@@ -23,9 +23,11 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.Scripting.Extensi EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.Dynamic", "..\..\..\..\ndp\fx\src\Dynamic\System\Dynamic\Microsoft.Dynamic.csproj", "{D4AE44AD-07B9-41DC-BB3B-1FDCDE3C987D}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.Scripting.Debugging", "..\..\Debugging\Microsoft.Scripting.Debugging\Microsoft.Scripting.Debugging.csproj", "{ED82A346-1CD9-4CB0-9C00-4CDD4CF577CF}" +EndProject Global GlobalSection(TeamFoundationVersionControl) = preSolution - SccNumberOfProjects = 11 + SccNumberOfProjects = 12 SccEnterpriseProvider = {4CA58AB2-18FA-4F8D-95D4-32DDF27D184C} SccTeamFoundationServer = http://vstfdevdiv:8080/ SccProjectUniqueName0 = IronPython\\IronPython.csproj @@ -78,11 +80,16 @@ Global SccAuxPath9 = http://vstfdevdiv:8080 SccLocalPath9 = ..\\..\\..\\..\\ndp\\fx\\src\\Core\\Microsoft\\Scripting SccProvider9 = {4CA58AB2-18FA-4F8D-95D4-32DDF27D184C} - SccProjectUniqueName10 = ..\\..\\..\\..\\ndp\\fx\\src\\Dynamic\\System.Dynamic.csproj - SccProjectName10 = ../../../../ndp/fx/src/DynamicCom + SccProjectUniqueName10 = ..\\..\\..\\..\\ndp\\fx\\src\\Dynamic\\System\\Dynamic\\Microsoft.Dynamic.csproj + SccProjectName10 = ../../../../ndp/fx/src/Dynamic/System/Dynamic SccAuxPath10 = http://vstfdevdiv:8080 - SccLocalPath10 = ..\\..\\..\\..\\ndp\\fx\\src\\DynamicCom + SccLocalPath10 = ..\\..\\..\\..\\ndp\\fx\\src\\Dynamic\\System\\Dynamic SccProvider10 = {4CA58AB2-18FA-4F8D-95D4-32DDF27D184C} + SccProjectUniqueName11 = ..\\..\\Debugging\\Microsoft.Scripting.Debugging\\Microsoft.Scripting.Debugging.csproj + SccProjectName11 = ../../Debugging/Microsoft.Scripting.Debugging + SccAuxPath11 = http://vstfdevdiv:8080 + SccLocalPath11 = ..\\..\\Debugging\\Microsoft.Scripting.Debugging + SccProvider11 = {4CA58AB2-18FA-4F8D-95D4-32DDF27D184C} EndGlobalSection GlobalSection(SolutionConfigurationPlatforms) = preSolution Build Debug|Any CPU = Build Debug|Any CPU @@ -242,6 +249,24 @@ Global {D4AE44AD-07B9-41DC-BB3B-1FDCDE3C987D}.Signed Release|Any CPU.ActiveCfg = Release|Any CPU {D4AE44AD-07B9-41DC-BB3B-1FDCDE3C987D}.Silverlight Debug|Any CPU.ActiveCfg = Debug|Any CPU {D4AE44AD-07B9-41DC-BB3B-1FDCDE3C987D}.Silverlight Release|Any CPU.ActiveCfg = Release|Any CPU + {ED82A346-1CD9-4CB0-9C00-4CDD4CF577CF}.Build Debug|Any CPU.ActiveCfg = Debug|Any CPU + {ED82A346-1CD9-4CB0-9C00-4CDD4CF577CF}.Build Debug|Any CPU.Build.0 = Debug|Any CPU + {ED82A346-1CD9-4CB0-9C00-4CDD4CF577CF}.Build Release|Any CPU.ActiveCfg = Release|Any CPU + {ED82A346-1CD9-4CB0-9C00-4CDD4CF577CF}.Build Release|Any CPU.Build.0 = Release|Any CPU + {ED82A346-1CD9-4CB0-9C00-4CDD4CF577CF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {ED82A346-1CD9-4CB0-9C00-4CDD4CF577CF}.Debug|Any CPU.Build.0 = Debug|Any CPU + {ED82A346-1CD9-4CB0-9C00-4CDD4CF577CF}.FxCop|Any CPU.ActiveCfg = Release|Any CPU + {ED82A346-1CD9-4CB0-9C00-4CDD4CF577CF}.FxCop|Any CPU.Build.0 = Release|Any CPU + {ED82A346-1CD9-4CB0-9C00-4CDD4CF577CF}.Release|Any CPU.ActiveCfg = Release|Any CPU + {ED82A346-1CD9-4CB0-9C00-4CDD4CF577CF}.Release|Any CPU.Build.0 = Release|Any CPU + {ED82A346-1CD9-4CB0-9C00-4CDD4CF577CF}.Signed Debug|Any CPU.ActiveCfg = Debug|Any CPU + {ED82A346-1CD9-4CB0-9C00-4CDD4CF577CF}.Signed Debug|Any CPU.Build.0 = Debug|Any CPU + {ED82A346-1CD9-4CB0-9C00-4CDD4CF577CF}.Signed Release|Any CPU.ActiveCfg = Release|Any CPU + {ED82A346-1CD9-4CB0-9C00-4CDD4CF577CF}.Signed Release|Any CPU.Build.0 = Release|Any CPU + {ED82A346-1CD9-4CB0-9C00-4CDD4CF577CF}.Silverlight Debug|Any CPU.ActiveCfg = Silverlight Debug|Any CPU + {ED82A346-1CD9-4CB0-9C00-4CDD4CF577CF}.Silverlight Debug|Any CPU.Build.0 = Silverlight Debug|Any CPU + {ED82A346-1CD9-4CB0-9C00-4CDD4CF577CF}.Silverlight Release|Any CPU.ActiveCfg = Silverlight Release|Any CPU + {ED82A346-1CD9-4CB0-9C00-4CDD4CF577CF}.Silverlight Release|Any CPU.Build.0 = Silverlight Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE Merlin/Main/Languages/IronPython/IronPython.sln @@ -461,7 +461,7 @@ </ProjectReference> <ProjectReference Include="..\..\..\..\..\ndp\fx\src\Dynamic\System\Dynamic\Microsoft.Dynamic.csproj" Condition=" '$(SilverlightBuild)' != 'true' "> <Project>{D4AE44AD-07B9-41DC-BB3B-1FDCDE3C987D}</Project> - <Name>System.Dynamic</Name> + <Name>Microsoft.Dynamic</Name> </ProjectReference> <ProjectReference Include="..\..\..\Runtime\Microsoft.Scripting\Microsoft.Scripting.csproj"> <Project>{EB66B766-6354-4208-A3D4-AACBDCB5C3B3}</Project> @@ -533,4 +533,4 @@ <Target Name="AfterBuild"> </Target> --> -</Project> +</Project> \ No newline at end of file Merlin/Main/Languages/IronPython/IronPython/IronPython.csproj Merlin/Main/Languages/Ruby/IronRuby.Tests/IronRuby.Tests.Build.csproj @@ -151,6 +151,7 @@ Backtrace3.rb:0 } public void Backtrace4() { +#if TODO // TODO: need to fix interpreter if (_driver.Interpret) return; @@ -186,6 +187,7 @@ Backtrace4.rb:11:in `foo' Backtrace4.rb:10:in `foo' Backtrace4.rb:0 ", OutputFlags.Match); +#endif } } } \ No newline at end of file Merlin/Main/Languages/Ruby/IronRuby.Tests/Runtime/BacktraceTests.cs @@ -14,16 +14,19 @@ * ***************************************************************************/ using System; +using System.Collections.ObjectModel; +using System.Linq.Expressions; using System.Runtime.CompilerServices; using IronRuby.Builtins; namespace IronRuby.Runtime.Calls { public abstract partial class MethodDispatcher { - internal const int /*$$*/PrecompiledParameterCount = 5; + internal const int /*$$*/MaxPrecompiledArity = 5; + internal const int /*$$*/MaxInterpretedArity = 15; private static readonly Type[] RubyObjectMethodDispatchers = new[] { #if GENERATOR - def generate; add_generic_types($PrecompiledParameterCount); end + def generate; add_generic_types($MaxPrecompiledArity); end #else typeof(RubyObjectMethodDispatcher<>), #endif @@ -37,7 +40,7 @@ namespace IronRuby.Runtime.Calls { private static readonly Type[] RubyObjectMethodDispatchersWithBlock = new[] { #if GENERATOR - def generate; add_generic_types($PrecompiledParameterCount); end + def generate; add_generic_types($MaxPrecompiledArity); end #else typeof(RubyObjectMethodDispatcherWithBlock<>), #endif @@ -51,7 +54,7 @@ namespace IronRuby.Runtime.Calls { private static readonly Type[] RubyObjectMethodDispatchersWithScope = new[] { #if GENERATOR - def generate; add_generic_types($PrecompiledParameterCount); end + def generate; add_generic_types($MaxPrecompiledArity); end #else typeof(RubyObjectMethodDispatcherWithScope<>), #endif @@ -65,7 +68,7 @@ namespace IronRuby.Runtime.Calls { private static readonly Type[] RubyObjectMethodDispatchersWithScopeAndBlock = new[] { #if GENERATOR - def generate; add_generic_types($PrecompiledParameterCount); end + def generate; add_generic_types($MaxPrecompiledArity); end #else typeof(RubyObjectMethodDispatcherWithScopeAndBlock<>), #endif @@ -76,36 +79,66 @@ namespace IronRuby.Runtime.Calls { typeof(RubyObjectMethodDispatcherWithScopeAndBlock<,,,,>), #endregion }; - } + private static readonly Type[] InterpretedFuncDispatchers = new[] { #if GENERATOR - def generate - $PrecompiledParameterCount.times { |n| @n = n + 1; super } - end - - def GenericDecl - "<" + Array.new(@n) { |i| "T#{i}" }.join(", ") + ">" - end - - def GenericParams - Array.new(@n) { |i| "T#{i}," }.join(" ") - end - - def Objects *args - ", object" * @n - end + def generate; add_generic_types($MaxInterpretedArity + 1); end +#else + typeof(InterpretedFuncDispatcher<>), +#endif +#region Generated by MethodDispatcher.Generator.rb + typeof(InterpretedFuncDispatcher<,>), + typeof(InterpretedFuncDispatcher<,,>), + typeof(InterpretedFuncDispatcher<,,,>), + typeof(InterpretedFuncDispatcher<,,,,>), + typeof(InterpretedFuncDispatcher<,,,,,>), + typeof(InterpretedFuncDispatcher<,,,,,,>), + typeof(InterpretedFuncDispatcher<,,,,,,,>), + typeof(InterpretedFuncDispatcher<,,,,,,,,>), + typeof(InterpretedFuncDispatcher<,,,,,,,,,>), + typeof(InterpretedFuncDispatcher<,,,,,,,,,,>), + typeof(InterpretedFuncDispatcher<,,,,,,,,,,,>), + typeof(InterpretedFuncDispatcher<,,,,,,,,,,,,>), + typeof(InterpretedFuncDispatcher<,,,,,,,,,,,,,>), + typeof(InterpretedFuncDispatcher<,,,,,,,,,,,,,,>), + typeof(InterpretedFuncDispatcher<,,,,,,,,,,,,,,,>), +#endregion + }; - def Parameters - "," + Array.new(@n) { |i| "T#{i} arg#{i}" }.join(", ") - end + private static readonly Type[] InterpretedActionDispatchers = new[] { + typeof(InterpretedActionDispatcher), +#if GENERATOR + def generate; add_generic_types($MaxInterpretedArity); end +#else + typeof(InterpretedActionDispatcher<>), +#endif +#region Generated by MethodDispatcher.Generator.rb + typeof(InterpretedActionDispatcher<,>), + typeof(InterpretedActionDispatcher<,,>), + typeof(InterpretedActionDispatcher<,,,>), + typeof(InterpretedActionDispatcher<,,,,>), + typeof(InterpretedActionDispatcher<,,,,,>), + typeof(InterpretedActionDispatcher<,,,,,,>), + typeof(InterpretedActionDispatcher<,,,,,,,>), + typeof(InterpretedActionDispatcher<,,,,,,,,>), + typeof(InterpretedActionDispatcher<,,,,,,,,,>), + typeof(InterpretedActionDispatcher<,,,,,,,,,,>), + typeof(InterpretedActionDispatcher<,,,,,,,,,,,>), + typeof(InterpretedActionDispatcher<,,,,,,,,,,,,>), + typeof(InterpretedActionDispatcher<,,,,,,,,,,,,,>), + typeof(InterpretedActionDispatcher<,,,,,,,,,,,,,,>), +#endregion + }; + } - def Arguments - "," + Array.new(@n) { |i| "arg#{i}" }.join(", ") +#if GENERATOR + def generate + $MaxPrecompiledArity.times { |n| @n = n + 1; super } end #else public class RubyObjectMethodDispatcher/*$GenericDecl*/ : MethodDispatcher<Func<object, Proc, object/*$Objects*/>> { public override object/*!*/ CreateDelegate() { - return new Func<CallSite, object, /*$GenericParams*/ object>(Invoke); + return new Func<CallSite, object /*$GenericParams*/, object>(Invoke); } public object Invoke(CallSite/*!*/ callSite, object self /*$Parameters*/) { @@ -113,7 +146,7 @@ namespace IronRuby.Runtime.Calls { if (obj != null && obj.ImmediateClass.Version.Value == Version) { return Method(self, null /*$Arguments*/); } else { - return ((CallSite<Func<CallSite, object, /*$GenericParams*/ object>>)callSite). + return ((CallSite<Func<CallSite, object /*$GenericParams*/, object>>)callSite). Update(callSite, self /*$Arguments*/); } } @@ -121,7 +154,7 @@ namespace IronRuby.Runtime.Calls { public class RubyObjectMethodDispatcherWithScope/*$GenericDecl*/ : MethodDispatcher<Func<object, Proc, object/*$Objects*/>> { public override object/*!*/ CreateDelegate() { - return new Func<CallSite, RubyScope, object, /*$GenericParams*/ object>(Invoke); + return new Func<CallSite, RubyScope, object /*$GenericParams*/, object>(Invoke); } public object Invoke(CallSite/*!*/ callSite, RubyScope/*!*/ scope, object self /*$Parameters*/) { @@ -129,7 +162,7 @@ namespace IronRuby.Runtime.Calls { if (obj != null && obj.ImmediateClass.Version.Value == Version) { return Method(self, null /*$Arguments*/); } else { - return ((CallSite<Func<CallSite, RubyScope, object, /*$GenericParams*/ object>>)callSite). + return ((CallSite<Func<CallSite, RubyScope, object /*$GenericParams*/, object>>)callSite). Update(callSite, scope, self /*$Arguments*/); } } @@ -137,7 +170,7 @@ namespace IronRuby.Runtime.Calls { public class RubyObjectMethodDispatcherWithBlock/*$GenericDecl*/ : MethodDispatcher<Func<object, Proc, object/*$Objects*/>> { public override object/*!*/ CreateDelegate() { - return new Func<CallSite, object, Proc, /*$GenericParams*/ object>(Invoke); + return new Func<CallSite, object, Proc /*$GenericParams*/, object>(Invoke); } public object Invoke(CallSite/*!*/ callSite, object self, Proc proc /*$Parameters*/) { @@ -157,7 +190,7 @@ namespace IronRuby.Runtime.Calls { RubyOps.LeaveMethodFrame(rfc); } } else { - return ((CallSite<Func<CallSite, object, Proc, /*$GenericParams*/ object>>)callSite). + return ((CallSite<Func<CallSite, object, Proc /*$GenericParams*/, object>>)callSite). Update(callSite, self, proc /*$Arguments*/); } } @@ -165,7 +198,7 @@ namespace IronRuby.Runtime.Calls { public class RubyObjectMethodDispatcherWithScopeAndBlock/*$GenericDecl*/ : MethodDispatcher<Func<object, Proc, object/*$Objects*/>> { public override object/*!*/ CreateDelegate() { - return new Func<CallSite, RubyScope, object, Proc, /*$GenericParams*/ object>(Invoke); + return new Func<CallSite, RubyScope, object, Proc /*$GenericParams*/, object>(Invoke); } public object Invoke(CallSite/*!*/ callSite, RubyScope/*!*/ scope, object self, Proc proc /*$Parameters*/) { @@ -185,7 +218,7 @@ namespace IronRuby.Runtime.Calls { RubyOps.LeaveMethodFrame(rfc); } } else { - return ((CallSite<Func<CallSite, RubyScope, object, Proc, /*$GenericParams*/ object>>)callSite). + return ((CallSite<Func<CallSite, RubyScope, object, Proc /*$GenericParams*/, object>>)callSite). Update(callSite, scope, self, proc /*$Arguments*/); } } @@ -194,7 +227,7 @@ namespace IronRuby.Runtime.Calls { #region Generated by MethodDispatcher.Generator.rb public class RubyObjectMethodDispatcher<T0> : MethodDispatcher<Func<object, Proc, object, object>> { public override object/*!*/ CreateDelegate() { - return new Func<CallSite, object, T0, object>(Invoke); + return new Func<CallSite, object , T0, object>(Invoke); } public object Invoke(CallSite/*!*/ callSite, object self ,T0 arg0) { @@ -202,7 +235,7 @@ namespace IronRuby.Runtime.Calls { if (obj != null && obj.ImmediateClass.Version.Value == Version) { return Method(self, null ,arg0); } else { - return ((CallSite<Func<CallSite, object, T0, object>>)callSite). + return ((CallSite<Func<CallSite, object , T0, object>>)callSite). Update(callSite, self ,arg0); } } @@ -210,7 +243,7 @@ namespace IronRuby.Runtime.Calls { public class RubyObjectMethodDispatcherWithScope<T0> : MethodDispatcher<Func<object, Proc, object, object>> { public override object/*!*/ CreateDelegate() { - return new Func<CallSite, RubyScope, object, T0, object>(Invoke); + return new Func<CallSite, RubyScope, object , T0, object>(Invoke); } public object Invoke(CallSite/*!*/ callSite, RubyScope/*!*/ scope, object self ,T0 arg0) { @@ -218,7 +251,7 @@ namespace IronRuby.Runtime.Calls { if (obj != null && obj.ImmediateClass.Version.Value == Version) { return Method(self, null ,arg0); } else { - return ((CallSite<Func<CallSite, RubyScope, object, T0, object>>)callSite). + return ((CallSite<Func<CallSite, RubyScope, object , T0, object>>)callSite). Update(callSite, scope, self ,arg0); } } @@ -226,7 +259,7 @@ namespace IronRuby.Runtime.Calls { public class RubyObjectMethodDispatcherWithBlock<T0> : MethodDispatcher<Func<object, Proc, object, object>> { public override object/*!*/ CreateDelegate() { - return new Func<CallSite, object, Proc, T0, object>(Invoke); + return new Func<CallSite, object, Proc , T0, object>(Invoke); } public object Invoke(CallSite/*!*/ callSite, object self, Proc proc ,T0 arg0) { @@ -246,7 +279,7 @@ namespace IronRuby.Runtime.Calls { RubyOps.LeaveMethodFrame(rfc); } } else { - return ((CallSite<Func<CallSite, object, Proc, T0, object>>)callSite). + return ((CallSite<Func<CallSite, object, Proc , T0, object>>)callSite). Update(callSite, self, proc ,arg0); } } @@ -254,7 +287,7 @@ namespace IronRuby.Runtime.Calls { public class RubyObjectMethodDispatcherWithScopeAndBlock<T0> : MethodDispatcher<Func<object, Proc, object, object>> { public override object/*!*/ CreateDelegate() { - return new Func<CallSite, RubyScope, object, Proc, T0, object>(Invoke); + return new Func<CallSite, RubyScope, object, Proc , T0, object>(Invoke); } public object Invoke(CallSite/*!*/ callSite, RubyScope/*!*/ scope, object self, Proc proc ,T0 arg0) { @@ -274,14 +307,14 @@ namespace IronRuby.Runtime.Calls { RubyOps.LeaveMethodFrame(rfc); } } else { - return ((CallSite<Func<CallSite, RubyScope, object, Proc, T0, object>>)callSite). + return ((CallSite<Func<CallSite, RubyScope, object, Proc , T0, object>>)callSite). Update(callSite, scope, self, proc ,arg0); } } } public class RubyObjectMethodDispatcher<T0, T1> : MethodDispatcher<Func<object, Proc, object, object, object>> { public override object/*!*/ CreateDelegate() { - return new Func<CallSite, object, T0, T1, object>(Invoke); + return new Func<CallSite, object , T0 , T1, object>(Invoke); } public object Invoke(CallSite/*!*/ callSite, object self ,T0 arg0, T1 arg1) { @@ -289,7 +322,7 @@ namespace IronRuby.Runtime.Calls { if (obj != null && obj.ImmediateClass.Version.Value == Version) { return Method(self, null ,arg0, arg1); } else { - return ((CallSite<Func<CallSite, object, T0, T1, object>>)callSite). + return ((CallSite<Func<CallSite, object , T0 , T1, object>>)callSite). Update(callSite, self ,arg0, arg1); } } @@ -297,7 +330,7 @@ namespace IronRuby.Runtime.Calls { public class RubyObjectMethodDispatcherWithScope<T0, T1> : MethodDispatcher<Func<object, Proc, object, object, object>> { public override object/*!*/ CreateDelegate() { - return new Func<CallSite, RubyScope, object, T0, T1, object>(Invoke); + return new Func<CallSite, RubyScope, object , T0 , T1, object>(Invoke); } public object Invoke(CallSite/*!*/ callSite, RubyScope/*!*/ scope, object self ,T0 arg0, T1 arg1) { @@ -305,7 +338,7 @@ namespace IronRuby.Runtime.Calls { if (obj != null && obj.ImmediateClass.Version.Value == Version) { return Method(self, null ,arg0, arg1); } else { - return ((CallSite<Func<CallSite, RubyScope, object, T0, T1, object>>)callSite). + return ((CallSite<Func<CallSite, RubyScope, object , T0 , T1, object>>)callSite). Update(callSite, scope, self ,arg0, arg1); } } @@ -313,7 +346,7 @@ namespace IronRuby.Runtime.Calls { public class RubyObjectMethodDispatcherWithBlock<T0, T1> : MethodDispatcher<Func<object, Proc, object, object, object>> { public override object/*!*/ CreateDelegate() { - return new Func<CallSite, object, Proc, T0, T1, object>(Invoke); + return new Func<CallSite, object, Proc , T0 , T1, object>(Invoke); } public object Invoke(CallSite/*!*/ callSite, object self, Proc proc ,T0 arg0, T1 arg1) { @@ -333,7 +366,7 @@ namespace IronRuby.Runtime.Calls { RubyOps.LeaveMethodFrame(rfc); } } else { - return ((CallSite<Func<CallSite, object, Proc, T0, T1, object>>)callSite). + return ((CallSite<Func<CallSite, object, Proc , T0 , T1, object>>)callSite). Update(callSite, self, proc ,arg0, arg1); } } @@ -341,7 +374,7 @@ namespace IronRuby.Runtime.Calls { public class RubyObjectMethodDispatcherWithScopeAndBlock<T0, T1> : MethodDispatcher<Func<object, Proc, object, object, object>> { public override object/*!*/ CreateDelegate() { - return new Func<CallSite, RubyScope, object, Proc, T0, T1, object>(Invoke); + return new Func<CallSite, RubyScope, object, Proc , T0 , T1, object>(Invoke); } public object Invoke(CallSite/*!*/ callSite, RubyScope/*!*/ scope, object self, Proc proc ,T0 arg0, T1 arg1) { @@ -361,14 +394,14 @@ namespace IronRuby.Runtime.Calls { RubyOps.LeaveMethodFrame(rfc); } } else { - return ((CallSite<Func<CallSite, RubyScope, object, Proc, T0, T1, object>>)callSite). + return ((CallSite<Func<CallSite, RubyScope, object, Proc , T0 , T1, object>>)callSite). Update(callSite, scope, self, proc ,arg0, arg1); } } } public class RubyObjectMethodDispatcher<T0, T1, T2> : MethodDispatcher<Func<object, Proc, object, object, object, object>> { public override object/*!*/ CreateDelegate() { - return new Func<CallSite, object, T0, T1, T2, object>(Invoke); + return new Func<CallSite, object , T0 , T1 , T2, object>(Invoke); } public object Invoke(CallSite/*!*/ callSite, object self ,T0 arg0, T1 arg1, T2 arg2) { @@ -376,7 +409,7 @@ namespace IronRuby.Runtime.Calls { if (obj != null && obj.ImmediateClass.Version.Value == Version) { return Method(self, null ,arg0, arg1, arg2); } else { - return ((CallSite<Func<CallSite, object, T0, T1, T2, object>>)callSite). + return ((CallSite<Func<CallSite, object , T0 , T1 , T2, object>>)callSite). Update(callSite, self ,arg0, arg1, arg2); } } @@ -384,7 +417,7 @@ namespace IronRuby.Runtime.Calls { public class RubyObjectMethodDispatcherWithScope<T0, T1, T2> : MethodDispatcher<Func<object, Proc, object, object, object, object>> { public override object/*!*/ CreateDelegate() { - return new Func<CallSite, RubyScope, object, T0, T1, T2, object>(Invoke); + return new Func<CallSite, RubyScope, object , T0 , T1 , T2, object>(Invoke); } public object Invoke(CallSite/*!*/ callSite, RubyScope/*!*/ scope, object self ,T0 arg0, T1 arg1, T2 arg2) { @@ -392,7 +425,7 @@ namespace IronRuby.Runtime.Calls { if (obj != null && obj.ImmediateClass.Version.Value == Version) { return Method(self, null ,arg0, arg1, arg2); } else { - return ((CallSite<Func<CallSite, RubyScope, object, T0, T1, T2, object>>)callSite). + return ((CallSite<Func<CallSite, RubyScope, object , T0 , T1 , T2, object>>)callSite). Update(callSite, scope, self ,arg0, arg1, arg2); } } @@ -400,7 +433,7 @@ namespace IronRuby.Runtime.Calls { public class RubyObjectMethodDispatcherWithBlock<T0, T1, T2> : MethodDispatcher<Func<object, Proc, object, object, object, object>> { public override object/*!*/ CreateDelegate() { - return new Func<CallSite, object, Proc, T0, T1, T2, object>(Invoke); + return new Func<CallSite, object, Proc , T0 , T1 , T2, object>(Invoke); } public object Invoke(CallSite/*!*/ callSite, object self, Proc proc ,T0 arg0, T1 arg1, T2 arg2) { @@ -420,7 +453,7 @@ namespace IronRuby.Runtime.Calls { RubyOps.LeaveMethodFrame(rfc); } } else { - return ((CallSite<Func<CallSite, object, Proc, T0, T1, T2, object>>)callSite). + return ((CallSite<Func<CallSite, object, Proc , T0 , T1 , T2, object>>)callSite). Update(callSite, self, proc ,arg0, arg1, arg2); } } @@ -428,7 +461,7 @@ namespace IronRuby.Runtime.Calls { public class RubyObjectMethodDispatcherWithScopeAndBlock<T0, T1, T2> : MethodDispatcher<Func<object, Proc, object, object, object, object>> { public override object/*!*/ CreateDelegate() { - return new Func<CallSite, RubyScope, object, Proc, T0, T1, T2, object>(Invoke); + return new Func<CallSite, RubyScope, object, Proc , T0 , T1 , T2, object>(Invoke); } public object Invoke(CallSite/*!*/ callSite, RubyScope/*!*/ scope, object self, Proc proc ,T0 arg0, T1 arg1, T2 arg2) { @@ -448,14 +481,14 @@ namespace IronRuby.Runtime.Calls { RubyOps.LeaveMethodFrame(rfc); } } else { - return ((CallSite<Func<CallSite, RubyScope, object, Proc, T0, T1, T2, object>>)callSite). + return ((CallSite<Func<CallSite, RubyScope, object, Proc , T0 , T1 , T2, object>>)callSite). Update(callSite, scope, self, proc ,arg0, arg1, arg2); } } } public class RubyObjectMethodDispatcher<T0, T1, T2, T3> : MethodDispatcher<Func<object, Proc, object, object, object, object, object>> { public override object/*!*/ CreateDelegate() { - return new Func<CallSite, object, T0, T1, T2, T3, object>(Invoke); + return new Func<CallSite, object , T0 , T1 , T2 , T3, object>(Invoke); } public object Invoke(CallSite/*!*/ callSite, object self ,T0 arg0, T1 arg1, T2 arg2, T3 arg3) { @@ -463,7 +496,7 @@ namespace IronRuby.Runtime.Calls { if (obj != null && obj.ImmediateClass.Version.Value == Version) { return Method(self, null ,arg0, arg1, arg2, arg3); } else { - return ((CallSite<Func<CallSite, object, T0, T1, T2, T3, object>>)callSite). + return ((CallSite<Func<CallSite, object , T0 , T1 , T2 , T3, object>>)callSite). Update(callSite, self ,arg0, arg1, arg2, arg3); } } @@ -471,7 +504,7 @@ namespace IronRuby.Runtime.Calls { public class RubyObjectMethodDispatcherWithScope<T0, T1, T2, T3> : MethodDispatcher<Func<object, Proc, object, object, object, object, object>> { public override object/*!*/ CreateDelegate() { - return new Func<CallSite, RubyScope, object, T0, T1, T2, T3, object>(Invoke); + return new Func<CallSite, RubyScope, object , T0 , T1 , T2 , T3, object>(Invoke); } public object Invoke(CallSite/*!*/ callSite, RubyScope/*!*/ scope, object self ,T0 arg0, T1 arg1, T2 arg2, T3 arg3) { @@ -479,7 +512,7 @@ namespace IronRuby.Runtime.Calls { if (obj != null && obj.ImmediateClass.Version.Value == Version) { return Method(self, null ,arg0, arg1, arg2, arg3); } else { - return ((CallSite<Func<CallSite, RubyScope, object, T0, T1, T2, T3, object>>)callSite). + return ((CallSite<Func<CallSite, RubyScope, object , T0 , T1 , T2 , T3, object>>)callSite). Update(callSite, scope, self ,arg0, arg1, arg2, arg3); } } @@ -487,7 +520,7 @@ namespace IronRuby.Runtime.Calls { public class RubyObjectMethodDispatcherWithBlock<T0, T1, T2, T3> : MethodDispatcher<Func<object, Proc, object, object, object, object, object>> { public override object/*!*/ CreateDelegate() { - return new Func<CallSite, object, Proc, T0, T1, T2, T3, object>(Invoke); + return new Func<CallSite, object, Proc , T0 , T1 , T2 , T3, object>(Invoke); } public object Invoke(CallSite/*!*/ callSite, object self, Proc proc ,T0 arg0, T1 arg1, T2 arg2, T3 arg3) { @@ -507,7 +540,7 @@ namespace IronRuby.Runtime.Calls { RubyOps.LeaveMethodFrame(rfc); } } else { - return ((CallSite<Func<CallSite, object, Proc, T0, T1, T2, T3, object>>)callSite). + return ((CallSite<Func<CallSite, object, Proc , T0 , T1 , T2 , T3, object>>)callSite). Update(callSite, self, proc ,arg0, arg1, arg2, arg3); } } @@ -515,7 +548,7 @@ namespace IronRuby.Runtime.Calls { public class RubyObjectMethodDispatcherWithScopeAndBlock<T0, T1, T2, T3> : MethodDispatcher<Func<object, Proc, object, object, object, object, object>> { public override object/*!*/ CreateDelegate() { - return new Func<CallSite, RubyScope, object, Proc, T0, T1, T2, T3, object>(Invoke); + return new Func<CallSite, RubyScope, object, Proc , T0 , T1 , T2 , T3, object>(Invoke); } public object Invoke(CallSite/*!*/ callSite, RubyScope/*!*/ scope, object self, Proc proc ,T0 arg0, T1 arg1, T2 arg2, T3 arg3) { @@ -535,14 +568,14 @@ namespace IronRuby.Runtime.Calls { RubyOps.LeaveMethodFrame(rfc); } } else { - return ((CallSite<Func<CallSite, RubyScope, object, Proc, T0, T1, T2, T3, object>>)callSite). + return ((CallSite<Func<CallSite, RubyScope, object, Proc , T0 , T1 , T2 , T3, object>>)callSite). Update(callSite, scope, self, proc ,arg0, arg1, arg2, arg3); } } } public class RubyObjectMethodDispatcher<T0, T1, T2, T3, T4> : MethodDispatcher<Func<object, Proc, object, object, object, object, object, object>> { public override object/*!*/ CreateDelegate() { - return new Func<CallSite, object, T0, T1, T2, T3, T4, object>(Invoke); + return new Func<CallSite, object , T0 , T1 , T2 , T3 , T4, object>(Invoke); } public object Invoke(CallSite/*!*/ callSite, object self ,T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { @@ -550,7 +583,7 @@ namespace IronRuby.Runtime.Calls { if (obj != null && obj.ImmediateClass.Version.Value == Version) { return Method(self, null ,arg0, arg1, arg2, arg3, arg4); } else { - return ((CallSite<Func<CallSite, object, T0, T1, T2, T3, T4, object>>)callSite). + return ((CallSite<Func<CallSite, object , T0 , T1 , T2 , T3 , T4, object>>)callSite). Update(callSite, self ,arg0, arg1, arg2, arg3, arg4); } } @@ -558,7 +591,7 @@ namespace IronRuby.Runtime.Calls { public class RubyObjectMethodDispatcherWithScope<T0, T1, T2, T3, T4> : MethodDispatcher<Func<object, Proc, object, object, object, object, object, object>> { public override object/*!*/ CreateDelegate() { - return new Func<CallSite, RubyScope, object, T0, T1, T2, T3, T4, object>(Invoke); + return new Func<CallSite, RubyScope, object , T0 , T1 , T2 , T3 , T4, object>(Invoke); } public object Invoke(CallSite/*!*/ callSite, RubyScope/*!*/ scope, object self ,T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { @@ -566,7 +599,7 @@ namespace IronRuby.Runtime.Calls { if (obj != null && obj.ImmediateClass.Version.Value == Version) { return Method(self, null ,arg0, arg1, arg2, arg3, arg4); } else { - return ((CallSite<Func<CallSite, RubyScope, object, T0, T1, T2, T3, T4, object>>)callSite). + return ((CallSite<Func<CallSite, RubyScope, object , T0 , T1 , T2 , T3 , T4, object>>)callSite). Update(callSite, scope, self ,arg0, arg1, arg2, arg3, arg4); } } @@ -574,7 +607,7 @@ namespace IronRuby.Runtime.Calls { public class RubyObjectMethodDispatcherWithBlock<T0, T1, T2, T3, T4> : MethodDispatcher<Func<object, Proc, object, object, object, object, object, object>> { public override object/*!*/ CreateDelegate() { - return new Func<CallSite, object, Proc, T0, T1, T2, T3, T4, object>(Invoke); + return new Func<CallSite, object, Proc , T0 , T1 , T2 , T3 , T4, object>(Invoke); } public object Invoke(CallSite/*!*/ callSite, object self, Proc proc ,T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { @@ -594,7 +627,7 @@ namespace IronRuby.Runtime.Calls { RubyOps.LeaveMethodFrame(rfc); } } else { - return ((CallSite<Func<CallSite, object, Proc, T0, T1, T2, T3, T4, object>>)callSite). + return ((CallSite<Func<CallSite, object, Proc , T0 , T1 , T2 , T3 , T4, object>>)callSite). Update(callSite, self, proc ,arg0, arg1, arg2, arg3, arg4); } } @@ -602,7 +635,7 @@ namespace IronRuby.Runtime.Calls { public class RubyObjectMethodDispatcherWithScopeAndBlock<T0, T1, T2, T3, T4> : MethodDispatcher<Func<object, Proc, object, object, object, object, object, object>> { public override object/*!*/ CreateDelegate() { - return new Func<CallSite, RubyScope, object, Proc, T0, T1, T2, T3, T4, object>(Invoke); + return new Func<CallSite, RubyScope, object, Proc , T0 , T1 , T2 , T3 , T4, object>(Invoke); } public object Invoke(CallSite/*!*/ callSite, RubyScope/*!*/ scope, object self, Proc proc ,T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { @@ -622,11 +655,740 @@ namespace IronRuby.Runtime.Calls { RubyOps.LeaveMethodFrame(rfc); } } else { - return ((CallSite<Func<CallSite, RubyScope, object, Proc, T0, T1, T2, T3, T4, object>>)callSite). + return ((CallSite<Func<CallSite, RubyScope, object, Proc , T0 , T1 , T2 , T3 , T4, object>>)callSite). Update(callSite, scope, self, proc ,arg0, arg1, arg2, arg3, arg4); } } } #endregion +#if GENERATOR + def generate + $MaxInterpretedArity.times { |n| @n = n + 1; super } + end +#else + public class InterpretedFuncDispatcher/*$GenericDeclWithReturn{*/<TReturn>/*}*/ : InterpretedDispatcher { + internal static readonly ReadOnlyCollection<ParameterExpression> _Parameters = + new ReadOnlyCollection<ParameterExpression>(new ParameterExpression[] { + /*$ParameterExpressions*/ + }); + + internal static readonly LabelTarget _ReturnLabel = Expression.Label(typeof(TReturn)); + + internal override ReadOnlyCollection<ParameterExpression> Parameters { get { return _Parameters; } } + internal override LabelTarget ReturnLabel { get { return _ReturnLabel; } } + + internal override object/*!*/ GetInterpretingDelegate() { + return new Func<CallSite /*$GenericParams*/, TReturn>(Invoke); + } + + public TReturn Invoke(CallSite/*!*/ callSite/*$Parameters*/) { + if (_compiled != null) { + ((CallSite<Func<CallSite /*$GenericParams*/, TReturn>>)callSite).Target = (Func<CallSite /*$GenericParams*/, TReturn>)_compiled; + } + return ((Func<CallSite /*$GenericParams*/, TReturn>)_rule)(callSite /*$Arguments*/); + } + } + + public class InterpretedActionDispatcher/*$GenericDecl*/ : InterpretedDispatcher { + internal static readonly ReadOnlyCollection<ParameterExpression> _Parameters = + new ReadOnlyCollection<ParameterExpression>(new ParameterExpression[] { + /*$ParameterExpressions*/ + }); + + internal static readonly LabelTarget _ReturnLabel = Expression.Label(typeof(void)); + + internal override ReadOnlyCollection<ParameterExpression> Parameters { get { return _Parameters; } } + internal override LabelTarget ReturnLabel { get { return _ReturnLabel; } } + + internal override object/*!*/ GetInterpretingDelegate() { + return new Action<CallSite/*$GenericParams*/>(Invoke); + } + + public void Invoke(CallSite/*!*/ callSite/*$Parameters*/) { + if (_compiled != null) { + ((CallSite<Action<CallSite/*$GenericParams*/>>)callSite).Target = (Action<CallSite/*$GenericParams*/>)_compiled; + } + ((Action<CallSite/*$GenericParams*/>)_rule)(callSite /*$Arguments*/); + } + } +#endif +#region Generated by MethodDispatcher.Generator.rb + public class InterpretedFuncDispatcher<T0, TReturn> : InterpretedDispatcher { + internal static readonly ReadOnlyCollection<ParameterExpression> _Parameters = + new ReadOnlyCollection<ParameterExpression>(new ParameterExpression[] { + Expression.Parameter(typeof(T0), "$arg0") + }); + + internal static readonly LabelTarget _ReturnLabel = Expression.Label(typeof(TReturn)); + + internal override ReadOnlyCollection<ParameterExpression> Parameters { get { return _Parameters; } } + internal override LabelTarget ReturnLabel { get { return _ReturnLabel; } } + + internal override object/*!*/ GetInterpretingDelegate() { + return new Func<CallSite , T0, TReturn>(Invoke); + } + + public TReturn Invoke(CallSite/*!*/ callSite,T0 arg0) { + if (_compiled != null) { + ((CallSite<Func<CallSite , T0, TReturn>>)callSite).Target = (Func<CallSite , T0, TReturn>)_compiled; + } + return ((Func<CallSite , T0, TReturn>)_rule)(callSite ,arg0); + } + } + + public class InterpretedActionDispatcher<T0> : InterpretedDispatcher { + internal static readonly ReadOnlyCollection<ParameterExpression> _Parameters = + new ReadOnlyCollection<ParameterExpression>(new ParameterExpression[] { + Expression.Parameter(typeof(T0), "$arg0") + }); + + internal static readonly LabelTarget _ReturnLabel = Expression.Label(typeof(void)); + + internal override ReadOnlyCollection<ParameterExpression> Parameters { get { return _Parameters; } } + internal override LabelTarget ReturnLabel { get { return _ReturnLabel; } } + + internal override object/*!*/ GetInterpretingDelegate() { + return new Action<CallSite, T0>(Invoke); + } + + public void Invoke(CallSite/*!*/ callSite,T0 arg0) { + if (_compiled != null) { + ((CallSite<Action<CallSite, T0>>)callSite).Target = (Action<CallSite, T0>)_compiled; + } + ((Action<CallSite, T0>)_rule)(callSite ,arg0); + } + } + public class InterpretedFuncDispatcher<T0, T1, TReturn> : InterpretedDispatcher { + internal static readonly ReadOnlyCollection<ParameterExpression> _Parameters = + new ReadOnlyCollection<ParameterExpression>(new ParameterExpression[] { + Expression.Parameter(typeof(T0), "$arg0"), Expression.Parameter(typeof(T1), "$arg1") + }); + + internal static readonly LabelTarget _ReturnLabel = Expression.Label(typeof(TReturn)); + + internal override ReadOnlyCollection<ParameterExpression> Parameters { get { return _Parameters; } } + internal override LabelTarget ReturnLabel { get { return _ReturnLabel; } } + + internal override object/*!*/ GetInterpretingDelegate() { + return new Func<CallSite , T0 , T1, TReturn>(Invoke); + } + + public TReturn Invoke(CallSite/*!*/ callSite,T0 arg0, T1 arg1) { + if (_compiled != null) { + ((CallSite<Func<CallSite , T0 , T1, TReturn>>)callSite).Target = (Func<CallSite , T0 , T1, TReturn>)_compiled; + } + return ((Func<CallSite , T0 , T1, TReturn>)_rule)(callSite ,arg0, arg1); + } + } + + public class InterpretedActionDispatcher<T0, T1> : InterpretedDispatcher { + internal static readonly ReadOnlyCollection<ParameterExpression> _Parameters = + new ReadOnlyCollection<ParameterExpression>(new ParameterExpression[] { + Expression.Parameter(typeof(T0), "$arg0"), Expression.Parameter(typeof(T1), "$arg1") + }); + + internal static readonly LabelTarget _ReturnLabel = Expression.Label(typeof(void)); + + internal override ReadOnlyCollection<ParameterExpression> Parameters { get { return _Parameters; } } + internal override LabelTarget ReturnLabel { get { return _ReturnLabel; } } + + internal override object/*!*/ GetInterpretingDelegate() { + return new Action<CallSite, T0 , T1>(Invoke); + } + + public void Invoke(CallSite/*!*/ callSite,T0 arg0, T1 arg1) { + if (_compiled != null) { + ((CallSite<Action<CallSite, T0 , T1>>)callSite).Target = (Action<CallSite, T0 , T1>)_compiled; + } + ((Action<CallSite, T0 , T1>)_rule)(callSite ,arg0, arg1); + } + } + public class InterpretedFuncDispatcher<T0, T1, T2, TReturn> : InterpretedDispatcher { + internal static readonly ReadOnlyCollection<ParameterExpression> _Parameters = + new ReadOnlyCollection<ParameterExpression>(new ParameterExpression[] { + Expression.Parameter(typeof(T0), "$arg0"), Expression.Parameter(typeof(T1), "$arg1"), Expression.Parameter(typeof(T2), "$arg2") + }); + + internal static readonly LabelTarget _ReturnLabel = Expression.Label(typeof(TReturn)); + + internal override ReadOnlyCollection<ParameterExpression> Parameters { get { return _Parameters; } } + internal override LabelTarget ReturnLabel { get { return _ReturnLabel; } } + + internal override object/*!*/ GetInterpretingDelegate() { + return new Func<CallSite , T0 , T1 , T2, TReturn>(Invoke); + } + + public TReturn Invoke(CallSite/*!*/ callSite,T0 arg0, T1 arg1, T2 arg2) { + if (_compiled != null) { + ((CallSite<Func<CallSite , T0 , T1 , T2, TReturn>>)callSite).Target = (Func<CallSite , T0 , T1 , T2, TReturn>)_compiled; + } + return ((Func<CallSite , T0 , T1 , T2, TReturn>)_rule)(callSite ,arg0, arg1, arg2); + } + } + + public class InterpretedActionDispatcher<T0, T1, T2> : InterpretedDispatcher { + internal static readonly ReadOnlyCollection<ParameterExpression> _Parameters = + new ReadOnlyCollection<ParameterExpression>(new ParameterExpression[] { + Expression.Parameter(typeof(T0), "$arg0"), Expression.Parameter(typeof(T1), "$arg1"), Expression.Parameter(typeof(T2), "$arg2") + }); + + internal static readonly LabelTarget _ReturnLabel = Expression.Label(typeof(void)); + + internal override ReadOnlyCollection<ParameterExpression> Parameters { get { return _Parameters; } } + internal override LabelTarget ReturnLabel { get { return _ReturnLabel; } } + + internal override object/*!*/ GetInterpretingDelegate() { + return new Action<CallSite, T0 , T1 , T2>(Invoke); + } + + public void Invoke(CallSite/*!*/ callSite,T0 arg0, T1 arg1, T2 arg2) { + if (_compiled != null) { + ((CallSite<Action<CallSite, T0 , T1 , T2>>)callSite).Target = (Action<CallSite, T0 , T1 , T2>)_compiled; + } + ((Action<CallSite, T0 , T1 , T2>)_rule)(callSite ,arg0, arg1, arg2); + } + } + public class InterpretedFuncDispatcher<T0, T1, T2, T3, TReturn> : InterpretedDispatcher { + internal static readonly ReadOnlyCollection<ParameterExpression> _Parameters = + new ReadOnlyCollection<ParameterExpression>(new ParameterExpression[] { + Expression.Parameter(typeof(T0), "$arg0"), Expression.Parameter(typeof(T1), "$arg1"), Expression.Parameter(typeof(T2), "$arg2"), Expression.Parameter(typeof(T3), "$arg3") + }); + + internal static readonly LabelTarget _ReturnLabel = Expression.Label(typeof(TReturn)); + + internal override ReadOnlyCollection<ParameterExpression> Parameters { get { return _Parameters; } } + internal override LabelTarget ReturnLabel { get { return _ReturnLabel; } } + + internal override object/*!*/ GetInterpretingDelegate() { + return new Func<CallSite , T0 , T1 , T2 , T3, TReturn>(Invoke); + } + + public TReturn Invoke(CallSite/*!*/ callSite,T0 arg0, T1 arg1, T2 arg2, T3 arg3) { + if (_compiled != null) { + ((CallSite<Func<CallSite , T0 , T1 , T2 , T3, TReturn>>)callSite).Target = (Func<CallSite , T0 , T1 , T2 , T3, TReturn>)_compiled; + } + return ((Func<CallSite , T0 , T1 , T2 , T3, TReturn>)_rule)(callSite ,arg0, arg1, arg2, arg3); + } + } + + public class InterpretedActionDispatcher<T0, T1, T2, T3> : InterpretedDispatcher { + internal static readonly ReadOnlyCollection<ParameterExpression> _Parameters = + new ReadOnlyCollection<ParameterExpression>(new ParameterExpression[] { + Expression.Parameter(typeof(T0), "$arg0"), Expression.Parameter(typeof(T1), "$arg1"), Expression.Parameter(typeof(T2), "$arg2"), Expression.Parameter(typeof(T3), "$arg3") + }); + + internal static readonly LabelTarget _ReturnLabel = Expression.Label(typeof(void)); + + internal override ReadOnlyCollection<ParameterExpression> Parameters { get { return _Parameters; } } + internal override LabelTarget ReturnLabel { get { return _ReturnLabel; } } + + internal override object/*!*/ GetInterpretingDelegate() { + return new Action<CallSite, T0 , T1 , T2 , T3>(Invoke); + } + + public void Invoke(CallSite/*!*/ callSite,T0 arg0, T1 arg1, T2 arg2, T3 arg3) { + if (_compiled != null) { + ((CallSite<Action<CallSite, T0 , T1 , T2 , T3>>)callSite).Target = (Action<CallSite, T0 , T1 , T2 , T3>)_compiled; + } + ((Action<CallSite, T0 , T1 , T2 , T3>)_rule)(callSite ,arg0, arg1, arg2, arg3); + } + } + public class InterpretedFuncDispatcher<T0, T1, T2, T3, T4, TReturn> : InterpretedDispatcher { + internal static readonly ReadOnlyCollection<ParameterExpression> _Parameters = + new ReadOnlyCollection<ParameterExpression>(new ParameterExpression[] { + Expression.Parameter(typeof(T0), "$arg0"), Expression.Parameter(typeof(T1), "$arg1"), Expression.Parameter(typeof(T2), "$arg2"), Expression.Parameter(typeof(T3), "$arg3"), Expression.Parameter(typeof(T4), "$arg4") + }); + + internal static readonly LabelTarget _ReturnLabel = Expression.Label(typeof(TReturn)); + + internal override ReadOnlyCollection<ParameterExpression> Parameters { get { return _Parameters; } } + internal override LabelTarget ReturnLabel { get { return _ReturnLabel; } } + + internal override object/*!*/ GetInterpretingDelegate() { + return new Func<CallSite , T0 , T1 , T2 , T3 , T4, TReturn>(Invoke); + } + + public TReturn Invoke(CallSite/*!*/ callSite,T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { + if (_compiled != null) { + ((CallSite<Func<CallSite , T0 , T1 , T2 , T3 , T4, TReturn>>)callSite).Target = (Func<CallSite , T0 , T1 , T2 , T3 , T4, TReturn>)_compiled; + } + return ((Func<CallSite , T0 , T1 , T2 , T3 , T4, TReturn>)_rule)(callSite ,arg0, arg1, arg2, arg3, arg4); + } + } + + public class InterpretedActionDispatcher<T0, T1, T2, T3, T4> : InterpretedDispatcher { + internal static readonly ReadOnlyCollection<ParameterExpression> _Parameters = + new ReadOnlyCollection<ParameterExpression>(new ParameterExpression[] { + Expression.Parameter(typeof(T0), "$arg0"), Expression.Parameter(typeof(T1), "$arg1"), Expression.Parameter(typeof(T2), "$arg2"), Expression.Parameter(typeof(T3), "$arg3"), Expression.Parameter(typeof(T4), "$arg4") + }); + + internal static readonly LabelTarget _ReturnLabel = Expression.Label(typeof(void)); + + internal override ReadOnlyCollection<ParameterExpression> Parameters { get { return _Parameters; } } + internal override LabelTarget ReturnLabel { get { return _ReturnLabel; } } + + internal override object/*!*/ GetInterpretingDelegate() { + return new Action<CallSite, T0 , T1 , T2 , T3 , T4>(Invoke); + } + + public void Invoke(CallSite/*!*/ callSite,T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { + if (_compiled != null) { + ((CallSite<Action<CallSite, T0 , T1 , T2 , T3 , T4>>)callSite).Target = (Action<CallSite, T0 , T1 , T2 , T3 , T4>)_compiled; + } + ((Action<CallSite, T0 , T1 , T2 , T3 , T4>)_rule)(callSite ,arg0, arg1, arg2, arg3, arg4); + } + } + public class InterpretedFuncDispatcher<T0, T1, T2, T3, T4, T5, TReturn> : InterpretedDispatcher { + internal static readonly ReadOnlyCollection<ParameterExpression> _Parameters = + new ReadOnlyCollection<ParameterExpression>(new ParameterExpression[] { + Expression.Parameter(typeof(T0), "$arg0"), Expression.Parameter(typeof(T1), "$arg1"), Expression.Parameter(typeof(T2), "$arg2"), Expression.Parameter(typeof(T3), "$arg3"), Expression.Parameter(typeof(T4), "$arg4"), Expression.Parameter(typeof(T5), "$arg5") + }); + + internal static readonly LabelTarget _ReturnLabel = Expression.Label(typeof(TReturn)); + + internal override ReadOnlyCollection<ParameterExpression> Parameters { get { return _Parameters; } } + internal override LabelTarget ReturnLabel { get { return _ReturnLabel; } } + + internal override object/*!*/ GetInterpretingDelegate() { + return new Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5, TReturn>(Invoke); + } + + public TReturn Invoke(CallSite/*!*/ callSite,T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5) { + if (_compiled != null) { + ((CallSite<Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5, TReturn>>)callSite).Target = (Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5, TReturn>)_compiled; + } + return ((Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5, TReturn>)_rule)(callSite ,arg0, arg1, arg2, arg3, arg4, arg5); + } + } + + public class InterpretedActionDispatcher<T0, T1, T2, T3, T4, T5> : InterpretedDispatcher { + internal static readonly ReadOnlyCollection<ParameterExpression> _Parameters = + new ReadOnlyCollection<ParameterExpression>(new ParameterExpression[] { + Expression.Parameter(typeof(T0), "$arg0"), Expression.Parameter(typeof(T1), "$arg1"), Expression.Parameter(typeof(T2), "$arg2"), Expression.Parameter(typeof(T3), "$arg3"), Expression.Parameter(typeof(T4), "$arg4"), Expression.Parameter(typeof(T5), "$arg5") + }); + + internal static readonly LabelTarget _ReturnLabel = Expression.Label(typeof(void)); + + internal override ReadOnlyCollection<ParameterExpression> Parameters { get { return _Parameters; } } + internal override LabelTarget ReturnLabel { get { return _ReturnLabel; } } + + internal override object/*!*/ GetInterpretingDelegate() { + return new Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5>(Invoke); + } + + public void Invoke(CallSite/*!*/ callSite,T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5) { + if (_compiled != null) { + ((CallSite<Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5>>)callSite).Target = (Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5>)_compiled; + } + ((Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5>)_rule)(callSite ,arg0, arg1, arg2, arg3, arg4, arg5); + } + } + public class InterpretedFuncDispatcher<T0, T1, T2, T3, T4, T5, T6, TReturn> : InterpretedDispatcher { + internal static readonly ReadOnlyCollection<ParameterExpression> _Parameters = + new ReadOnlyCollection<ParameterExpression>(new ParameterExpression[] { + Expression.Parameter(typeof(T0), "$arg0"), Expression.Parameter(typeof(T1), "$arg1"), Expression.Parameter(typeof(T2), "$arg2"), Expression.Parameter(typeof(T3), "$arg3"), Expression.Parameter(typeof(T4), "$arg4"), Expression.Parameter(typeof(T5), "$arg5"), Expression.Parameter(typeof(T6), "$arg6") + }); + + internal static readonly LabelTarget _ReturnLabel = Expression.Label(typeof(TReturn)); + + internal override ReadOnlyCollection<ParameterExpression> Parameters { get { return _Parameters; } } + internal override LabelTarget ReturnLabel { get { return _ReturnLabel; } } + + internal override object/*!*/ GetInterpretingDelegate() { + return new Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5 , T6, TReturn>(Invoke); + } + + public TReturn Invoke(CallSite/*!*/ callSite,T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6) { + if (_compiled != null) { + ((CallSite<Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5 , T6, TReturn>>)callSite).Target = (Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5 , T6, TReturn>)_compiled; + } + return ((Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5 , T6, TReturn>)_rule)(callSite ,arg0, arg1, arg2, arg3, arg4, arg5, arg6); + } + } + + public class InterpretedActionDispatcher<T0, T1, T2, T3, T4, T5, T6> : InterpretedDispatcher { + internal static readonly ReadOnlyCollection<ParameterExpression> _Parameters = + new ReadOnlyCollection<ParameterExpression>(new ParameterExpression[] { + Expression.Parameter(typeof(T0), "$arg0"), Expression.Parameter(typeof(T1), "$arg1"), Expression.Parameter(typeof(T2), "$arg2"), Expression.Parameter(typeof(T3), "$arg3"), Expression.Parameter(typeof(T4), "$arg4"), Expression.Parameter(typeof(T5), "$arg5"), Expression.Parameter(typeof(T6), "$arg6") + }); + + internal static readonly LabelTarget _ReturnLabel = Expression.Label(typeof(void)); + + internal override ReadOnlyCollection<ParameterExpression> Parameters { get { return _Parameters; } } + internal override LabelTarget ReturnLabel { get { return _ReturnLabel; } } + + internal override object/*!*/ GetInterpretingDelegate() { + return new Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5 , T6>(Invoke); + } + + public void Invoke(CallSite/*!*/ callSite,T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6) { + if (_compiled != null) { + ((CallSite<Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5 , T6>>)callSite).Target = (Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5 , T6>)_compiled; + } + ((Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5 , T6>)_rule)(callSite ,arg0, arg1, arg2, arg3, arg4, arg5, arg6); + } + } + public class InterpretedFuncDispatcher<T0, T1, T2, T3, T4, T5, T6, T7, TReturn> : InterpretedDispatcher { + internal static readonly ReadOnlyCollection<ParameterExpression> _Parameters = + new ReadOnlyCollection<ParameterExpression>(new ParameterExpression[] { + Expression.Parameter(typeof(T0), "$arg0"), Expression.Parameter(typeof(T1), "$arg1"), Expression.Parameter(typeof(T2), "$arg2"), Expression.Parameter(typeof(T3), "$arg3"), Expression.Parameter(typeof(T4), "$arg4"), Expression.Parameter(typeof(T5), "$arg5"), Expression.Parameter(typeof(T6), "$arg6"), Expression.Parameter(typeof(T7), "$arg7") + }); + + internal static readonly LabelTarget _ReturnLabel = Expression.Label(typeof(TReturn)); + + internal override ReadOnlyCollection<ParameterExpression> Parameters { get { return _Parameters; } } + internal override LabelTarget ReturnLabel { get { return _ReturnLabel; } } + + internal override object/*!*/ GetInterpretingDelegate() { + return new Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7, TReturn>(Invoke); + } + + public TReturn Invoke(CallSite/*!*/ callSite,T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7) { + if (_compiled != null) { + ((CallSite<Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7, TReturn>>)callSite).Target = (Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7, TReturn>)_compiled; + } + return ((Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7, TReturn>)_rule)(callSite ,arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); + } + } + + public class InterpretedActionDispatcher<T0, T1, T2, T3, T4, T5, T6, T7> : InterpretedDispatcher { + internal static readonly ReadOnlyCollection<ParameterExpression> _Parameters = + new ReadOnlyCollection<ParameterExpression>(new ParameterExpression[] { + Expression.Parameter(typeof(T0), "$arg0"), Expression.Parameter(typeof(T1), "$arg1"), Expression.Parameter(typeof(T2), "$arg2"), Expression.Parameter(typeof(T3), "$arg3"), Expression.Parameter(typeof(T4), "$arg4"), Expression.Parameter(typeof(T5), "$arg5"), Expression.Parameter(typeof(T6), "$arg6"), Expression.Parameter(typeof(T7), "$arg7") + }); + + internal static readonly LabelTarget _ReturnLabel = Expression.Label(typeof(void)); + + internal override ReadOnlyCollection<ParameterExpression> Parameters { get { return _Parameters; } } + internal override LabelTarget ReturnLabel { get { return _ReturnLabel; } } + + internal override object/*!*/ GetInterpretingDelegate() { + return new Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>(Invoke); + } + + public void Invoke(CallSite/*!*/ callSite,T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7) { + if (_compiled != null) { + ((CallSite<Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>>)callSite).Target = (Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>)_compiled; + } + ((Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>)_rule)(callSite ,arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); + } + } + public class InterpretedFuncDispatcher<T0, T1, T2, T3, T4, T5, T6, T7, T8, TReturn> : InterpretedDispatcher { + internal static readonly ReadOnlyCollection<ParameterExpression> _Parameters = + new ReadOnlyCollection<ParameterExpression>(new ParameterExpression[] { + Expression.Parameter(typeof(T0), "$arg0"), Expression.Parameter(typeof(T1), "$arg1"), Expression.Parameter(typeof(T2), "$arg2"), Expression.Parameter(typeof(T3), "$arg3"), Expression.Parameter(typeof(T4), "$arg4"), Expression.Parameter(typeof(T5), "$arg5"), Expression.Parameter(typeof(T6), "$arg6"), Expression.Parameter(typeof(T7), "$arg7"), Expression.Parameter(typeof(T8), "$arg8") + }); + + internal static readonly LabelTarget _ReturnLabel = Expression.Label(typeof(TReturn)); + + internal override ReadOnlyCollection<ParameterExpression> Parameters { get { return _Parameters; } } + internal override LabelTarget ReturnLabel { get { return _ReturnLabel; } } + + internal override object/*!*/ GetInterpretingDelegate() { + return new Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8, TReturn>(Invoke); + } + + public TReturn Invoke(CallSite/*!*/ callSite,T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8) { + if (_compiled != null) { + ((CallSite<Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8, TReturn>>)callSite).Target = (Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8, TReturn>)_compiled; + } + return ((Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8, TReturn>)_rule)(callSite ,arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); + } + } + + public class InterpretedActionDispatcher<T0, T1, T2, T3, T4, T5, T6, T7, T8> : InterpretedDispatcher { + internal static readonly ReadOnlyCollection<ParameterExpression> _Parameters = + new ReadOnlyCollection<ParameterExpression>(new ParameterExpression[] { + Expression.Parameter(typeof(T0), "$arg0"), Expression.Parameter(typeof(T1), "$arg1"), Expression.Parameter(typeof(T2), "$arg2"), Expression.Parameter(typeof(T3), "$arg3"), Expression.Parameter(typeof(T4), "$arg4"), Expression.Parameter(typeof(T5), "$arg5"), Expression.Parameter(typeof(T6), "$arg6"), Expression.Parameter(typeof(T7), "$arg7"), Expression.Parameter(typeof(T8), "$arg8") + }); + + internal static readonly LabelTarget _ReturnLabel = Expression.Label(typeof(void)); + + internal override ReadOnlyCollection<ParameterExpression> Parameters { get { return _Parameters; } } + internal override LabelTarget ReturnLabel { get { return _ReturnLabel; } } + + internal override object/*!*/ GetInterpretingDelegate() { + return new Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>(Invoke); + } + + public void Invoke(CallSite/*!*/ callSite,T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8) { + if (_compiled != null) { + ((CallSite<Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>>)callSite).Target = (Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>)_compiled; + } + ((Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>)_rule)(callSite ,arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); + } + } + public class InterpretedFuncDispatcher<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, TReturn> : InterpretedDispatcher { + internal static readonly ReadOnlyCollection<ParameterExpression> _Parameters = + new ReadOnlyCollection<ParameterExpression>(new ParameterExpression[] { + Expression.Parameter(typeof(T0), "$arg0"), Expression.Parameter(typeof(T1), "$arg1"), Expression.Parameter(typeof(T2), "$arg2"), Expression.Parameter(typeof(T3), "$arg3"), Expression.Parameter(typeof(T4), "$arg4"), Expression.Parameter(typeof(T5), "$arg5"), Expression.Parameter(typeof(T6), "$arg6"), Expression.Parameter(typeof(T7), "$arg7"), Expression.Parameter(typeof(T8), "$arg8"), Expression.Parameter(typeof(T9), "$arg9") + }); + + internal static readonly LabelTarget _ReturnLabel = Expression.Label(typeof(TReturn)); + + internal override ReadOnlyCollection<ParameterExpression> Parameters { get { return _Parameters; } } + internal override LabelTarget ReturnLabel { get { return _ReturnLabel; } } + + internal override object/*!*/ GetInterpretingDelegate() { + return new Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9, TReturn>(Invoke); + } + + public TReturn Invoke(CallSite/*!*/ callSite,T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9) { + if (_compiled != null) { + ((CallSite<Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9, TReturn>>)callSite).Target = (Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9, TReturn>)_compiled; + } + return ((Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9, TReturn>)_rule)(callSite ,arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); + } + } + + public class InterpretedActionDispatcher<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> : InterpretedDispatcher { + internal static readonly ReadOnlyCollection<ParameterExpression> _Parameters = + new ReadOnlyCollection<ParameterExpression>(new ParameterExpression[] { + Expression.Parameter(typeof(T0), "$arg0"), Expression.Parameter(typeof(T1), "$arg1"), Expression.Parameter(typeof(T2), "$arg2"), Expression.Parameter(typeof(T3), "$arg3"), Expression.Parameter(typeof(T4), "$arg4"), Expression.Parameter(typeof(T5), "$arg5"), Expression.Parameter(typeof(T6), "$arg6"), Expression.Parameter(typeof(T7), "$arg7"), Expression.Parameter(typeof(T8), "$arg8"), Expression.Parameter(typeof(T9), "$arg9") + }); + + internal static readonly LabelTarget _ReturnLabel = Expression.Label(typeof(void)); + + internal override ReadOnlyCollection<ParameterExpression> Parameters { get { return _Parameters; } } + internal override LabelTarget ReturnLabel { get { return _ReturnLabel; } } + + internal override object/*!*/ GetInterpretingDelegate() { + return new Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>(Invoke); + } + + public void Invoke(CallSite/*!*/ callSite,T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9) { + if (_compiled != null) { + ((CallSite<Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>>)callSite).Target = (Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>)_compiled; + } + ((Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>)_rule)(callSite ,arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); + } + } + public class InterpretedFuncDispatcher<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TReturn> : InterpretedDispatcher { + internal static readonly ReadOnlyCollection<ParameterExpression> _Parameters = + new ReadOnlyCollection<ParameterExpression>(new ParameterExpression[] { + Expression.Parameter(typeof(T0), "$arg0"), Expression.Parameter(typeof(T1), "$arg1"), Expression.Parameter(typeof(T2), "$arg2"), Expression.Parameter(typeof(T3), "$arg3"), Expression.Parameter(typeof(T4), "$arg4"), Expression.Parameter(typeof(T5), "$arg5"), Expression.Parameter(typeof(T6), "$arg6"), Expression.Parameter(typeof(T7), "$arg7"), Expression.Parameter(typeof(T8), "$arg8"), Expression.Parameter(typeof(T9), "$arg9"), Expression.Parameter(typeof(T10), "$arg10") + }); + + internal static readonly LabelTarget _ReturnLabel = Expression.Label(typeof(TReturn)); + + internal override ReadOnlyCollection<ParameterExpression> Parameters { get { return _Parameters; } } + internal override LabelTarget ReturnLabel { get { return _ReturnLabel; } } + + internal override object/*!*/ GetInterpretingDelegate() { + return new Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10, TReturn>(Invoke); + } + + public TReturn Invoke(CallSite/*!*/ callSite,T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10) { + if (_compiled != null) { + ((CallSite<Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10, TReturn>>)callSite).Target = (Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10, TReturn>)_compiled; + } + return ((Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10, TReturn>)_rule)(callSite ,arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); + } + } + + public class InterpretedActionDispatcher<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> : InterpretedDispatcher { + internal static readonly ReadOnlyCollection<ParameterExpression> _Parameters = + new ReadOnlyCollection<ParameterExpression>(new ParameterExpression[] { + Expression.Parameter(typeof(T0), "$arg0"), Expression.Parameter(typeof(T1), "$arg1"), Expression.Parameter(typeof(T2), "$arg2"), Expression.Parameter(typeof(T3), "$arg3"), Expression.Parameter(typeof(T4), "$arg4"), Expression.Parameter(typeof(T5), "$arg5"), Expression.Parameter(typeof(T6), "$arg6"), Expression.Parameter(typeof(T7), "$arg7"), Expression.Parameter(typeof(T8), "$arg8"), Expression.Parameter(typeof(T9), "$arg9"), Expression.Parameter(typeof(T10), "$arg10") + }); + + internal static readonly LabelTarget _ReturnLabel = Expression.Label(typeof(void)); + + internal override ReadOnlyCollection<ParameterExpression> Parameters { get { return _Parameters; } } + internal override LabelTarget ReturnLabel { get { return _ReturnLabel; } } + + internal override object/*!*/ GetInterpretingDelegate() { + return new Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10>(Invoke); + } + + public void Invoke(CallSite/*!*/ callSite,T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10) { + if (_compiled != null) { + ((CallSite<Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10>>)callSite).Target = (Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10>)_compiled; + } + ((Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10>)_rule)(callSite ,arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); + } + } + public class InterpretedFuncDispatcher<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TReturn> : InterpretedDispatcher { + internal static readonly ReadOnlyCollection<ParameterExpression> _Parameters = + new ReadOnlyCollection<ParameterExpression>(new ParameterExpression[] { + Expression.Parameter(typeof(T0), "$arg0"), Expression.Parameter(typeof(T1), "$arg1"), Expression.Parameter(typeof(T2), "$arg2"), Expression.Parameter(typeof(T3), "$arg3"), Expression.Parameter(typeof(T4), "$arg4"), Expression.Parameter(typeof(T5), "$arg5"), Expression.Parameter(typeof(T6), "$arg6"), Expression.Parameter(typeof(T7), "$arg7"), Expression.Parameter(typeof(T8), "$arg8"), Expression.Parameter(typeof(T9), "$arg9"), Expression.Parameter(typeof(T10), "$arg10"), Expression.Parameter(typeof(T11), "$arg11") + }); + + internal static readonly LabelTarget _ReturnLabel = Expression.Label(typeof(TReturn)); + + internal override ReadOnlyCollection<ParameterExpression> Parameters { get { return _Parameters; } } + internal override LabelTarget ReturnLabel { get { return _ReturnLabel; } } + + internal override object/*!*/ GetInterpretingDelegate() { + return new Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11, TReturn>(Invoke); + } + + public TReturn Invoke(CallSite/*!*/ callSite,T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11) { + if (_compiled != null) { + ((CallSite<Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11, TReturn>>)callSite).Target = (Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11, TReturn>)_compiled; + } + return ((Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11, TReturn>)_rule)(callSite ,arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11); + } + } + + public class InterpretedActionDispatcher<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> : InterpretedDispatcher { + internal static readonly ReadOnlyCollection<ParameterExpression> _Parameters = + new ReadOnlyCollection<ParameterExpression>(new ParameterExpression[] { + Expression.Parameter(typeof(T0), "$arg0"), Expression.Parameter(typeof(T1), "$arg1"), Expression.Parameter(typeof(T2), "$arg2"), Expression.Parameter(typeof(T3), "$arg3"), Expression.Parameter(typeof(T4), "$arg4"), Expression.Parameter(typeof(T5), "$arg5"), Expression.Parameter(typeof(T6), "$arg6"), Expression.Parameter(typeof(T7), "$arg7"), Expression.Parameter(typeof(T8), "$arg8"), Expression.Parameter(typeof(T9), "$arg9"), Expression.Parameter(typeof(T10), "$arg10"), Expression.Parameter(typeof(T11), "$arg11") + }); + + internal static readonly LabelTarget _ReturnLabel = Expression.Label(typeof(void)); + + internal override ReadOnlyCollection<ParameterExpression> Parameters { get { return _Parameters; } } + internal override LabelTarget ReturnLabel { get { return _ReturnLabel; } } + + internal override object/*!*/ GetInterpretingDelegate() { + return new Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11>(Invoke); + } + + public void Invoke(CallSite/*!*/ callSite,T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11) { + if (_compiled != null) { + ((CallSite<Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11>>)callSite).Target = (Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11>)_compiled; + } + ((Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11>)_rule)(callSite ,arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11); + } + } + public class InterpretedFuncDispatcher<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TReturn> : InterpretedDispatcher { + internal static readonly ReadOnlyCollection<ParameterExpression> _Parameters = + new ReadOnlyCollection<ParameterExpression>(new ParameterExpression[] { + Expression.Parameter(typeof(T0), "$arg0"), Expression.Parameter(typeof(T1), "$arg1"), Expression.Parameter(typeof(T2), "$arg2"), Expression.Parameter(typeof(T3), "$arg3"), Expression.Parameter(typeof(T4), "$arg4"), Expression.Parameter(typeof(T5), "$arg5"), Expression.Parameter(typeof(T6), "$arg6"), Expression.Parameter(typeof(T7), "$arg7"), Expression.Parameter(typeof(T8), "$arg8"), Expression.Parameter(typeof(T9), "$arg9"), Expression.Parameter(typeof(T10), "$arg10"), Expression.Parameter(typeof(T11), "$arg11"), Expression.Parameter(typeof(T12), "$arg12") + }); + + internal static readonly LabelTarget _ReturnLabel = Expression.Label(typeof(TReturn)); + + internal override ReadOnlyCollection<ParameterExpression> Parameters { get { return _Parameters; } } + internal override LabelTarget ReturnLabel { get { return _ReturnLabel; } } + + internal override object/*!*/ GetInterpretingDelegate() { + return new Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12, TReturn>(Invoke); + } + + public TReturn Invoke(CallSite/*!*/ callSite,T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12) { + if (_compiled != null) { + ((CallSite<Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12, TReturn>>)callSite).Target = (Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12, TReturn>)_compiled; + } + return ((Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12, TReturn>)_rule)(callSite ,arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12); + } + } + + public class InterpretedActionDispatcher<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> : InterpretedDispatcher { + internal static readonly ReadOnlyCollection<ParameterExpression> _Parameters = + new ReadOnlyCollection<ParameterExpression>(new ParameterExpression[] { + Expression.Parameter(typeof(T0), "$arg0"), Expression.Parameter(typeof(T1), "$arg1"), Expression.Parameter(typeof(T2), "$arg2"), Expression.Parameter(typeof(T3), "$arg3"), Expression.Parameter(typeof(T4), "$arg4"), Expression.Parameter(typeof(T5), "$arg5"), Expression.Parameter(typeof(T6), "$arg6"), Expression.Parameter(typeof(T7), "$arg7"), Expression.Parameter(typeof(T8), "$arg8"), Expression.Parameter(typeof(T9), "$arg9"), Expression.Parameter(typeof(T10), "$arg10"), Expression.Parameter(typeof(T11), "$arg11"), Expression.Parameter(typeof(T12), "$arg12") + }); + + internal static readonly LabelTarget _ReturnLabel = Expression.Label(typeof(void)); + + internal override ReadOnlyCollection<ParameterExpression> Parameters { get { return _Parameters; } } + internal override LabelTarget ReturnLabel { get { return _ReturnLabel; } } + + internal override object/*!*/ GetInterpretingDelegate() { + return new Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12>(Invoke); + } + + public void Invoke(CallSite/*!*/ callSite,T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12) { + if (_compiled != null) { + ((CallSite<Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12>>)callSite).Target = (Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12>)_compiled; + } + ((Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12>)_rule)(callSite ,arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12); + } + } + public class InterpretedFuncDispatcher<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TReturn> : InterpretedDispatcher { + internal static readonly ReadOnlyCollection<ParameterExpression> _Parameters = + new ReadOnlyCollection<ParameterExpression>(new ParameterExpression[] { + Expression.Parameter(typeof(T0), "$arg0"), Expression.Parameter(typeof(T1), "$arg1"), Expression.Parameter(typeof(T2), "$arg2"), Expression.Parameter(typeof(T3), "$arg3"), Expression.Parameter(typeof(T4), "$arg4"), Expression.Parameter(typeof(T5), "$arg5"), Expression.Parameter(typeof(T6), "$arg6"), Expression.Parameter(typeof(T7), "$arg7"), Expression.Parameter(typeof(T8), "$arg8"), Expression.Parameter(typeof(T9), "$arg9"), Expression.Parameter(typeof(T10), "$arg10"), Expression.Parameter(typeof(T11), "$arg11"), Expression.Parameter(typeof(T12), "$arg12"), Expression.Parameter(typeof(T13), "$arg13") + }); + + internal static readonly LabelTarget _ReturnLabel = Expression.Label(typeof(TReturn)); + + internal override ReadOnlyCollection<ParameterExpression> Parameters { get { return _Parameters; } } + internal override LabelTarget ReturnLabel { get { return _ReturnLabel; } } + + internal override object/*!*/ GetInterpretingDelegate() { + return new Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13, TReturn>(Invoke); + } + + public TReturn Invoke(CallSite/*!*/ callSite,T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13) { + if (_compiled != null) { + ((CallSite<Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13, TReturn>>)callSite).Target = (Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13, TReturn>)_compiled; + } + return ((Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13, TReturn>)_rule)(callSite ,arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13); + } + } + + public class InterpretedActionDispatcher<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> : InterpretedDispatcher { + internal static readonly ReadOnlyCollection<ParameterExpression> _Parameters = + new ReadOnlyCollection<ParameterExpression>(new ParameterExpression[] { + Expression.Parameter(typeof(T0), "$arg0"), Expression.Parameter(typeof(T1), "$arg1"), Expression.Parameter(typeof(T2), "$arg2"), Expression.Parameter(typeof(T3), "$arg3"), Expression.Parameter(typeof(T4), "$arg4"), Expression.Parameter(typeof(T5), "$arg5"), Expression.Parameter(typeof(T6), "$arg6"), Expression.Parameter(typeof(T7), "$arg7"), Expression.Parameter(typeof(T8), "$arg8"), Expression.Parameter(typeof(T9), "$arg9"), Expression.Parameter(typeof(T10), "$arg10"), Expression.Parameter(typeof(T11), "$arg11"), Expression.Parameter(typeof(T12), "$arg12"), Expression.Parameter(typeof(T13), "$arg13") + }); + + internal static readonly LabelTarget _ReturnLabel = Expression.Label(typeof(void)); + + internal override ReadOnlyCollection<ParameterExpression> Parameters { get { return _Parameters; } } + internal override LabelTarget ReturnLabel { get { return _ReturnLabel; } } + + internal override object/*!*/ GetInterpretingDelegate() { + return new Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13>(Invoke); + } + + public void Invoke(CallSite/*!*/ callSite,T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13) { + if (_compiled != null) { + ((CallSite<Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13>>)callSite).Target = (Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13>)_compiled; + } + ((Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13>)_rule)(callSite ,arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13); + } + } + public class InterpretedFuncDispatcher<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TReturn> : InterpretedDispatcher { + internal static readonly ReadOnlyCollection<ParameterExpression> _Parameters = + new ReadOnlyCollection<ParameterExpression>(new ParameterExpression[] { + Expression.Parameter(typeof(T0), "$arg0"), Expression.Parameter(typeof(T1), "$arg1"), Expression.Parameter(typeof(T2), "$arg2"), Expression.Parameter(typeof(T3), "$arg3"), Expression.Parameter(typeof(T4), "$arg4"), Expression.Parameter(typeof(T5), "$arg5"), Expression.Parameter(typeof(T6), "$arg6"), Expression.Parameter(typeof(T7), "$arg7"), Expression.Parameter(typeof(T8), "$arg8"), Expression.Parameter(typeof(T9), "$arg9"), Expression.Parameter(typeof(T10), "$arg10"), Expression.Parameter(typeof(T11), "$arg11"), Expression.Parameter(typeof(T12), "$arg12"), Expression.Parameter(typeof(T13), "$arg13"), Expression.Parameter(typeof(T14), "$arg14") + }); + + internal static readonly LabelTarget _ReturnLabel = Expression.Label(typeof(TReturn)); + + internal override ReadOnlyCollection<ParameterExpression> Parameters { get { return _Parameters; } } + internal override LabelTarget ReturnLabel { get { return _ReturnLabel; } } + + internal override object/*!*/ GetInterpretingDelegate() { + return new Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14, TReturn>(Invoke); + } + + public TReturn Invoke(CallSite/*!*/ callSite,T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14) { + if (_compiled != null) { + ((CallSite<Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14, TReturn>>)callSite).Target = (Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14, TReturn>)_compiled; + } + return ((Func<CallSite , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14, TReturn>)_rule)(callSite ,arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14); + } + } + + public class InterpretedActionDispatcher<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> : InterpretedDispatcher { + internal static readonly ReadOnlyCollection<ParameterExpression> _Parameters = + new ReadOnlyCollection<ParameterExpression>(new ParameterExpression[] { + Expression.Parameter(typeof(T0), "$arg0"), Expression.Parameter(typeof(T1), "$arg1"), Expression.Parameter(typeof(T2), "$arg2"), Expression.Parameter(typeof(T3), "$arg3"), Expression.Parameter(typeof(T4), "$arg4"), Expression.Parameter(typeof(T5), "$arg5"), Expression.Parameter(typeof(T6), "$arg6"), Expression.Parameter(typeof(T7), "$arg7"), Expression.Parameter(typeof(T8), "$arg8"), Expression.Parameter(typeof(T9), "$arg9"), Expression.Parameter(typeof(T10), "$arg10"), Expression.Parameter(typeof(T11), "$arg11"), Expression.Parameter(typeof(T12), "$arg12"), Expression.Parameter(typeof(T13), "$arg13"), Expression.Parameter(typeof(T14), "$arg14") + }); + + internal static readonly LabelTarget _ReturnLabel = Expression.Label(typeof(void)); + + internal override ReadOnlyCollection<ParameterExpression> Parameters { get { return _Parameters; } } + internal override LabelTarget ReturnLabel { get { return _ReturnLabel; } } + + internal override object/*!*/ GetInterpretingDelegate() { + return new Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14>(Invoke); + } + + public void Invoke(CallSite/*!*/ callSite,T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14) { + if (_compiled != null) { + ((CallSite<Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14>>)callSite).Target = (Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14>)_compiled; + } + ((Action<CallSite, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14>)_rule)(callSite ,arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14); + } + } +#endregion } + Merlin/Main/Languages/Ruby/Ruby/Runtime/Calls/MethodDispatcher.Generated.cs @@ -4,6 +4,34 @@ class Generator def add_generic_types(n) (n - 1).times { |i| @generated << @template.sub('<>', '<,' + (',' * i) + '>') } end + + def GenericDecl + "<" + Array.new(@n) { |i| "T#{i}" }.join(", ") + ">" + end + + def GenericDeclWithReturn(*args) + "<" + Array.new(@n) { |i| "T#{i}" }.join(", ") + ", TReturn>" + end + + def GenericParams + Array.new(@n) { |i| ", T#{i}" }.join(" ") + end + + def Objects *args + ", object" * @n + end + + def Parameters + "," + Array.new(@n) { |i| "T#{i} arg#{i}" }.join(", ") + end + + def Arguments + "," + Array.new(@n) { |i| "arg#{i}" }.join(", ") + end + + def ParameterExpressions + Array.new(@n) { |i| %{Expression.Parameter(typeof(T#{i}), "$arg#{i}")} }.join(", ") + end end expand_templates(__FILE__) \ No newline at end of file Merlin/Main/Languages/Ruby/Ruby/Runtime/Calls/MethodDispatcher.Generator.rb @@ -20,6 +20,11 @@ using IronRuby.Builtins; using System.Runtime.CompilerServices; using System.Diagnostics; using Microsoft.Scripting.Utils; +using System.Linq.Expressions; +using Microsoft.Scripting.Generation; +using System.Collections.ObjectModel; +using Microsoft.Scripting.Interpreter; +using Microsoft.Scripting; namespace IronRuby.Runtime.Calls { @@ -59,7 +64,7 @@ namespace IronRuby.Runtime.Calls { return null; } - if (parameterCount > PrecompiledParameterCount) { + if (parameterCount > MaxPrecompiledArity) { return null; } @@ -79,16 +84,35 @@ namespace IronRuby.Runtime.Calls { } } - public abstract object/*!*/ CreateDelegate(); - internal abstract void Initialize(Delegate/*!*/ method, int version); + internal static InterpretedDispatcher CreateInterpreted(Type/*!*/ delegateType, int parameterCount) { + if (parameterCount > MaxInterpretedArity) { + return null; + } + + // Func<CallSite, T1, ... TN, TReturn> + // Action<CallSite, T1, ... TN> + var types = delegateType.GetGenericArguments(); + types = types.GetSlice(1, types.Length - 1); + + Type dispatcherType; + if (parameterCount != types.Length) { + // Func + Debug.Assert(parameterCount + 1 == types.Length); + dispatcherType = InterpretedFuncDispatchers[parameterCount]; + } else { + // Action + dispatcherType = InterpretedActionDispatchers[parameterCount]; + } - internal virtual void InitializeSingleton(object singleton, VersionHandle/*!*/ versionHandle) { - throw Assert.Unreachable; + return (InterpretedDispatcher)Activator.CreateInstance(dispatcherType.MakeGenericType(types)); } + + public abstract object/*!*/ CreateDelegate(); + internal abstract void Initialize(Delegate/*!*/ method, int version); } public abstract class MethodDispatcher<TRubyFunc> : MethodDispatcher { - internal TRubyFunc/*!*/ Method; + internal TRubyFunc Method; internal override void Initialize(Delegate/*!*/ method, int version) { Assert.NotNull(method); @@ -96,4 +120,65 @@ namespace IronRuby.Runtime.Calls { Version = version; } } + + public abstract class InterpretedDispatcher { + internal object _rule; + internal Delegate _compiled; + + internal T/*!*/ CreateDelegate<T>(Expression/*!*/ binding) where T : class { + Delegate d = CompilerHelpers.LightCompile(Stitch<T>(binding)); + T result = (T)(object)d; + + LightLambda lambda = d.Target as LightLambda; + if (lambda != null) { + _rule = result; + lambda.Compile += (_, e) => _compiled = e.Compiled; + return (T)GetInterpretingDelegate(); + } else { + PerfTrack.NoteEvent(PerfTrack.Categories.Rules, "Rule not interpreted"); + return result; + } + } + + // TODO: This is a copy of CallSiteBinder.Stitch. + private LambdaExpression/*!*/ Stitch<T>(Expression/*!*/ binding) where T : class { + Expression updLabel = Expression.Label(CallSiteBinder.UpdateLabel); + + var site = Expression.Parameter(typeof(CallSite), "$site"); + var @params = ArrayUtils.Insert(site, Parameters); + + var body = Expression.Block( + binding, + updLabel, + Expression.Label( + ReturnLabel, + Expression.Condition( + Expression.Call( + typeof(CallSiteOps).GetMethod("SetNotMatched"), + @params[0] + ), + Expression.Default(ReturnLabel.Type), + Expression.Invoke( + Expression.Property( + Expression.Convert(site, typeof(CallSite<T>)), + typeof(CallSite<T>).GetProperty("Update") + ), + @params + ) + ) + ) + ); + + return Expression.Lambda<T>( + body, + "CallSite.Target", + true, // always compile the rules with tail call optimization + @params + ); + } + + internal abstract ReadOnlyCollection<ParameterExpression> Parameters { get; } + internal abstract LabelTarget ReturnLabel { get; } + internal abstract object/*!*/ GetInterpretingDelegate(); + } } Merlin/Main/Languages/Ruby/Ruby/Runtime/Calls/MethodDispatcher.cs @@ -53,11 +53,6 @@ namespace IronRuby.Runtime.Calls { return GetType().Name + (Context != null ? " @" + Context.RuntimeId.ToString() : null); } - public override T BindDelegate<T>(System.Runtime.CompilerServices.CallSite<T> site, object[] args) { - PerfTrack.NoteEvent(PerfTrack.Categories.Binding, "Ruby: " + GetType().Name + ": BindDelegate"); - return base.BindDelegate<T>(site, args); - } - public static RubyConversionAction TryGetDefaultConversionAction(RubyContext context, Type/*!*/ parameterType) { var factory = TryGetDefaultConversionAction(parameterType); return factory != null ? factory(context != null ? context.MetaBinderFactory : RubyMetaBinderFactory.Shared) : null; Merlin/Main/Languages/Ruby/Ruby/Runtime/Calls/ProtocolConversionAction.cs @@ -92,8 +92,6 @@ namespace IronRuby.Runtime.Calls { #region Precompiled Rules public override T BindDelegate<T>(CallSite<T>/*!*/ site, object[]/*!*/ args) { - PerfTrack.NoteEvent(PerfTrack.Categories.Binding, "Ruby: RubyCallAction" + Signature.ToString() + ": BindDelegate"); - if (Context == null || (Signature.Flags & ~(RubyCallFlags.HasImplicitSelf | RubyCallFlags.HasScope | RubyCallFlags.HasBlock)) != 0) { return base.BindDelegate<T>(site, args); } Merlin/Main/Languages/Ruby/Ruby/Runtime/Calls/RubyCallAction.cs @@ -24,6 +24,7 @@ using System.Reflection; using Microsoft.Scripting; using Microsoft.Scripting.Runtime; using System.Linq.Expressions; +using System.Runtime.CompilerServices; namespace IronRuby.Runtime.Calls { public abstract class RubyMetaBinder : DynamicMetaObjectBinder, IExpressionSerializable { @@ -49,11 +50,24 @@ namespace IronRuby.Runtime.Calls { protected abstract bool Build(MetaObjectBuilder/*!*/ metaBuilder, CallArguments/*!*/ args, bool defaultFallback); public abstract Expression CreateExpression(); - protected virtual DynamicMetaObjectBinder GetInteropBinder(RubyContext/*!*/ context, IList<DynamicMetaObject/*!*/>/*!*/ args, - out MethodInfo postProcessor) { + public override T BindDelegate<T>(System.Runtime.CompilerServices.CallSite<T> site, object[] args) { + InterpretedDispatcher dispatcher = MethodDispatcher.CreateInterpreted(typeof(T), args.Length); - postProcessor = null; - return null; + if (dispatcher == null) { + // call site has too many arguments: + PerfTrack.NoteEvent(PerfTrack.Categories.Binding, "Ruby: ! No dispatcher for " + Signature.ToString()); + return base.BindDelegate<T>(site, args); + } else { + Expression binding = Bind(args, dispatcher.Parameters, dispatcher.ReturnLabel); + + if (binding == null) { + throw new InvalidImplementationException("DynamicMetaObjectBinder.Bind must return non-null meta-object"); + } + + T result = dispatcher.CreateDelegate<T>(binding); + CacheTarget(result); + return result; + } } public override DynamicMetaObject/*!*/ Bind(DynamicMetaObject/*!*/ scopeOrContextOrTarget, DynamicMetaObject/*!*/[]/*!*/ args) { @@ -64,12 +78,18 @@ namespace IronRuby.Runtime.Calls { if (IsForeignMetaObject(callArgs.MetaTarget)) { return InteropBind(metaBuilder, callArgs); - } + } Build(metaBuilder, callArgs, true); return metaBuilder.CreateMetaObject(this); } + protected virtual DynamicMetaObjectBinder GetInteropBinder(RubyContext/*!*/ context, IList<DynamicMetaObject/*!*/>/*!*/ args, + out MethodInfo postProcessor) { + + postProcessor = null; + return null; + } private DynamicMetaObject/*!*/ InteropBind(MetaObjectBuilder/*!*/ metaBuilder, CallArguments/*!*/ args) { // TODO: argument count limit depends on the binder! Merlin/Main/Languages/Ruby/Ruby/Runtime/Calls/RubyMetaBinder.cs @@ -1269,7 +1269,7 @@ namespace IronRuby.Runtime { return result; } - internal bool TryGetClrTypeInstanceData(object obj, out RubyInstanceData result) { + internal bool TryGetClrTypeInstanceData(object/*!*/ obj, out RubyInstanceData result) { lock (ReferenceTypeInstanceDataLock) { return _referenceTypeInstanceData.TryGetValue(obj, out result); } Merlin/Main/Languages/Ruby/Ruby/Runtime/RubyContext.cs @@ -123,28 +123,32 @@ tutorial "IronRuby tutorial" do :code => '2 + 2' task(:body => "Now let's do some printing. This is done with the puts function.", - :code => "puts 'Hello world'") { |i| i.output =~ /Hello/i } + :code => "puts 'Hello world'" + ) { |i| i.output =~ /Hello/i } task(:body => "Let's use a local variable.", - :code => "x = 1") { |i| i.bind.x == 1 } + :code => "x = 1" + ) { |i| i.bind.x == 1 } task(:body => "And then print the local variable.", - :code => "puts x") { |i| i.output.chomp == "1" } + :code => "puts x" + ) { |i| i.output.chomp == "1" } end chapter "Multi-line statements" do introduction "This chapter explains how multi-line statements can be used in the tutorial" task( :body => %{ - Entering multiple lines in an interactive console is a bit tricky as it can be ambigous when - you are done entering a statement. When you press the +Enter+ key, you may either be expecting - to execute the code you have typed already, or you may want to enter more code. Also, - sometimes you might want to go back and edit a line above. + Entering multiple lines in an interactive console can be a bit tricky as it is not an editor. + You cannot go back and change a prior line. If you realized you mis-typed something, you + need to enter all the lines again. - The tutorial currently only handles single line input. Use <tt>;</tt> to separate statements + After you enter the first line, the prompt characters shown at the start of the input textbox + change from ">>>" to "..." to indicate to the user that more lines are expected before the + input will be evaluated. }, - :code => "if 2 < 3 then puts 'this'; puts 'that' end" - ) { |interaction| interaction.output =~ /this\nthat/ } + :code => "if 2 < 3\n puts 1\nelse\n puts 2\nend" + ) { |interaction| interaction.output.chomp == '1' } end chapter "Built-in modules and interactive exploration" do @@ -181,7 +185,8 @@ tutorial "IronRuby tutorial" do function. Let's load the +thread+ module. }, :setup => Proc.new { $LOADED_FEATURES.delete "thread.rb" }, - :code => "require 'thread'") { $LOADED_FEATURES.include? 'thread.rb' } + :code => "require 'thread'" + ) { $LOADED_FEATURES.include? 'thread.rb' } task :body => %{ Now let's see which new classes were loaded. Can you spot the new classes using @@ -209,7 +214,8 @@ tutorial "IronRuby tutorial" do }, :source_files => IronRubyTutorial.primes_path, :setup => Proc.new { $LOADED_FEATURES.delete "primes.rb" }, - :code => "require 'primes.rb'") { $LOADED_FEATURES.include? 'primes.rb' } + :code => "require 'primes.rb'" + ) { $LOADED_FEATURES.include? 'primes.rb' } task :body => %{ We know that the file defines a module called +Primes+. Let's explore the methods defined @@ -281,7 +287,10 @@ tutorial "IronRuby tutorial" do task(:body => %{ Insert a few elements into the hash table }, - :code => ["h[:a] = 'IronRuby'", "h[:b] = 'Tutorial'"]) { |i| i.bind.h.count == 2 } + :code => [ + "h[:a] = 'IronRuby'", + "h[:b] = 'Tutorial'"] + ) { |i| i.bind.h.count == 2 } task :body => %{ IronRuby supports the C# - style syntax for accessing the hash table elements. The same @@ -294,13 +303,17 @@ tutorial "IronRuby tutorial" do are instances of the +DictionaryEntry+ class. Print the +Key+ and +Value+ properties of each entry. }, - :code => 'h.each { |e| puts "#{e.Key}=>#{e.Value}" }') { |i| /a=>IronRuby/ =~ i.output } + :code => 'h.each { |e| puts "#{e.Key}=>#{e.Value}" }' + ) { |i| /a=>IronRuby/ =~ i.output } task(:body => %{ You can initialize the collection classes by passing in the Ruby built-in list as arguments. }, - :code => ['l = ArrayList.new([1,2,3])', 'l.each { |i| puts i }']) { |i| /1\n2\n3/ =~ i.output } + :code => [ + 'l = ArrayList.new([1,2,3])', + 'l.each { |i| puts i }'] + ) { |i| /1\n2\n3/ =~ i.output } end chapter "Generics" do @@ -317,22 +330,28 @@ tutorial "IronRuby tutorial" do Create an instance of a generic dictionary mapping Strings to Fixnums }, - :code => 'd = Dictionary[String, Fixnum].new') { |i| i.bind.d.class == Dictionary[String, Fixnum] } + :code => 'd = Dictionary[String, Fixnum].new' + ) { |i| i.bind.d.class == Dictionary[String, Fixnum] } task(:body => %{ Add string values into the list. Since we created a list of string, adding strings is possible. }, - :code => ["d['Hello'] = 1", "d['Hi'] = 2"]) { |i| i.bind.d.count == 2 } + :code => [ + "d['Hello'] = 1", + "d['Hi'] = 2"] + ) { |i| i.bind.d.count == 2 } task(:body => %{ Try adding objects of types other than string. It will fail with a TypeError }, - :code => 'd[3] = 3') { |i| i.error.kind_of? TypeError } + :code => 'd[3] = 3' + ) { |i| i.error.kind_of? TypeError } task(:body => %{ Enumerate the generic collection }, - :code => 'd.each { |kvp| puts kvp }') { |i| /Hello/ =~ i.output } + :code => 'd.each { |kvp| puts kvp }' + ) { |i| /Hello/ =~ i.output } end end @@ -378,7 +397,8 @@ tutorial "IronRuby tutorial" do }, :code => [ "n = d.select_nodes '//Puzzle/SavedGames/Game/@caption'", - 'n.each { |e| puts e.value }']) { |i| /Seattle/ =~ i.output } + 'n.each { |e| puts e.value }'] + ) { |i| /Seattle/ =~ i.output } end chapter "Loading .NET libraries from a given path" do @@ -412,7 +432,8 @@ tutorial "IronRuby tutorial" do }, :code => [ 'include System::IO', - 'w = FileSystemWatcher.new']) { |i| i.bind.w.class == System::IO::FileSystemWatcher } + 'w = FileSystemWatcher.new'] + ) { |i| i.bind.w.class == System::IO::FileSystemWatcher } task(:body => %{ Inspect the methods available on the instance, and then set the +path+ property to watch @@ -420,7 +441,8 @@ tutorial "IronRuby tutorial" do }, :code => [ 'w.class.instance_methods false', - "w.path = '.'"]) { |i| i.bind.w.path == '.' } + "w.path = '.'"] + ) { |i| i.bind.w.path == '.' } task(:body => %{ Register a block as an event handler for the +changed+, +created+, and +deleted+ events. @@ -431,12 +453,14 @@ tutorial "IronRuby tutorial" do :code => [ 'w.changed { |*a| puts a.inspect }', 'w.created { |*a| puts a.inspect }', - 'w.deleted { |*a| puts a.inspect }']) { IronRubyTutorial.deleted_flag } + 'w.deleted { |*a| puts a.inspect }'] + ) { IronRubyTutorial.deleted_flag } task(:body => %{ Enable the watcher to raise events. }, - :code => 'w.enable_raising_events = true') { |i| i.bind.w.enable_raising_events } + :code => 'w.enable_raising_events = true' + ) { |i| i.bind.w.enable_raising_events } task(:body => %{ Now open the Tutorial folder and create a file. An @@ -454,7 +478,8 @@ tutorial "IronRuby tutorial" do Finally disable the watcher. }, - :code => 'w.enable_raising_events = false') { |i| not i.bind.w.enable_raising_events } + :code => 'w.enable_raising_events = false' + ) { |i| not i.bind.w.enable_raising_events } end chapter "Improving the event handler" do @@ -486,30 +511,51 @@ tutorial "IronRuby tutorial" do :code => [ 'w.changed { |w1,a| puts a.change_type, a.full_path }', 'w.created { |w1,a| puts a.change_type, a.full_path }', - 'w.deleted { |w1,a| puts a.change_type, a.full_path }']) { IronRubyTutorial.deleted_flag } + 'w.deleted { |w1,a| puts a.change_type, a.full_path }'] + ) { IronRubyTutorial.deleted_flag } task(:body => %{ Make sure the raising of the events is enabled: }, - :code => 'w.enable_raising_events = true') { |i| i.bind.w.enable_raising_events } + :code => 'w.enable_raising_events = true' + ) { |i| i.bind.w.enable_raising_events } task(:body => %{ Finally disable the watcher. }, - :code => 'w.enable_raising_events = false') { |i| not i.bind.w.enable_raising_events } + :code => 'w.enable_raising_events = false' + ) { |i| not i.bind.w.enable_raising_events } end end section "Advanced IronRuby - Windows Forms" do - + + introduction %{ + Note that if you develop Windows applications interactively using the <tt>ir.exe</tt> from the + <b>Command Prompt</b>, IronRuby must be initialized specially for that purpose. <tt>ir.exe</tt> + blocks the main thread so that it can read user input. While this thread awaits text input, the + Windows application being dynamically created from the console needs to run on a separate thread + so that it can process Windows messages. Also, all interactive commands that interact with UI + need to be executed on the message pump thread. <tt>wpf.rb</tt> includes a helper method to deal + with this. If you are using a console interactive session, do the following: + + require "wpf.rb" + Wpf.interact + } + chapter "Creating a simple Form" do introduction %{ In this exercise, you will create simple Windows Forms applications dynamically. } task :body => %{ - First, we need to load <tt>System.Windows.Forms.dll</tt> + First, we need to load <tt>System.Windows.Forms.dll</tt>. Note that it is recommended to + use the full assembly name in larger programs as such: + + load_assembly("System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089") + + However, for interactive use, we will use the short form. }, :code => "load_assembly('System.Windows.Forms')" @@ -522,7 +568,8 @@ tutorial "IronRuby tutorial" do task(:body => %{ Create an instance of the Form class and display it. }, - :code => ['f = Form.new', 'f.show']) { |i| i.bind.f.visible } + :code => ['f = Form.new', 'f.show'] + ) { |i| i.bind.f.visible } task(:body => %{ You may need to alt-tab or look for the running application since it may not have popped @@ -533,7 +580,8 @@ tutorial "IronRuby tutorial" do :setup => Proc.new { # TODO - Position the form so that it is not hidden behind the current window }, - :code => "f.text = 'Hello'") { |i| /hello/i =~ i.bind.f.text } + :code => "f.text = 'Hello'" + ) { |i| /hello/i =~ i.bind.f.text } end chapter "Adding event handlers to the Form" do @@ -551,7 +599,8 @@ tutorial "IronRuby tutorial" do IronRubyTutorial.snoop_add_handler "click", bind.f }, - :code => 'f.click { |*args| puts args }') { IronRubyTutorial.click_flag } + :code => 'f.click { |*args| puts args }' + ) { IronRubyTutorial.click_flag } task :body => %{ Now click the form. You should see output printed in the REPL window, looking something @@ -573,21 +622,22 @@ tutorial "IronRuby tutorial" do l = Label.new l.text = 'Hello' l.location = a.location - f.controls.add(l) - end - }) do |i| - f = Tutorial.stub - a = Tutorial.stub - # "l.location = a.location" is expected to fail because "a.location" currently just returns a Stub - i.bind.on_click(f, a) rescue TypeError - a.called? :location - end + f.controls.add l + end}.strip_margin + ) do |i| + f = Tutorial.stub + a = Tutorial.stub + # "l.location = a.location" is expected to fail because "a.location" currently just returns a Stub + i.bind.on_click(f, a) rescue TypeError + a.called? :location + end task(:body => %{ Now add the method as a +click+ handler }, :setup => Proc.new { |bind| IronRubyTutorial.snoop_add_handler "click", bind.f }, - :code => 'f.click { |f, a| on_click(f, a) }') { IronRubyTutorial.click_flag } + :code => 'f.click { |f, a| on_click(f, a) }' + ) { IronRubyTutorial.click_flag } task :body => %{ Now clicking on the form with the mouse will add 'Hello' labels. We can also access the @@ -599,18 +649,12 @@ tutorial "IronRuby tutorial" do After a few moments of clicking, the form will get quite crowded, so we can clear it out. Also, don't forget to close the form. }, - :code => ['f.controls.clear', 'f.close']) { |i| not i.bind.f.visible } + :code => [ + 'f.controls.clear', + 'f.close'] + ) { |i| not i.bind.f.visible } end - - summary %{ - Note that if you develop Windows applications interactively using the <tt>ir.exe</tt> from the - <b>Command Prompt</b>, IronRuby must be initialized specially for that purpose. By default, - <tt>ir.exe</tt>executes on one thread only. While this thread awaits text input, the Windows - application being dynamically created from the console is not able to process Windows messages. - Therefore, the application does not repaint itself or handle input to the UI. - - TODO - Explain what the solution to this problem is - } + end section "Advanced IronRuby - Windows Presentation Foundation" do @@ -628,6 +672,11 @@ tutorial "IronRuby tutorial" do task :body => %{ It is useful to have common initialization code while using Windows Presentation Foundation in interactive development. This is available in the +Wpf+ module in the <tt>wpf.rb</tt> file. + }, + :source_files => IronRubyTutorial.wpf_path, + :code => "require 'wpf.rb'" + + task(:body => %{ To make all the WPF class names directly available, you could do: include Wpf @@ -636,14 +685,13 @@ tutorial "IronRuby tutorial" do For example, <tt>System::Collections::Generic::List</tt> and <tt>System::Windows::Documents::List</tt>. For this reason, it is preferable to use scope access like <tt>Wpf::List</tt> instead of doing <tt>include Wpf</tt>. + + Now let's create a window. }, - :source_files => IronRubyTutorial.wpf_path, - :code => "require 'wpf.rb'" - - task(:body => %{ - Coming_soon - }, - :code => ['w = Wpf::Window.new', 'w.show']) { |i| i.bind.w.visibility == System::Windows::Visibility.visible } + :code => [ + 'w = Wpf::Window.new', + 'w.show'] + ) { |i| i.bind.w.visibility == System::Windows::Visibility.visible } task(:body => %{ You may need to alt-tab or look for the running application since it may not have popped @@ -654,7 +702,8 @@ tutorial "IronRuby tutorial" do }, :code => [ 'w.size_to_content = Wpf::SizeToContent.width_and_height', - "w.title = 'Hello'"]) { |i| String.new(i.bind.w.title) =~ /Hello/i } # TODO - String.new should not be needed here + "w.title = 'Hello'"] + ) { |i| String.new(i.bind.w.title) =~ /Hello/i } # TODO - String.new should not be needed here task(:body => %{ Let's add the content now @@ -662,12 +711,19 @@ tutorial "IronRuby tutorial" do :code => [ 'w.content = Wpf::TextBlock.new', 'w.content.text = "Hello IronRuby!"', - 'w.content.font_size = 50']) { |i| i.bind.w.content.font_size == 50 } + 'w.content.font_size = 50'] + ) { |i| i.bind.w.content.font_size == 50 } task(:body => %{ - Remove the window content + You can close the window like this" + + w.close + + However, we will just clear out the content so that we can use the same window in the + next chapter. }, - :code => 'w.content = nil') { |i| not i.bind.w.content } + :code => 'w.content = nil' + ) { |i| not i.bind.w.content } end chapter "WPF calculator" do @@ -680,17 +736,20 @@ tutorial "IronRuby tutorial" do eval %{ w = Wpf::Window.new unless defined? w and w.class == Wpf::Window w.size_to_content = Wpf::SizeToContent.width_and_height + w.content = nil w.show }, bind }, :source_files => IronRubyTutorial.calc_xaml_path, - :code => "w.content = Wpf.load_xaml_file '#{IronRubyTutorial.calc_xaml_relative_path}'") { |i| i.bind.w.content } + :code => "w.content = Wpf.load_xaml_file '#{IronRubyTutorial.calc_xaml_relative_path}'" + ) { |i| i.bind.w.content } task(:body => %{ Let's walk the calculator's object model using the +walk+ method defined in the "wpf.rb" file. }, - :code => 'Wpf.walk(w) { |c| puts c }') { |i| i.output =~ /Button: \+/ } + :code => 'Wpf.walk(w) { |c| puts c }' + ) { |i| i.output =~ /Button: \+/ } task :body => %{ Let's filter the results to button only @@ -726,21 +785,23 @@ tutorial "IronRuby tutorial" do else c.Result.text = c.Result.text + text end - end - }) { |i| i.bind.on_click(Tutorial.stub, '=') == '' } + end}.strip_margin + ) { |i| i.bind.on_click(Tutorial.stub, '=') == '' } task(:body => %{ Let's hook up the event handler }, :setup => Proc.new { |bind| IronRubyTutorial.snoop_add_handler "click", bind.buttons.first }, - :code => 'buttons.each { |b| b.click { on_click w.content, b.content } }') { |i| IronRubyTutorial.click_flag } + :code => 'buttons.each { |b| b.click { on_click w.content, b.content } }' + ) { |i| IronRubyTutorial.click_flag } task(:body => %{ Now you should be able to use the calculator! When you are done, close the calculator window. }, - :code => 'w.close') { |i| not i.bind.w.is_visible } + :code => 'w.close' + ) { |i| not i.bind.w.is_visible } end end Merlin/Main/Languages/Ruby/Samples/Tutorial/Tutorials/ironruby_tutorial.rb @@ -13,8 +13,8 @@ # # **************************************************************************** -require "tutorial" require "stringio" +require File.dirname(__FILE__) + "/tutorial" class ConsoleTutorial attr :tutorial @@ -30,23 +30,28 @@ class ConsoleTutorial @out.puts "---------------------" @out.puts "Starting #{chapter.name}" @out.print chapter.introduction + prompt = "> " chapter.tasks.each do |task| @out.puts task.description task.setup.call(@context.bind) if task.setup @out.puts "Enter the following code:" @out.puts task.code_string begin - @out.print "> " + @out.print prompt if @in.eof? then raise "No more input... (Task description: #{task.description}\nTask code: #{task.code_string})" end input = @in.gets result = @context.interact input @out.puts result.output if not result.output.empty? - if result.error + if result.partial_input? + prompt = "* " + next + elsif result.error @out.puts result.error.to_s else @out.puts "=> #{result.result.inspect}" - end + end + prompt = "> " end until task.success?(result) end @out.puts "Chapter completed successfully!" Merlin/Main/Languages/Ruby/Samples/Tutorial/console_tutorial.rb @@ -13,12 +13,12 @@ # # **************************************************************************** -require "tutorial" require "stringio" require "pathname" require "erb" require "rdoc/markup/simple_markup" require "rdoc/markup/simple_markup/to_html" +require File.dirname(__FILE__) + "/tutorial" # Utility class to convert from RDoc SimpleMarkup text to WPF FlowDocument. # It adds hyperlinking functinality to SM::ToHtml similar to Generators::HyperlinkHtml, Merlin/Main/Languages/Ruby/Samples/Tutorial/html_tutorial.rb @@ -13,18 +13,56 @@ # # **************************************************************************** +orig_dir = Dir.pwd +if $0 == __FILE__ + filename = File.expand_path __FILE__, orig_dir +else + filename = __FILE__ +end +dirname = File.dirname filename + require 'rubygems' require 'test/spec' require 'stringio' -require 'tutorial' -require 'console_tutorial' -require 'html_tutorial' +require 'fileutils' +require dirname + '/../tutorial.rb' +require dirname + '/../console_tutorial' +require dirname + '/../html_tutorial' + +FileUtils.cd(File.expand_path('/')) # This ensures that the tutorial can be launched from any folder + +describe "ReplContext" do + before(:each) do + @context = Tutorial::ReplContext.new + end + + it "works with single-line input" do + @context.interact("2+2").result.should == 4 + end + + it "works with multi-line code" do + code = ["if true", "101", "else", "102", "end"].join("\n") + @context.interact(code).result.should == 101 + end + + it "works with multi-line input" do + result = nil + ["if true", "101", "else", "102", "end"].each {|i| result = @context.interact i } + result.result.should == 101 + end + + it "can be reset" do + ["if true", "101", "else"].each {|i| @context.interact i } + @context.reset_input + @context.interact("2+2").result.should == 4 + end +end describe "ConsoleTutorial" do before(:each) do @in = StringIO.new @out = StringIO.new - tutorial = Tutorial.get_tutorial(File.dirname(__FILE__) + '/../Tutorials/tryruby_tutorial.rb') + tutorial = Tutorial.get_tutorial(dirname + '/../Tutorials/tryruby_tutorial.rb') @app = ConsoleTutorial.new tutorial, @in, @out end @@ -90,16 +128,17 @@ module TutorialTests end describe "IronRubyTutorial" do - TutorialTests.create_tests self, File.dirname(__FILE__) + '/../Tutorials/ironruby_tutorial.rb' + TutorialTests.create_tests self, dirname + '/../Tutorials/ironruby_tutorial.rb' end describe "TryRubyTutorial" do - TutorialTests.create_tests self, File.dirname(__FILE__) + '/../Tutorials/tryruby_tutorial.rb' + TutorialTests.create_tests self, dirname + '/../Tutorials/tryruby_tutorial.rb' end describe "HtmlGeneratorTests" do it "basically works" do - html_tutorial = HtmlTutorial.new + tutorial = Tutorial.get_tutorial(dirname + '/../Tutorials/tryruby_tutorial.rb') + html_tutorial = HtmlTutorial.new tutorial html = html_tutorial.generate_html assert_match %r{<h2>Table of Contents</h2>}, html end Merlin/Main/Languages/Ruby/Samples/Tutorial/test/test_console.rb @@ -46,8 +46,6 @@ module Tutorial @title = title @description = description @setup = setup - # Since we do not support multi-line commands yet, convert multi-line commands into a single ;-separated line - code = code.gsub(/\n\s*/, ' ; ') unless code.respond_to? :to_ary @code = code @source_files = source_files @success_evaluator = success_evaluator @@ -170,6 +168,7 @@ module Tutorial attr :bind def initialize + @partial_input = "" @scope = Object.new class << @scope @@ -209,7 +208,7 @@ module Tutorial Thread.current[:evaluating_tutorial_input] = true begin - result = eval(input.to_s, @bind) # TODO - to_s should not be needed here + result = eval(@partial_input + input.to_s, @bind) # TODO - to_s should not be needed here rescue Exception => error raise error if error.kind_of? SystemExit ensure @@ -218,7 +217,18 @@ module Tutorial $VERBOSE = old_verbose end - InteractionResult.new(@bind, output.string, result, error) + if error.kind_of? SyntaxError and error.message =~ /unexpected (\$end|END_OF_FILE)/ + @partial_input += input + @partial_input += "\n" unless input[input.size-1] == "\n" # TODO - input[-1] seems to cause IndexError + InteractionResult.new(@bind, "", nil, nil, true) + else + @partial_input = "" + InteractionResult.new(@bind, output.string, result, error) + end + end + + def reset_input + @partial_input = "" end end @@ -228,11 +238,12 @@ module Tutorial attr :result attr :error - def initialize(bind, output, result, error = nil) + def initialize(bind, output, result, error = nil, partial_input = false) @bind = bind @output = output @result = result @error = error + @partial_input = partial_input raise "result should be nil if an exception was raised" if result and error end @@ -242,13 +253,22 @@ module Tutorial end def result - raise "Interaction resulted in an exception" if error + raise "Interaction resulted in an exception" if error or @partial_input @result end + + def error + raise "Partial input received" if @partial_input + @error + end + + def partial_input? + @partial_input + end end - # We define a simple Stub class here instead of using one of the existing gems to avoid dependencies. - # Ideally, we could provide a simpler implementation of some existing mocking API to make this easy for folks to use + # Simple stub class for mocking. + # TODO - move to a real mocking framework class Stub def initialize() @calls = [] end @@ -388,3 +408,11 @@ class Object raise NotImplementedError end end + +class String + def strip_margin + /( *)\w/ =~ self + match = $1 + gsub(/^#{match}/, "") + end +end \ No newline at end of file Merlin/Main/Languages/Ruby/Samples/Tutorial/tutorial.rb @@ -46,7 +46,7 @@ end class System::Windows::Markup::XamlReader class << self - alias raw_load load + alias raw_load load unless method_defined? :raw_load end def self.load(xaml) @@ -87,11 +87,11 @@ class Module end class System::Windows::Threading::DispatcherObject - def invoke &block - require "system.core, Version=3.5.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" - dispatch_callback = System::Action[].new block - self.dispatcher.invoke(System::Windows::Threading::DispatcherPriority.Normal, dispatch_callback) - end + def invoke &block + require "system.core, Version=3.5.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" + dispatch_callback = System::Action[].new block + self.dispatcher.invoke(System::Windows::Threading::DispatcherPriority.Normal, dispatch_callback) + end end class System::Windows::Documents::FlowDocument @@ -100,7 +100,8 @@ class System::Windows::Documents::FlowDocument paragraph.inlines.add(System::Windows::Documents::Run.new(text)) self.blocks.add paragraph end - + + # Converts text in RDoc simple markup format to a WPF FlowDocument object def self.from_simple_markup text require 'rdoc/markup/simple_markup' require 'rdoc/markup/simple_markup/inline' @@ -140,9 +141,9 @@ module Wpf def self.load_xaml_file(filename) f = System::IO::FileStream.new filename, System::IO::FileMode.open, System::IO::FileAccess.read begin - element = XamlReader.load f + element = XamlReader.load f ensure - f.close + f.close end element end @@ -151,19 +152,19 @@ module Wpf # Note that it also includes content (which could be just strings). def self.walk(tree, &b) if not block_given? - result = [] - walk(tree) { |child| result << child } - return result + result = [] + walk(tree) { |child| result << child } + return result end yield tree if tree.respond_to? :Children - tree.Children.each { |child| walk child, &b } + tree.Children.each { |child| walk child, &b } elsif tree.respond_to? :Child - walk tree.Child, &b + walk tree.Child, &b elsif tree.respond_to? :Content - walk tree.Content, &b + walk tree.Content, &b end end @@ -199,6 +200,57 @@ module Wpf false end + def self.create_sta_thread &block + ts = System::Threading::ThreadStart.new &block + + # Workaround for http://ironruby.codeplex.com/WorkItem/View.aspx?WorkItemId=1306 + param_types = System::Array[System::Type].new(1) { |i| System::Threading::ThreadStart.to_clr_type } + ctor = System::Threading::Thread.to_clr_type.get_constructor param_types + t = ctor.Invoke(System::Array[Object].new(1) { ts }) + t.ApartmentState = System::Threading::ApartmentState.STA + t.Start + end + + # Some setup is needed to use WPF from an interactive session console (like iirb). This is because + # WPF needs to do message pumping on a thread, iirb also requires a thread to read user input, + # and all commands that interact with UI need to be executed on the message pump thread. + def self.interact + raise NotImplementedError + def CallBack(function, priority = DispatcherPriority.Normal) + Application.Current.Dispatcher.BeginInvoke(priority, System::Action[].new(function)) + end + + def CallBack1(function, arg0, priority = DispatcherPriority.Normal) + Application.Current.Dispatcher.BeginInvoke(priority, System::Action[arg0.class].new(function), arg0) + end + + dispatcher = nil + message_pump_started = System::Threading::AutoResetEvent.new false + + create_sta_thread do + app = Application.new + app.startup do + dispatcher = Dispatcher.FromThread System::Threading::Thread.current_thread + message_pump_started.set + end + begin + app.run + ensure + IronRuby::Ruby.SetCommandDispatcher(None) # This is a non-existent method that will need to be implemented + end + end + + message_pump_started.wait_one + + def dispatch_console_command(console_command) + if console_command + dispatcher.invoke DispatcherPriority.Normal, console_command + end + end + + IronRuby::Ruby.SetCommandDispatcher dispatch_console_command # This is a non-existent method that will need to be implemented + end + class ToFlowDocument include System::Windows include System::Windows::Documents Merlin/Main/Languages/Ruby/Samples/Tutorial/wpf.rb @@ -55,17 +55,6 @@ module WpfTutorial end end - def create_sta_thread &block - ts = System::Threading::ThreadStart.new &block - - # Workaround for http://ironruby.codeplex.com/WorkItem/View.aspx?WorkItemId=1306 - param_types = System::Array[System::Type].new(1) { |i| System::Threading::ThreadStart.to_clr_type } - ctor = System::Threading::Thread.to_clr_type.get_constructor param_types - t = ctor.Invoke(System::Array[Object].new(1) { ts }) - t.ApartmentState = System::Threading::ApartmentState.STA - t.Start - end - def run_interactive(proc_obj) if Application.Current app_callback = System::Threading::ThreadStart.new { proc_obj.call rescue puts $! } @@ -73,7 +62,7 @@ module WpfTutorial else warn "Setting explicit shutdown. Exit the process by calling 'unload'" # Run the app on another thread so that the interactive REPL can stay on the main thread - create_sta_thread { proc_obj.call rescue puts $! } + Wpf.create_sta_thread { proc_obj.call rescue puts $! } end end end @@ -377,6 +366,8 @@ module WpfTutorial @window.repl_input.show! @window.repl_input.focus + Window.repl.set_prompt + Window.repl.context.reset_input # TODO - Should use TextChanged here @window.repl_input.key_up do |target, event_args| if event_args.key == Key.enter @@ -432,7 +423,7 @@ module WpfTutorial def initialize @context = ::Tutorial::ReplContext.new @prev_newline = nil - + # Hook-up "puts" so that we can redirect asynchronous "puts" (typically called from event-handlers) - atleast # the ones that are entered into the REPL class << @context.scope @@ -456,17 +447,25 @@ module WpfTutorial history.scroll_to_line(history.line_count - 1) end + def set_prompt p = ">>>" + @prompt = p + Window.current.repl_input_arrow.content = p + end + def on_repl_input print '' if @prev_newline history.show! input = self.input.text - print ">>> #{input}" + print "#{@prompt} #{input}" + set_prompt self.input.text = '' result = @context.interact input print result.output, false unless result.output.empty? - if result.error + if result.partial_input? + set_prompt "..." + elsif result.error print result.error.to_s else print "=> #{result.result.inspect}" Merlin/Main/Languages/Ruby/Samples/Tutorial/wpf_tutorial.rb @@ -92,7 +92,7 @@ def using(file) content = read_file_content(file) snippet_count = 0 - content.match(/^\s*#if RUBY\s*(.*?)#endif/m) do + content.gsub(/^\s*#if RUBY\s*(.*?)#endif/m) do snippet_count += 1 snippet = $1 @@ -103,7 +103,7 @@ def using(file) end def eval_metavariables(content) - content.match(/\/\*\$\$\*\/([^;]*)/) do + content.gsub(/\/\*\$\$\*\/([^;]*)/) do eval('$' + $1) puts $1 end Merlin/Main/Languages/Ruby/Scripts/CodeGenerator.rb @@ -58,7 +58,7 @@ class IRTest if File.exists?(file = "#{@root}\\Scripts\\Python\\GenerateSystemCoreCsproj.py") cmd = "#{@root}\\Bin\\Debug\\ipy.exe #{file}" - run_cmd cmd { @results << "Dev10 Build failed!!!" } + run_cmd(cmd) { @results << "Dev10 Build failed!!!" } end end Merlin/Main/Languages/Ruby/Scripts/irtests.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/A/a.generated.dll Merlin/Main/Languages/Ruby/Tests/Interop/net/B/b.generated.dll @@ -330,7 +330,7 @@ public interface IEmptyInterfaceGroup { } public interface IInterfaceGroup1<T> {void m1();} public interface IInterfaceGroup1<T,V> {void m1();} -#line 224 "./method/invocation/generic_spec.rb" +#line 226 "./method/invocation/generic_spec.rb" public partial class ClassWithMethods { #region private methods private string Private1Generic0Arg<T>() { @@ -459,7 +459,7 @@ public partial class ClassWithMethods { } public partial class SubKlass : Klass {} -#line 262 "./method/invocation/generic_spec.rb" +#line 264 "./method/invocation/generic_spec.rb" #pragma warning disable 693 public partial class GenericClassWithMethods<K> { #region private methods @@ -584,7 +584,7 @@ public partial class ClassWithMethods { } #pragma warning restore 693 -#line 289 "./method/invocation/generic_spec.rb" +#line 291 "./method/invocation/generic_spec.rb" #pragma warning disable 693 public partial class GenericClass2Params<K, J> { #region private methods Merlin/Main/Languages/Ruby/Tests/Interop/net/fixtures.generated.cs Merlin/Main/Languages/Ruby/Tests/Interop/net/fixtures.generated.dll @@ -11,6 +11,26 @@ describe "Reflecting on regular .NET methods" do before(:each) do @obj = ClassWithMethods.new end + + it "IronRuby::Clr::Name implements equality comparison so that include? works on dual names" do + System::AppDomain.singleton_methods.include?(:unload).should be_true + System::AppDomain.singleton_methods.include?("unload").should be_true + System::AppDomain.singleton_methods.include?("Unload").should be_false + end + + ruby_version_is "".."1.8.6" do + it "simple names are represented by strings" do + System::AppDomain.singleton_methods.include?(:Equals).should be_false + System::AppDomain.singleton_methods.include?("Equals").should be_true + end + end + + ruby_version_is "1.9" do + it "simple names are represented by symbols" do + System::AppDomain.singleton_methods.include?(:Equals).should be_true + System::AppDomain.singleton_methods.include?("Equals").should be_false + end + end it "are included in an objects method list" do #.instance_methods(true) Merlin/Main/Languages/Ruby/Tests/Interop/net/method/reflection_spec.rb @@ -1182,7 +1182,7 @@ namespace Microsoft.Scripting.Generation { //CONFORMING [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity")] private void EmitNumericConversion(Type typeFrom, Type typeTo, bool isChecked) { - bool isFromUnsigned = TypeUtils.IsUnsigned(typeFrom); + bool isFromUnsigned = TypeUtils.IsUnsignedInt(typeFrom); bool isFromFloatingPoint = TypeUtils.IsFloatingPoint(typeFrom); if (typeTo == typeof(Single)) { if (isFromUnsigned) Merlin/Main/Runtime/Microsoft.Scripting/Generation/ILGen.cs @@ -870,24 +870,31 @@ namespace Microsoft.Scripting.Interpreter { } } - public class NewInstruction : Instruction { - private ConstructorInfo _constructor; - private int _argCount; + public sealed class NewInstruction : Instruction { + private readonly ConstructorInfo _constructor; + private readonly int _argCount; public NewInstruction(ConstructorInfo constructor) { - this._constructor = constructor; - this._argCount = constructor.GetParameters().Length; + _constructor = constructor; + _argCount = constructor.GetParameters().Length; } public override int ConsumedStack { get { return _argCount; } } public override int ProducedStack { get { return 1; } } + public override int Run(InterpretedFrame frame) { object[] args = new object[_argCount]; for (int i = _argCount - 1; i >= 0; i--) { args[i] = frame.Pop(); } - object ret = _constructor.Invoke(args); + object ret; + try { + ret = _constructor.Invoke(args); + } catch (TargetInvocationException e) { + ExceptionHelpers.UpdateForRethrow(e.InnerException); + throw e.InnerException; + } frame.Push(ret); return +1; } @@ -916,12 +923,13 @@ namespace Microsoft.Scripting.Interpreter { private readonly FieldInfo _field; public FieldAccessInstruction(FieldInfo field) { - Debug.Assert(!field.IsStatic); + Assert.NotNull(field); _field = field; } public override int ConsumedStack { get { return 1; } } public override int ProducedStack { get { return 1; } } + public override int Run(InterpretedFrame frame) { frame.Push(_field.GetValue(frame.Pop())); return +1; @@ -932,12 +940,13 @@ namespace Microsoft.Scripting.Interpreter { private readonly FieldInfo _field; public FieldAssignInstruction(FieldInfo field) { - Debug.Assert(!field.IsStatic); + Assert.NotNull(field); _field = field; } public override int ConsumedStack { get { return 2; } } public override int ProducedStack { get { return 0; } } + public override int Run(InterpretedFrame frame) { object value = frame.Pop(); object self = frame.Pop(); @@ -986,6 +995,234 @@ namespace Microsoft.Scripting.Interpreter { } } + public abstract class NumericConvertInstruction : Instruction { + internal readonly TypeCode _from, _to; + + public NumericConvertInstruction(TypeCode from, TypeCode to) { + _from = from; + _to = to; + } + + public override int ConsumedStack { get { return 1; } } + public override int ProducedStack { get { return 1; } } + + public override string ToString() { + return InstructionName + "(" + _from + "->" + _to + ")"; + } + + public sealed class Unchecked : NumericConvertInstruction { + public override string InstructionName { get { return "UncheckedConvert"; } } + + public Unchecked(TypeCode from, TypeCode to) + : base(from, to) { + } + + public override int Run(InterpretedFrame frame) { + frame.Push(Convert(frame.Pop())); + return +1; + } + + private object Convert(object obj) { + switch (_from) { + case TypeCode.Byte: return ConvertInt32((Byte)obj); + case TypeCode.SByte: return ConvertInt32((SByte)obj); + case TypeCode.Int16: return ConvertInt32((Int16)obj); + case TypeCode.Char: return ConvertInt32((Char)obj); + case TypeCode.Int32: return ConvertInt32((Int32)obj); + case TypeCode.Int64: return ConvertInt64((Int64)obj); + case TypeCode.UInt16: return ConvertInt32((UInt16)obj); + case TypeCode.UInt32: return ConvertInt64((UInt32)obj); + case TypeCode.UInt64: return ConvertUInt64((UInt64)obj); + case TypeCode.Single: return ConvertDouble((Single)obj); + case TypeCode.Double: return ConvertDouble((Double)obj); + default: throw Assert.Unreachable; + } + } + + private object ConvertInt32(int obj) { + unchecked { + switch (_to) { + case TypeCode.Byte: return (Byte)obj; + case TypeCode.SByte: return (SByte)obj; + case TypeCode.Int16: return (Int16)obj; + case TypeCode.Char: return (Char)obj; + case TypeCode.Int32: return (Int32)obj; + case TypeCode.Int64: return (Int64)obj; + case TypeCode.UInt16: return (UInt16)obj; + case TypeCode.UInt32: return (UInt32)obj; + case TypeCode.UInt64: return (UInt64)obj; + case TypeCode.Single: return (Single)obj; + case TypeCode.Double: return (Double)obj; + default: throw Assert.Unreachable; + } + } + } + + private object ConvertInt64(Int64 obj) { + unchecked { + switch (_to) { + case TypeCode.Byte: return (Byte)obj; + case TypeCode.SByte: return (SByte)obj; + case TypeCode.Int16: return (Int16)obj; + case TypeCode.Char: return (Char)obj; + case TypeCode.Int32: return (Int32)obj; + case TypeCode.Int64: return (Int64)obj; + case TypeCode.UInt16: return (UInt16)obj; + case TypeCode.UInt32: return (UInt32)obj; + case TypeCode.UInt64: return (UInt64)obj; + case TypeCode.Single: return (Single)obj; + case TypeCode.Double: return (Double)obj; + default: throw Assert.Unreachable; + } + } + } + + private object ConvertUInt64(UInt64 obj) { + unchecked { + switch (_to) { + case TypeCode.Byte: return (Byte)obj; + case TypeCode.SByte: return (SByte)obj; + case TypeCode.Int16: return (Int16)obj; + case TypeCode.Char: return (Char)obj; + case TypeCode.Int32: return (Int32)obj; + case TypeCode.Int64: return (Int64)obj; + case TypeCode.UInt16: return (UInt16)obj; + case TypeCode.UInt32: return (UInt32)obj; + case TypeCode.UInt64: return (UInt64)obj; + case TypeCode.Single: return (Single)obj; + case TypeCode.Double: return (Double)obj; + default: throw Assert.Unreachable; + } + } + } + + private object ConvertDouble(Double obj) { + unchecked { + switch (_to) { + case TypeCode.Byte: return (Byte)obj; + case TypeCode.SByte: return (SByte)obj; + case TypeCode.Int16: return (Int16)obj; + case TypeCode.Char: return (Char)obj; + case TypeCode.Int32: return (Int32)obj; + case TypeCode.Int64: return (Int64)obj; + case TypeCode.UInt16: return (UInt16)obj; + case TypeCode.UInt32: return (UInt32)obj; + case TypeCode.UInt64: return (UInt64)obj; + case TypeCode.Single: return (Single)obj; + case TypeCode.Double: return (Double)obj; + default: throw Assert.Unreachable; + } + } + } + } + + public sealed class Checked : NumericConvertInstruction { + public override string InstructionName { get { return "CheckedConvert"; } } + + public Checked(TypeCode from, TypeCode to) + : base(from, to) { + } + + public override int Run(InterpretedFrame frame) { + frame.Push(Convert(frame.Pop())); + return +1; + } + + private object Convert(object obj) { + switch (_from) { + case TypeCode.Byte: return ConvertInt32((Byte)obj); + case TypeCode.SByte: return ConvertInt32((SByte)obj); + case TypeCode.Int16: return ConvertInt32((Int16)obj); + case TypeCode.Char: return ConvertInt32((Char)obj); + case TypeCode.Int32: return ConvertInt32((Int32)obj); + case TypeCode.Int64: return ConvertInt64((Int64)obj); + case TypeCode.UInt16: return ConvertInt32((UInt16)obj); + case TypeCode.UInt32: return ConvertInt64((UInt32)obj); + case TypeCode.UInt64: return ConvertUInt64((UInt64)obj); + case TypeCode.Single: return ConvertDouble((Single)obj); + case TypeCode.Double: return ConvertDouble((Double)obj); + default: throw Assert.Unreachable; + } + } + + private object ConvertInt32(int obj) { + checked { + switch (_to) { + case TypeCode.Byte: return (Byte)obj; + case TypeCode.SByte: return (SByte)obj; + case TypeCode.Int16: return (Int16)obj; + case TypeCode.Char: return (Char)obj; + case TypeCode.Int32: return (Int32)obj; + case TypeCode.Int64: return (Int64)obj; + case TypeCode.UInt16: return (UInt16)obj; + case TypeCode.UInt32: return (UInt32)obj; + case TypeCode.UInt64: return (UInt64)obj; + case TypeCode.Single: return (Single)obj; + case TypeCode.Double: return (Double)obj; + default: throw Assert.Unreachable; + } + } + } + + private object ConvertInt64(Int64 obj) { + checked { + switch (_to) { + case TypeCode.Byte: return (Byte)obj; + case TypeCode.SByte: return (SByte)obj; + case TypeCode.Int16: return (Int16)obj; + case TypeCode.Char: return (Char)obj; + case TypeCode.Int32: return (Int32)obj; + case TypeCode.Int64: return (Int64)obj; + case TypeCode.UInt16: return (UInt16)obj; + case TypeCode.UInt32: return (UInt32)obj; + case TypeCode.UInt64: return (UInt64)obj; + case TypeCode.Single: return (Single)obj; + case TypeCode.Double: return (Double)obj; + default: throw Assert.Unreachable; + } + } + } + + private object ConvertUInt64(UInt64 obj) { + checked { + switch (_to) { + case TypeCode.Byte: return (Byte)obj; + case TypeCode.SByte: return (SByte)obj; + case TypeCode.Int16: return (Int16)obj; + case TypeCode.Char: return (Char)obj; + case TypeCode.Int32: return (Int32)obj; + case TypeCode.Int64: return (Int64)obj; + case TypeCode.UInt16: return (UInt16)obj; + case TypeCode.UInt32: return (UInt32)obj; + case TypeCode.UInt64: return (UInt64)obj; + case TypeCode.Single: return (Single)obj; + case TypeCode.Double: return (Double)obj; + default: throw Assert.Unreachable; + } + } + } + + private object ConvertDouble(Double obj) { + checked { + switch (_to) { + case TypeCode.Byte: return (Byte)obj; + case TypeCode.SByte: return (SByte)obj; + case TypeCode.Int16: return (Int16)obj; + case TypeCode.Char: return (Char)obj; + case TypeCode.Int32: return (Int32)obj; + case TypeCode.Int64: return (Int64)obj; + case TypeCode.UInt16: return (UInt16)obj; + case TypeCode.UInt32: return (UInt32)obj; + case TypeCode.UInt64: return (UInt64)obj; + case TypeCode.Single: return (Single)obj; + case TypeCode.Double: return (Double)obj; + default: throw Assert.Unreachable; + } + } + } + } + } + public class NotInstruction : Instruction { public static readonly Instruction Instance = new NotInstruction(); @@ -1014,20 +1251,7 @@ namespace Microsoft.Scripting.Interpreter { public abstract class EqualInstruction : Instruction { // Perf: EqualityComparer<T> but is 3/2 to 2 times slower. - - public static readonly Instruction Reference = new EqualReference(); - public static readonly Instruction Boolean = new EqualBoolean(); - public static readonly Instruction SByte = new EqualSByte(); - public static readonly Instruction Int16 = new EqualInt16(); - public static readonly Instruction Char = new EqualChar(); - public static readonly Instruction Int32 = new EqualInt32(); - public static readonly Instruction Int64 = new EqualInt64(); - public static readonly Instruction Byte = new EqualByte(); - public static readonly Instruction UInt16 = new EqualUInt16(); - public static readonly Instruction UInt32 = new EqualUInt32(); - public static readonly Instruction UInt64 = new EqualUInt64(); - public static readonly Instruction Single = new EqualSingle(); - public static readonly Instruction Double = new EqualDouble(); + private static Instruction _Reference, _Boolean, _SByte, _Int16, _Char, _Int32, _Int64, _Byte, _UInt16, _UInt32, _UInt64, _Single, _Double; public override int ConsumedStack { get { return 2; } } public override int ProducedStack { get { return 1; } } @@ -1129,24 +1353,24 @@ namespace Microsoft.Scripting.Interpreter { public static Instruction Create(Type type) { // Boxed enums can be unboxed as their underlying types: switch (Type.GetTypeCode(type.IsEnum ? Enum.GetUnderlyingType(type) : type)) { - case TypeCode.Boolean: return Boolean; - case TypeCode.SByte: return SByte; - case TypeCode.Byte: return Byte; - case TypeCode.Char: return Char; - case TypeCode.Int16: return Int16; - case TypeCode.Int32: return Int32; - case TypeCode.Int64: return Int64; + case TypeCode.Boolean: return _Boolean ?? (_Boolean = new EqualBoolean()); + case TypeCode.SByte: return _SByte ?? (_SByte = new EqualSByte()); + case TypeCode.Byte: return _Byte ?? (_Byte = new EqualByte()); + case TypeCode.Char: return _Char ?? (_Char = new EqualChar()); + case TypeCode.Int16: return _Int16 ?? (_Int16 = new EqualInt16()); + case TypeCode.Int32: return _Int32 ?? (_Int32 = new EqualInt32()); + case TypeCode.Int64: return _Int64 ?? (_Int64 = new EqualInt64()); - case TypeCode.UInt16: return UInt16; - case TypeCode.UInt32: return UInt32; - case TypeCode.UInt64: return UInt64; + case TypeCode.UInt16: return _UInt16 ?? (_UInt16 = new EqualInt16()); + case TypeCode.UInt32: return _UInt32 ?? (_UInt32 = new EqualInt32()); + case TypeCode.UInt64: return _UInt64 ?? (_UInt64 = new EqualInt64()); - case TypeCode.Single: return Single; - case TypeCode.Double: return Double; + case TypeCode.Single: return _Single ?? (_Single = new EqualSingle()); + case TypeCode.Double: return _Double ?? (_Double = new EqualDouble()); case TypeCode.Object: if (!type.IsValueType) { - return Reference; + return _Reference ?? (_Reference = new EqualReference()); } // TODO: Nullable<T> throw new NotImplementedException(); @@ -1163,21 +1387,8 @@ namespace Microsoft.Scripting.Interpreter { public abstract class NotEqualInstruction : Instruction { // Perf: EqualityComparer<T> but is 3/2 to 2 times slower. - - public static readonly Instruction Reference = new NotEqualReference(); - public static readonly Instruction Boolean = new NotEqualBoolean(); - public static readonly Instruction SByte = new NotEqualSByte(); - public static readonly Instruction Int16 = new NotEqualInt16(); - public static readonly Instruction Char = new NotEqualChar(); - public static readonly Instruction Int32 = new NotEqualInt32(); - public static readonly Instruction Int64 = new NotEqualInt64(); - public static readonly Instruction Byte = new NotEqualByte(); - public static readonly Instruction UInt16 = new NotEqualUInt16(); - public static readonly Instruction UInt32 = new NotEqualUInt32(); - public static readonly Instruction UInt64= new NotEqualUInt64(); - public static readonly Instruction Single = new NotEqualSingle(); - public static readonly Instruction Double = new NotEqualDouble(); - + private static Instruction _Reference, _Boolean, _SByte, _Int16, _Char, _Int32, _Int64, _Byte, _UInt16, _UInt32, _UInt64, _Single, _Double; + public override int ConsumedStack { get { return 2; } } public override int ProducedStack { get { return 1; } } @@ -1278,24 +1489,24 @@ namespace Microsoft.Scripting.Interpreter { public static Instruction Instance(Type type) { // Boxed enums can be unboxed as their underlying types: switch (Type.GetTypeCode(type.IsEnum ? Enum.GetUnderlyingType(type) : type)) { - case TypeCode.Boolean: return Boolean; - case TypeCode.SByte: return SByte; - case TypeCode.Byte: return Byte; - case TypeCode.Char: return Char; - case TypeCode.Int16: return Int16; - case TypeCode.Int32: return Int32; - case TypeCode.Int64: return Int64; + case TypeCode.Boolean: return _Boolean ?? (_Boolean = new NotEqualBoolean()); + case TypeCode.SByte: return _SByte ?? (_SByte = new NotEqualSByte()); + case TypeCode.Byte: return _Byte ?? (_Byte = new NotEqualByte()); + case TypeCode.Char: return _Char ?? (_Char = new NotEqualChar()); + case TypeCode.Int16: return _Int16 ?? (_Int16 = new NotEqualInt16()); + case TypeCode.Int32: return _Int32 ?? (_Int32 = new NotEqualInt32()); + case TypeCode.Int64: return _Int64 ?? (_Int64 = new NotEqualInt64()); - case TypeCode.UInt16: return UInt16; - case TypeCode.UInt32: return UInt32; - case TypeCode.UInt64: return UInt64; + case TypeCode.UInt16: return _UInt16 ?? (_UInt16 = new NotEqualInt16()); + case TypeCode.UInt32: return _UInt32 ?? (_UInt32 = new NotEqualInt32()); + case TypeCode.UInt64: return _UInt64 ?? (_UInt64 = new NotEqualInt64()); - case TypeCode.Single: return Single; - case TypeCode.Double: return Double; + case TypeCode.Single: return _Single ?? (_Single = new NotEqualSingle()); + case TypeCode.Double: return _Double ?? (_Double = new NotEqualDouble()); case TypeCode.Object: if (!type.IsValueType) { - return Reference; + return _Reference ?? (_Reference = new NotEqualReference()); } // TODO: Nullable<T> throw new NotImplementedException(); @@ -1310,6 +1521,138 @@ namespace Microsoft.Scripting.Interpreter { } } + public abstract class LessThanInstruction : Instruction { + private static Instruction _SByte, _Int16, _Char, _Int32, _Int64, _Byte, _UInt16, _UInt32, _UInt64, _Single, _Double; + + public override int ConsumedStack { get { return 2; } } + public override int ProducedStack { get { return 1; } } + + private LessThanInstruction() { + } + + internal sealed class LessThanSByte : LessThanInstruction { + public override int Run(InterpretedFrame frame) { + frame.Push(((SByte)frame.Pop()) < ((SByte)frame.Pop())); + return +1; + } + } + + internal sealed class LessThanInt16 : LessThanInstruction { + public override int Run(InterpretedFrame frame) { + frame.Push(((Int16)frame.Pop()) < ((Int16)frame.Pop())); + return +1; + } + } + + internal sealed class LessThanChar : LessThanInstruction { + public override int Run(InterpretedFrame frame) { + frame.Push(((Char)frame.Pop()) < ((Char)frame.Pop())); + return +1; + } + } + + internal sealed class LessThanInt32 : LessThanInstruction { + public override int Run(InterpretedFrame frame) { + frame.Push(((Int32)frame.Pop()) < ((Int32)frame.Pop())); + return +1; + } + } + + internal sealed class LessThanInt64 : LessThanInstruction { + public override int Run(InterpretedFrame frame) { + frame.Push(((Int64)frame.Pop()) < ((Int64)frame.Pop())); + return +1; + } + } + + internal sealed class LessThanByte : LessThanInstruction { + public override int Run(InterpretedFrame frame) { + frame.Push(((Byte)frame.Pop()) < ((Byte)frame.Pop())); + return +1; + } + } + + internal sealed class LessThanUInt16 : LessThanInstruction { + public override int Run(InterpretedFrame frame) { + frame.Push(((UInt16)frame.Pop()) < ((UInt16)frame.Pop())); + return +1; + } + } + + internal sealed class LessThanUInt32 : LessThanInstruction { + public override int Run(InterpretedFrame frame) { + frame.Push(((UInt32)frame.Pop()) < ((UInt32)frame.Pop())); + return +1; + } + } + + internal sealed class LessThanUInt64 : LessThanInstruction { + public override int Run(InterpretedFrame frame) { + frame.Push(((UInt64)frame.Pop()) < ((UInt64)frame.Pop())); + return +1; + } + } + + internal sealed class LessThanSingle : LessThanInstruction { + public override int Run(InterpretedFrame frame) { + frame.Push(((Single)frame.Pop()) < ((Single)frame.Pop())); + return +1; + } + } + + internal sealed class LessThanDouble : LessThanInstruction { + public override int Run(InterpretedFrame frame) { + frame.Push(((Double)frame.Pop()) < ((Double)frame.Pop())); + return +1; + } + } + + public static Instruction Instance(Type type) { + Debug.Assert(!type.IsEnum); + switch (Type.GetTypeCode(type)) { + case TypeCode.SByte: return _SByte ?? (_SByte = new LessThanSByte()); + case TypeCode.Byte: return _Byte ?? (_Byte = new LessThanSByte()); + case TypeCode.Char: return _Char ?? (_Char = new LessThanSByte()); + case TypeCode.Int16: return _Int16 ?? (_Int16 = new LessThanSByte()); + case TypeCode.Int32: return _Int32 ?? (_Int32 = new LessThanSByte()); + case TypeCode.Int64: return _Int64 ?? (_Int64 = new LessThanSByte()); + case TypeCode.UInt16: return _UInt16 ?? (_UInt16 = new LessThanSByte()); + case TypeCode.UInt32: return _UInt32 ?? (_UInt32 = new LessThanSByte()); + case TypeCode.UInt64: return _UInt64 ?? (_UInt64 = new LessThanSByte()); + case TypeCode.Single: return _Single ?? (_Single = new LessThanSByte()); + case TypeCode.Double: return _Double ?? (_Double = new LessThanSByte()); + + default: + throw Assert.Unreachable; + } + } + + public override string ToString() { + return "LessThan()"; + } + } + + public sealed class TypeEqualsInstruction : Instruction { + public static readonly TypeEqualsInstruction Instance = new TypeEqualsInstruction(); + + public override int ConsumedStack { get { return 2; } } + public override int ProducedStack { get { return 1; } } + + private TypeEqualsInstruction() { + } + + public override int Run(InterpretedFrame frame) { + Type type = (Type)frame.Pop(); + object obj = frame.Pop(); + frame.Push(ScriptingRuntimeHelpers.BooleanToObject(obj != null && obj.GetType() == type)); + return +1; + } + + public override string InstructionName { + get { return "TypeEquals()"; } + } + } + #endregion public class RuntimeVariablesInstruction : Instruction { Merlin/Main/Runtime/Microsoft.Scripting/Interpreter/Instruction.cs @@ -21,6 +21,7 @@ using System.Reflection; using System.Threading; using Microsoft.Scripting.Utils; using AstUtils = Microsoft.Scripting.Ast.Utils; +using Microsoft.Scripting.Generation; namespace Microsoft.Scripting.Interpreter { @@ -564,8 +565,12 @@ namespace Microsoft.Scripting.Interpreter { FieldInfo fi = member.Member as FieldInfo; if (fi != null) { - this.Compile(member.Expression); - this.Compile(node.Right); + if (member.Expression != null) { + Compile(member.Expression); + } else { + PushConstant(null); + } + Compile(node.Right); int index = 0; if (!asVoid) { @@ -639,6 +644,10 @@ namespace Microsoft.Scripting.Interpreter { CompileNotEqual(node.Left, node.Right); return; + case ExpressionType.LessThan: + CompileLessThan(node.Left, node.Right); + return; + default: throw new NotImplementedException(); } @@ -659,6 +668,17 @@ namespace Microsoft.Scripting.Interpreter { AddInstruction(NotEqualInstruction.Instance(left.Type)); } + private void CompileLessThan(Expression left, Expression right) { + Debug.Assert(left.Type == right.Type && TypeUtils.IsNumeric(left.Type)); + + // TODO: + // if (TypeUtils.IsNullableType(left.Type) && liftToNull) ... + + Compile(left); + Compile(right); + AddInstruction(LessThanInstruction.Instance(left.Type)); + } + private void CompileAdd(Expression left, Expression right) { if (left.Type == typeof(int) && right.Type == typeof(int)) { Compile(left); @@ -688,7 +708,8 @@ namespace Microsoft.Scripting.Interpreter { Compile(index); AddInstruction(SetArrayItemInstruction<object>.Instance); } else { - throw new NotImplementedException(); + // TODO: this code doesn't work, we just need to visit the expressions and force compilation + _forceCompile = true; } } @@ -707,16 +728,42 @@ namespace Microsoft.Scripting.Interpreter { private void CompileConvertUnaryExpression(Expression expr) { var node = (UnaryExpression)expr; - - // TODO: check the logic on this, but we think we can ignore conversions in this boxed world - Compile(node.Operand); - if (node.Method != null) { + Compile(node.Operand); + // We should be able to ignore Int32ToObject if (node.Method != Runtime.ScriptingRuntimeHelpers.Int32ToObjectMethod) { AddInstruction(new CallInstruction(node.Method)); } + } else if (node.Type == typeof(void)) { + CompileAsVoid(node.Operand); + } else { + Compile(node.Operand); + CompileConvertToType(node.Operand.Type, node.Type, node.NodeType == ExpressionType.ConvertChecked); + } + } + + private void CompileConvertToType(Type typeFrom, Type typeTo, bool isChecked) { + Debug.Assert(typeFrom != typeof(void) && typeTo != typeof(void)); + + if (TypeUtils.AreEquivalent(typeTo, typeFrom)) { + return; + } + + TypeCode from = Type.GetTypeCode(typeFrom); + TypeCode to = Type.GetTypeCode(typeTo); + if (TypeUtils.IsNumeric(from) && TypeUtils.IsNumeric(to)) { + if (isChecked) { + AddInstruction(new NumericConvertInstruction.Checked(from, to)); + } else { + AddInstruction(new NumericConvertInstruction.Unchecked(from, to)); + } + return; } + + // TODO: Conversions to a super-class or implemented interfaces are no-op. + // A conversion to a non-implemented interface or an unrelated class, etc. should fail. + return; } private void CompileNotExpression(UnaryExpression node) { @@ -1081,7 +1128,11 @@ namespace Microsoft.Scripting.Interpreter { return; } - //TODO support pass by reference and lots of other fancy stuff + //TODO support pass by reference and lots of other fancy stuff; + // force compilation for now: + if (!CollectionUtils.TrueForAll(node.Method.GetParameters(), (p) => !p.IsByRefParameter())) { + _forceCompile = true; + } if (!node.Method.IsStatic) { this.Compile(node.Object); @@ -1319,7 +1370,15 @@ namespace Microsoft.Scripting.Interpreter { } private void CompileInvocationExpression(Expression expr) { - throw new System.NotImplementedException(); + var node = (InvocationExpression)expr; + + // TODO: LambdaOperand optimization (see compiler) + if (typeof(LambdaExpression).IsAssignableFrom(node.Expression.Type)) { + throw new System.NotImplementedException(); + } + + // TODO: do not create a new Call Expression + CompileMethodCallExpression(Expression.Call(node.Expression, node.Expression.Type.GetMethod("Invoke"), node.Arguments)); } private void CompileListInitExpression(Expression expr) { @@ -1335,10 +1394,33 @@ namespace Microsoft.Scripting.Interpreter { } private void CompileUnboxUnaryExpression(Expression expr) { - throw new System.NotImplementedException(); + var node = (UnaryExpression)expr; + // unboxing is a nop: + Compile(node.Operand); + } + + private void CompileTypeEqualExpression(Expression expr) { + Debug.Assert(expr.NodeType == ExpressionType.TypeEqual); + var node = (TypeBinaryExpression)expr; + + Compile(node.Expression); + PushConstant(node.TypeOperand); + AddInstruction(TypeEqualsInstruction.Instance); } - private void CompileTypeBinaryExpression(Expression expr) { + private void CompileTypeIsExpression(Expression expr) { + Debug.Assert(expr.NodeType == ExpressionType.TypeIs); + var node = (TypeBinaryExpression)expr; + + // use TypeEqual for sealed types: + if (node.TypeOperand.IsSealed) { + Compile(node.Expression); + PushConstant(node.TypeOperand); + AddInstruction(TypeEqualsInstruction.Instance); + return; + } + + // TODO: throw new System.NotImplementedException(); } @@ -1434,7 +1516,7 @@ namespace Microsoft.Scripting.Interpreter { case ExpressionType.Subtract: CompileBinaryExpression(expr); break; case ExpressionType.SubtractChecked: CompileBinaryExpression(expr); break; case ExpressionType.TypeAs: CompileUnaryExpression(expr); break; - case ExpressionType.TypeIs: CompileTypeBinaryExpression(expr); break; + case ExpressionType.TypeIs: CompileTypeIsExpression(expr); break; case ExpressionType.Assign: CompileAssignBinaryExpression(expr, expr.Type == typeof(void)); break; case ExpressionType.Block: CompileBlockExpression(expr, expr.Type == typeof(void)); break; case ExpressionType.DebugInfo: CompileDebugInfoExpression(expr); break; @@ -1452,7 +1534,7 @@ namespace Microsoft.Scripting.Interpreter { case ExpressionType.Throw: CompileThrowUnaryExpression(expr, expr.Type == typeof(void)); break; case ExpressionType.Try: CompileTryExpression(expr); break; case ExpressionType.Unbox: CompileUnboxUnaryExpression(expr); break; - case ExpressionType.TypeEqual: CompileTypeBinaryExpression(expr); break; + case ExpressionType.TypeEqual: CompileTypeEqualExpression(expr); break; case ExpressionType.OnesComplement: CompileUnaryExpression(expr); break; case ExpressionType.IsTrue: CompileUnaryExpression(expr); break; case ExpressionType.IsFalse: CompileUnaryExpression(expr); break; Merlin/Main/Runtime/Microsoft.Scripting/Interpreter/LightCompiler.cs @@ -22,6 +22,7 @@ using Microsoft.Scripting.Runtime; namespace Microsoft.Scripting.Utils { static class TypeUtils { + // keep in sync with System.Core version internal static Type GetNonNullableType(Type type) { if (IsNullableType(type)) { return type.GetGenericArguments()[0]; @@ -29,35 +30,44 @@ namespace Microsoft.Scripting.Utils { return type; } + // keep in sync with System.Core version internal static bool IsNullableType(Type type) { return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>); } + // keep in sync with System.Core version internal static bool IsBool(Type type) { return GetNonNullableType(type) == typeof(bool); } + // keep in sync with System.Core version internal static bool IsNumeric(Type type) { type = GetNonNullableType(type); if (!type.IsEnum) { - switch (Type.GetTypeCode(type)) { - case TypeCode.Char: - case TypeCode.SByte: - case TypeCode.Byte: - case TypeCode.Int16: - case TypeCode.Int32: - case TypeCode.Int64: - case TypeCode.Double: - case TypeCode.Single: - case TypeCode.UInt16: - case TypeCode.UInt32: - case TypeCode.UInt64: - return true; - } + return IsNumeric(Type.GetTypeCode(type)); } return false; } + internal static bool IsNumeric(TypeCode typeCode) { + switch (typeCode) { + case TypeCode.Char: + case TypeCode.SByte: + case TypeCode.Byte: + case TypeCode.Int16: + case TypeCode.Int32: + case TypeCode.Int64: + case TypeCode.Double: + case TypeCode.Single: + case TypeCode.UInt16: + case TypeCode.UInt32: + case TypeCode.UInt64: + return true; + } + return false; + } + + // keep in sync with System.Core version internal static bool IsArithmetic(Type type) { type = GetNonNullableType(type); if (!type.IsEnum) { @@ -76,7 +86,8 @@ namespace Microsoft.Scripting.Utils { return false; } - internal static bool IsUnsigned(Type type) { + // keep in sync with System.Core version + internal static bool IsUnsignedInt(Type type) { type = GetNonNullableType(type); if (!type.IsEnum) { switch (Type.GetTypeCode(type)) { @@ -89,6 +100,7 @@ namespace Microsoft.Scripting.Utils { return false; } + // keep in sync with System.Core version internal static bool IsIntegerOrBool(Type type) { type = GetNonNullableType(type); if (!type.IsEnum) { @@ -226,6 +238,15 @@ namespace Microsoft.Scripting.Utils { } // keep in sync with System.Core version + internal static bool AreEquivalent(Type t1, Type t2) { +#if !SYSTEM_CORE + return t1 == t2; +#else + return t1 == t2 || t1.IsEquivalentTo(t2); +#endif + } + + // keep in sync with System.Core version internal static bool AreReferenceAssignable(Type dest, Type src) { // WARNING: This actually implements "Is this identity assignable and/or reference assignable?" if (dest == src) { Merlin/Main/Runtime/Microsoft.Scripting/Utils/TypeUtils.cs @@ -18,6 +18,7 @@ using System.Collections.ObjectModel; using System.Diagnostics; using System.Dynamic.Utils; using System.Linq.Expressions.Compiler; +using System.Reflection; using System.Runtime.CompilerServices; namespace System.Linq.Expressions { @@ -559,13 +560,13 @@ namespace System.Linq.Expressions { ValidateOneArgument(method, ExpressionType.Dynamic, arg1, parameters[2]); ValidateDynamicArgument(arg2); ValidateOneArgument(method, ExpressionType.Dynamic, arg2, parameters[3]); - ValidateDynamicArgument(arg2); + ValidateDynamicArgument(arg3); ValidateOneArgument(method, ExpressionType.Dynamic, arg3, parameters[4]); return DynamicExpression.Make(method.GetReturnType(), delegateType, binder, arg0, arg1, arg2, arg3); } - private static System.Reflection.MethodInfo GetValidMethodForDynamic(Type delegateType) { + private static MethodInfo GetValidMethodForDynamic(Type delegateType) { var method = delegateType.GetMethod("Invoke"); var pi = method.GetParametersCached(); ContractUtils.Requires(pi.Length > 0 && pi[0].ParameterType == typeof(CallSite), "delegateType", Strings.FirstArgumentMustBeCallSite); ndp/fx/src/Core/Microsoft/Scripting/Ast/DynamicExpression.cs @@ -26,34 +26,6 @@ namespace System.Linq.Expressions { internal static class ConstantCheck { - /// <summary> - /// Tests to see if the expression is a constant with the given value. - /// </summary> - /// <param name="e">The expression to examine</param> - /// <param name="value">The constant value to check for.</param> - /// <returns>true/false</returns> - [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily")] - internal static bool IsConstant(Expression e, bool value) { - switch (e.NodeType) { - case ExpressionType.AndAlso: - return CheckAndAlso((BinaryExpression)e, value); - - case ExpressionType.OrElse: - return CheckOrElse((BinaryExpression)e, value); - - case ExpressionType.Constant: - return value.Equals(((ConstantExpression)e).Value); - - case ExpressionType.TypeIs: - AnalyzeTypeIsResult result = AnalyzeTypeIs((TypeBinaryExpression)e); - if (value) { - return result == AnalyzeTypeIsResult.KnownTrue; - } - return result == AnalyzeTypeIsResult.KnownFalse; - } - return false; - } - internal static bool IsNull(Expression e) { switch (e.NodeType) { case ExpressionType.Constant: @@ -68,35 +40,6 @@ namespace System.Linq.Expressions { } - private static bool CheckAndAlso(BinaryExpression node, bool value) { - Debug.Assert(node.NodeType == ExpressionType.AndAlso); - - if (node.Method != null || node.IsLifted) { - return false; - } - - if (value) { - return IsConstant(node.Left, true) && IsConstant(node.Right, true); - } else { - // if left isn't a constant it has to be evaluated - return IsConstant(node.Left, false); - } - } - - private static bool CheckOrElse(BinaryExpression node, bool value) { - Debug.Assert(node.NodeType == ExpressionType.OrElse); - - if (node.Method != null || node.IsLifted) { - return false; - } - - if (value) { - return IsConstant(node.Left, true); - } else { - return IsConstant(node.Left, false) && IsConstant(node.Right, false); - } - } - /// <summary> /// If the result of a TypeBinaryExpression is known statically, this /// returns the result, otherwise it returns null, meaning we'll need ndp/fx/src/Core/Microsoft/Scripting/Compiler/ConstantCheck.cs @@ -443,12 +443,38 @@ namespace System.Linq.Expressions.Compiler { #region Optimized branching + /// <summary> + /// Emits the expression and then either brtrue/brfalse to the label. + /// </summary> + /// <param name="branchValue">True for brtrue, false for brfalse.</param> + /// <param name="node">The expression to emit.</param> + /// <param name="label">The label to conditionally branch to.</param> + /// <remarks> + /// This function optimizes equality and short circuiting logical + /// operators to avoid double-branching, minimize instruction count, + /// and generate similar IL to the C# compiler. This is important for + /// the JIT to optimize patterns like: + /// x != null AndAlso x.GetType() == typeof(SomeType) + /// + /// One optimization we don't do: we always emits at least one + /// conditional branch to the label, and always possibly falls through, + /// even if we know if the branch will always succeed or always fail. + /// We do this to avoid generating unreachable code, which is fine for + /// the CLR JIT, but doesn't verify with peverify. + /// + /// This kind of optimization could be implemented safely, by doing + /// constant folding over conditionals and logical expressions at the + /// tree level. + /// </remarks> [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily")] private void EmitExpressionAndBranch(bool branchValue, Expression node, Label label) { CompilationFlags startEmitted = EmitExpressionStart(node); try { if (node.Type == typeof(bool)) { switch (node.NodeType) { + case ExpressionType.Not: + EmitBranchNot(branchValue, (UnaryExpression)node, label); + return; case ExpressionType.AndAlso: case ExpressionType.OrElse: EmitBranchLogical(branchValue, (BinaryExpression)node, label); @@ -473,6 +499,15 @@ namespace System.Linq.Expressions.Compiler { _ilg.Emit(branch ? OpCodes.Brtrue : OpCodes.Brfalse, label); } + private void EmitBranchNot(bool branch, UnaryExpression node, Label label) { + if (node.Method != null) { + EmitExpression(node, CompilationFlags.EmitAsNoTail | CompilationFlags.EmitNoExpressionStart); + EmitBranchOp(branch, label); + return; + } + EmitExpressionAndBranch(!branch, node.Operand, label); + } + private void EmitBranchComparison(bool branch, BinaryExpression node, Label label) { Debug.Assert(node.NodeType == ExpressionType.Equal || node.NodeType == ExpressionType.NotEqual); Debug.Assert(!node.IsLiftedToNull); @@ -555,35 +590,29 @@ namespace System.Linq.Expressions.Compiler { // if (!(left && right)) branch value // becomes: // if (!left || !right) branch value - + // + // The observation is that "brtrue(x && y)" has the same codegen as + // "brfalse(x || y)" except the branches have the opposite sign. + // Same for "brfalse(x && y)" and "brtrue(x || y)". + // if (branch == isAnd) { - EmitBranchAnd(branch, (BinaryExpression)node, label); + EmitBranchAnd(branch, node, label); } else { - EmitBranchOr(branch, (BinaryExpression)node, label); + EmitBranchOr(branch, node, label); } } // Generates optimized AndAlso with branch == true // or optimized OrElse with branch == false private void EmitBranchAnd(bool branch, BinaryExpression node, Label label) { - // if (left AND right) branch label - - if (!ConstantCheck.IsConstant(node.Left, !branch) && !ConstantCheck.IsConstant(node.Right, !branch)) { - if (ConstantCheck.IsConstant(node.Left, branch)) { - EmitExpressionAndBranch(branch, node.Right, label); - } else if (ConstantCheck.IsConstant(node.Right, branch)) { - EmitExpressionAndBranch(branch, node.Left, label); - } else { - // if (left) then - // if (right) branch label - // endif - - Label endif = _ilg.DefineLabel(); - EmitExpressionAndBranch(!branch, node.Left, endif); - EmitExpressionAndBranch(branch, node.Right, label); - _ilg.MarkLabel(endif); - } - } + // if (left) then + // if (right) branch label + // endif + + Label endif = _ilg.DefineLabel(); + EmitExpressionAndBranch(!branch, node.Left, endif); + EmitExpressionAndBranch(branch, node.Right, label); + _ilg.MarkLabel(endif); } // Generates optimized OrElse with branch == true @@ -591,19 +620,8 @@ namespace System.Linq.Expressions.Compiler { private void EmitBranchOr(bool branch, BinaryExpression node, Label label) { // if (left OR right) branch label - if (ConstantCheck.IsConstant(node.Left, branch)) { - _ilg.Emit(OpCodes.Br, label); - } else { - if (!ConstantCheck.IsConstant(node.Left, !branch)) { - EmitExpressionAndBranch(branch, node.Left, label); - } - - if (ConstantCheck.IsConstant(node.Right, branch)) { - _ilg.Emit(OpCodes.Br, label); - } else if (!ConstantCheck.IsConstant(node.Right, !branch)) { - EmitExpressionAndBranch(branch, node.Right, label); - } - } + EmitExpressionAndBranch(branch, node.Left, label); + EmitExpressionAndBranch(branch, node.Right, label); } private void EmitBranchBlock(bool branch, BlockExpression node, Label label) { ndp/fx/src/Core/Microsoft/Scripting/Compiler/LambdaCompiler.Logical.cs @@ -203,27 +203,3 @@ namespace System { } #endif - -#if !SPECSHARP - -namespace Microsoft.Contracts { - [Conditional("SPECSHARP"), AttributeUsage(AttributeTargets.Delegate | AttributeTargets.Event | AttributeTargets.Property | AttributeTargets.Method | AttributeTargets.Constructor, AllowMultiple = false, Inherited = true)] - internal sealed class StateIndependentAttribute : Attribute { - } - -#if MICROSOFT_SCRIPTING_CORE - [Conditional("SPECSHARP"), AttributeUsage(AttributeTargets.Delegate | AttributeTargets.Event | AttributeTargets.Property | AttributeTargets.Method | AttributeTargets.Constructor, AllowMultiple = false, Inherited = true)] - internal sealed class PureAttribute : Attribute { - } -#endif - - [Conditional("SPECSHARP"), AttributeUsage(AttributeTargets.Delegate | AttributeTargets.Event | AttributeTargets.Property | AttributeTargets.Method | AttributeTargets.Constructor, AllowMultiple = false, Inherited = true)] - internal sealed class ConfinedAttribute : Attribute { - } - - [Conditional("SPECSHARP"), AttributeUsage(AttributeTargets.Field)] - internal sealed class StrictReadonlyAttribute : Attribute { - } -} - -#endif ndp/fx/src/Core/Microsoft/Scripting/Stubs.cs b1fe23ee1dc61e14ef70586945f4ad639fd63fa8 Jim Deville jdeville@microsoft.com http://github.com/ironruby/ironruby/commit/2b73aba8bde0e6cf2ee0e579d6dabee57836708a 2b73aba8bde0e6cf2ee0e579d6dabee57836708a 2009-06-19T10:46:46-07:00 2009-06-19T10:46:46-07:00 Syncing to head of TFS e404820686b7e27f8de84c8e6c26b01afc429890 Jim Deville jdeville@microsoft.com