edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/IronRuby.Tests/RubyTests.cs;C924186 File: RubyTests.cs =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/IronRuby.Tests/RubyTests.cs;C924186 (server) 6/1/2009 1:32 PM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/IronRuby.Tests/RubyTests.cs;ClrInteropBugFixes @@ -343,6 +343,7 @@ RequireInterop1, Load1, LibraryLoader1, + LoadAssembly1, ClrFields1, ClrTypes1, @@ -384,6 +385,7 @@ ClrEvents4, ClrOverride1, ClrOverride2, + ClrOverride3, ClrConstructor1, ClrConstructor2, ClrConstructor3, =================================================================== edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/IronRuby.Tests/Runtime/ClrTests.cs;C924186 File: ClrTests.cs =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/IronRuby.Tests/Runtime/ClrTests.cs;C924186 (server) 6/1/2009 10:50 AM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/IronRuby.Tests/Runtime/ClrTests.cs;ClrInteropBugFixes @@ -26,16 +26,24 @@ namespace InteropTests.Generics1 { public class C { - public int Arity { get { return 0; } } + public virtual int Arity { get { return 0; } } } public class C { - public int Arity { get { return 1; } } + public virtual int Arity { get { return 1; } } } public class C { - public int Arity { get { return 2; } } + public virtual int Arity { get { return 2; } } } + + public class D : C { + public override int Arity { get { return 10; } } + } + + public class D : C { + public override int Arity { get { return 11; } } + } } namespace IronRuby.Tests { @@ -197,6 +205,15 @@ 3 [Int32 BinarySearch(System.Object)] "); + + TestOutput(@" +class C < Array +end + +p C.new.clr_member(:get_enumerator).call.move_next +", @" +false +"); } public class ProtectedA { @@ -1114,18 +1131,37 @@ public void ClrGenerics1() { Runtime.LoadAssembly(typeof(Tests).Assembly); - AssertOutput(delegate() { - CompilerTest(@" + TestOutput(@" include InteropTests::Generics1 p C +p D +p C.new +p D.new # test if we don't use cached dispatch to C.new again +p C.clr_new +p D.clr_new +p C.superclass +p D.superclass +", @" +# +# +InteropTests.Generics1.C +InteropTests.Generics1.D +InteropTests.Generics1.C +InteropTests.Generics1.D +Object +InteropTests::Generics1::C +"); + + TestOutput(@" +include InteropTests::Generics1 p C.new.arity p C[String].new.arity +p D[String].new.arity p C[Fixnum, Fixnum].new.arity -"); - }, @" -# +", @" 0 1 +11 2 "); } @@ -1334,12 +1370,16 @@ public void ClrDelegates2() { Runtime.LoadAssembly(typeof(Func<>).Assembly); + Runtime.LoadAssembly(typeof(Action).Assembly); - var f = Engine.Execute>(@" -System::Func.of(Fixnum, Fixnum).new { |a| a + 1 } -"); + var f = Engine.Execute>(@"System::Func.of(Fixnum, Fixnum).new { |a| a + 1 }"); + Assert(f(1) == 2); - Assert(f(1) == 2); + Engine.Execute(@"System::Action.new { $x = 1 }")(); + Assert((int)Context.GetGlobalVariable("x") == 1); + + Engine.Execute>(@"System::Action[Fixnum].new { |x| $x = x + 1 }")(10); + Assert((int)Context.GetGlobalVariable("x") == 11); } public void ClrEvents1() { @@ -1523,6 +1563,32 @@ Assert(obj.Equals(obj)); } + public class ClassCallingVirtualInCtor1 { + public ClassCallingVirtualInCtor1() { + VirtualMethod(); + } + + public virtual int VirtualMethod() { + return 1; + } + } + + /// + /// We need to fully initialize the derived type before calling base ctor. + /// The ebase ctor can call virtual methods that require _class to be set. + /// + public void ClrOverride3() { + Context.ObjectClass.SetConstant("C", Context.GetClass(typeof(ClassCallingVirtualInCtor1))); + TestOutput(@" +class D < C +end + +p D.new.virtual_method +", @" +1 +"); + } + public class ClassWithNonEmptyConstructor { public int P { get; set; } =================================================================== edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/IronRuby.Tests/Runtime/LoaderTests.cs;C922537 File: LoaderTests.cs =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/IronRuby.Tests/Runtime/LoaderTests.cs;C922537 (server) 6/1/2009 4:32 PM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/IronRuby.Tests/Runtime/LoaderTests.cs;ClrInteropBugFixes @@ -19,6 +19,7 @@ using System.Dynamic; using IronRuby.Builtins; using IronRuby.Runtime; +using Microsoft.Scripting.Actions; namespace IronRuby.Tests { public partial class Tests { @@ -41,14 +42,14 @@ b = Loader.TryParseAssemblyName(str, out type, out assembly); Assert(b == false); - str = "IronRuby.Runtime.RubyContext, IronRuby, Version=0.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"; + str = "IronRuby.Runtime.RubyContext, IronRuby, Version=" + RubyContext.IronRubyVersionString + ", Culture=neutral, PublicKeyToken=31bf3856ad364e35"; b = Loader.TryParseAssemblyName(str, out type, out assembly); - Assert(b == true && - assembly == "IronRuby, Version=0.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" && + Assert(b == true && + assembly == "IronRuby, Version=" + RubyContext.IronRubyVersionString + ", Culture=neutral, PublicKeyToken=31bf3856ad364e35" && type == "IronRuby.Runtime.RubyContext" ); - - str = "IronRuby, Version=0.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"; + + str = "IronRuby, Version=" + RubyContext.IronRubyVersionString + ", Culture=neutral, PublicKeyToken=31bf3856ad364e35"; b = Loader.TryParseAssemblyName(str, out type, out assembly); Assert(b == true && assembly == str && type == null); @@ -56,7 +57,7 @@ b = Loader.TryParseAssemblyName(str, out type, out assembly); Assert(b == true && assembly == str && type == null); - str = "IronRuby, Version=0.5.0.0"; + str = "IronRuby, Version=" + RubyContext.IronRubyVersionString; b = Loader.TryParseAssemblyName(str, out type, out assembly); Assert(b == true && assembly == str && type == null); } @@ -116,6 +117,14 @@ } } + public void LoadAssembly1() { + if (_driver.PartialTrust) return; + bool loaded = false; + Context.DomainManager.AssemblyLoaded += new EventHandler((_, __) => loaded = true); + Assert(KernelOps.LoadAssembly(Context, null, MutableString.Create("System.Core"), null)); + Assert(loaded); + } + public void RequireInterop1() { if (_driver.PartialTrust || !_driver.RunPython) return; =================================================================== edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Initializers.Generated.cs;C924186 File: Initializers.Generated.cs =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Initializers.Generated.cs;C924186 (server) 6/1/2009 10:43 AM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Initializers.Generated.cs;ClrInteropBugFixes @@ -3472,6 +3472,19 @@ new System.Func(IronRuby.Builtins.TypeGroupOps.Of) ); + module.DefineLibraryMethod("clr_constructor", 0x51, + new System.Func(IronRuby.Builtins.TypeGroupOps.GetClrConstructor) + ); + + module.DefineLibraryMethod("clr_ctor", 0x51, + new System.Func(IronRuby.Builtins.TypeGroupOps.GetClrConstructor) + ); + + module.DefineLibraryMethod("clr_new", 0x51, + new System.Func>, Microsoft.Scripting.Actions.TypeGroup, System.Object[], System.Object>(IronRuby.Builtins.TypeGroupOps.ClrNew), + new System.Func>, IronRuby.Runtime.BlockParam, Microsoft.Scripting.Actions.TypeGroup, System.Object[], System.Object>(IronRuby.Builtins.TypeGroupOps.ClrNew) + ); + module.DefineLibraryMethod("each", 0x51, new System.Func(IronRuby.Builtins.TypeGroupOps.EachType) ); @@ -3484,12 +3497,19 @@ new System.Func(IronRuby.Builtins.TypeGroupOps.GetName) ); - module.DefineRuleGenerator("new", 0x51, IronRuby.Builtins.TypeGroupOps.GetInstanceConstructor()); + module.DefineLibraryMethod("new", 0x51, + new System.Func>, Microsoft.Scripting.Actions.TypeGroup, System.Object[], System.Object>(IronRuby.Builtins.TypeGroupOps.New), + new System.Func>, IronRuby.Runtime.BlockParam, Microsoft.Scripting.Actions.TypeGroup, System.Object[], System.Object>(IronRuby.Builtins.TypeGroupOps.New) + ); module.DefineLibraryMethod("of", 0x51, new System.Func(IronRuby.Builtins.TypeGroupOps.Of) ); + module.DefineLibraryMethod("superclass", 0x51, + new System.Func(IronRuby.Builtins.TypeGroupOps.GetSuperclass) + ); + module.DefineLibraryMethod("to_s", 0x51, new System.Func(IronRuby.Builtins.TypeGroupOps.GetName) ); @@ -5051,10 +5071,6 @@ new System.Func(IronRuby.Builtins.IEnumerableOps.Each) ); - module.DefineLibraryMethod("GetEnumerator", 0x51, - new System.Func(IronRuby.Builtins.IEnumerableOps.GetEnumerator) - ); - } private static void LoadSystem__Collections__IList_Instance(IronRuby.Builtins.RubyModule/*!*/ module) { =================================================================== edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/KernelOps.cs;C924186 File: KernelOps.cs =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/KernelOps.cs;C924186 (server) 6/1/2009 10:39 AM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/KernelOps.cs;ClrInteropBugFixes @@ -413,7 +413,7 @@ [DefaultProtocol, NotNull]MutableString/*!*/ assemblyName, [DefaultProtocol, Optional, NotNull]MutableString libraryNamespace) { string initializer = libraryNamespace != null ? LibraryInitializer.GetFullTypeName(libraryNamespace.ConvertToString()) : null; - return context.Loader.LoadAssembly(assemblyName.ConvertToString(), initializer, true); + return context.Loader.LoadAssembly(assemblyName.ConvertToString(), initializer, true, true); } [RubyMethod("require", RubyMethodAttributes.PrivateInstance)] @@ -1432,7 +1432,7 @@ // thread-safe: /// /// Returns a RubyMethod instance that represents one or more CLR members of given name. - /// An exception is thrown if the class of self doesn't represent a CLR type or if the member is not found. + /// An exception is thrown if the member is not found. /// Name could be of Ruby form (foo_bar) or CLR form (FooBar). Operator names are translated /// (e.g. "+" to op_Addition, "[]"/"[]=" to a default index getter/setter). /// The resulting RubyMethod might represent multiple CLR members (overloads). @@ -1440,18 +1440,14 @@ /// Includes all CLR members that match the name even if they are not callable from Ruby - /// they are hidden by a Ruby member or their declaring type is not included in the ancestors list of the class. /// Includes members of any Ruby visibility. - /// Includes CLR protected members. + /// Includes CLR protected members. /// Includes CLR private members if PrivateBinding is on. /// [RubyMethod("clr_member")] public static RubyMethod/*!*/ GetClrMember(RubyContext/*!*/ context, object self, [DefaultProtocol, NotNull]string/*!*/ name) { RubyMemberInfo info; + RubyClass cls = context.GetClassOf(self); - - if (cls.TypeTracker == null) { - throw RubyExceptions.CreateNotClrTypeError(cls); - } - if (!cls.TryGetClrMember(name, out info)) { throw RubyExceptions.CreateNameError(String.Format("undefined CLR method `{0}' for class `{1}'", name, cls.Name)); } =================================================================== edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Extensions/TypeGroupOps.cs;C922537 File: TypeGroupOps.cs =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Extensions/TypeGroupOps.cs;C922537 (server) 6/1/2009 11:19 AM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Extensions/TypeGroupOps.cs;ClrInteropBugFixes @@ -19,16 +19,15 @@ using Microsoft.Scripting.Actions; using IronRuby.Runtime; using IronRuby.Runtime.Calls; +using IronRuby.Compiler.Generation; +using Ast = System.Linq.Expressions.Expression; +using AstUtils = Microsoft.Scripting.Ast.Utils; +using System.Runtime.CompilerServices; namespace IronRuby.Builtins { [RubyClass(Extends = typeof(TypeGroup), Restrictions = ModuleRestrictions.None)] [Includes(typeof(Enumerable))] public class TypeGroupOps { - - [RubyMethod("new")] - public static RuleGenerator/*!*/ GetInstanceConstructor() { - return new RuleGenerator(RuleGenerators.InstanceConstructorForGroup); - } [RubyMethod("of")] [RubyMethod("[]")] @@ -91,5 +90,85 @@ return result; } + + private static Type/*!*/ GetNonGenericType(TypeGroup/*!*/ self) { + TypeTracker type = self.GetTypeForArity(0); + if (type == null) { + throw RubyExceptions.CreateTypeError("type group doesn't include non-generic type"); + } + + return type.Type; + } + + [Emitted] + public static RubyClass/*!*/ GetNonGenericClass(RubyContext/*!*/ context, TypeGroup/*!*/ typeGroup) { + Type type = GetNonGenericType(typeGroup); + if (type.IsInterface) { + throw RubyExceptions.CreateTypeError("cannot instantiate an interface"); + } + return context.GetClass(type); + } + + private static object/*!*/ New(string/*!*/ methodName, CallSiteStorage>/*!*/ storage, + TypeGroup/*!*/ self,[NotNull]params object[] args) { + + var cls = GetNonGenericClass(storage.Context, self); + var site = storage.GetCallSite(methodName, + new RubyCallSignature(1, RubyCallFlags.HasImplicitSelf | RubyCallFlags.HasSplattedArgument) + ); + + return site.Target(site, cls, RubyOps.MakeArrayN(args)); + } + + private static object/*!*/ New(string/*!*/ methodName, CallSiteStorage>/*!*/ storage, BlockParam block, + TypeGroup/*!*/ self, [NotNull]params object[] args) { + + var cls = GetNonGenericClass(storage.Context, self); + var site = storage.GetCallSite(methodName, + new RubyCallSignature(1, RubyCallFlags.HasImplicitSelf | RubyCallFlags.HasSplattedArgument | RubyCallFlags.HasBlock) + ); + + return site.Target(site, cls, block != null ? block.Proc : null, RubyOps.MakeArrayN(args)); + } + + // ARGS: N + [RubyMethod("new")] + public static object/*!*/ New(CallSiteStorage>/*!*/ storage, + TypeGroup/*!*/ self, [NotNull]params object[] args) { + return New("new", storage, self, args); + } + + // ARGS: N& + [RubyMethod("new")] + public static object/*!*/ New(CallSiteStorage>/*!*/ storage, BlockParam block, + TypeGroup/*!*/ self, [NotNull]params object[] args) { + return New("new", storage, block, self, args); + } + + [RubyMethod("superclass")] + public static RubyClass GetSuperclass(RubyContext/*!*/ context, TypeGroup/*!*/ self) { + Type type = GetNonGenericType(self); + return type.IsInterface ? null : context.GetClass(type).SuperClass; + } + + // ARGS: N + [RubyMethod("clr_new")] + public static object/*!*/ ClrNew(CallSiteStorage>/*!*/ storage, + TypeGroup/*!*/ self, [NotNull]params object[] args) { + return New("clr_new", storage, self, args); + } + + // ARGS: N& + [RubyMethod("clr_new")] + public static object/*!*/ ClrNew(CallSiteStorage>/*!*/ storage, BlockParam block, + TypeGroup/*!*/ self, [NotNull]params object[] args) { + return New("clr_new", storage, block, self, args); + } + + [RubyMethod("clr_ctor")] + [RubyMethod("clr_constructor")] + public static RubyMethod/*!*/ GetClrConstructor(RubyContext/*!*/ context, TypeGroup/*!*/ self) { + return ClassOps.GetClrConstructor(GetNonGenericClass(context, self)); + } } } =================================================================== edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Builtins/RubyClass.cs;C924186 File: RubyClass.cs =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Builtins/RubyClass.cs;C924186 (server) 6/1/2009 10:46 AM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Builtins/RubyClass.cs;ClrInteropBugFixes @@ -624,11 +624,18 @@ // thread safe: doesn't need any lock since it only accesses immutable state public bool TryGetClrMember(string/*!*/ name, out RubyMemberInfo method) { + // Get the first class in hierarchy that represents CLR type - worse case we end up with Object. + // Ruby classes don't represent a CLR type and hence expose no CLR members. + RubyClass cls = this; + while (cls.TypeTracker == null) { + cls = cls.SuperClass; + } + + Debug.Assert(!cls.TypeTracker.Type.IsInterface); + // Note: We don't cache failures as this API is not used so frequently (e.g. for regular method dispatch) that we would need caching. method = null; - return TypeTracker != null - && !TypeTracker.Type.IsInterface - && TryGetClrMember(TypeTracker.Type, name, true, 0, out method); + return cls.TryGetClrMember(cls.TypeTracker.Type, name, true, 0, out method); } // thread safe: doesn't need any lock since it only accesses immutable state @@ -1147,6 +1154,7 @@ RubyMemberInfo initializer; using (Context.ClassHierarchyLocker()) { + // check version of the class so that we invalidate the rule whenever the initializer changes: metaBuilder.AddVersionTest(this); initializer = ResolveMethodForSiteNoLock(Symbols.Initialize, IgnoreVisibility).Info; @@ -1287,15 +1295,12 @@ private void BuildDelegateConstructorCall(MetaObjectBuilder/*!*/ metaBuilder, CallArguments/*!*/ args, Type/*!*/ type) { if (args.Signature.HasBlock) { - if (args.ExplicitArgumentCount == 2) { + var actualArgs = RubyOverloadResolver.NormalizeArguments(metaBuilder, args, 0, 0); + if (!metaBuilder.Error) { metaBuilder.Result = Methods.CreateDelegateFromProc.OpCall( AstUtils.Constant(type), AstUtils.Convert(args.GetBlockExpression(), typeof(Proc)) ); - } else { - metaBuilder.SetError(Methods.MakeWrongNumberOfArgumentsError.OpCall( - AstUtils.Constant(args.ExplicitArgumentCount - 1), AstUtils.Constant(0) - )); } } else { var actualArgs = RubyOverloadResolver.NormalizeArguments(metaBuilder, args, 1, 1); =================================================================== edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Compiler/Generation/RubyTypeBuilder.cs;C922537 File: RubyTypeBuilder.cs =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Compiler/Generation/RubyTypeBuilder.cs;C922537 (server) 6/1/2009 1:36 PM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Compiler/Generation/RubyTypeBuilder.cs;ClrInteropBugFixes @@ -219,6 +219,12 @@ int paramIndex = 0; int argIndex = 0; + // We need to initialize before calling base ctor since the ctor can call virtual methods. + // _class = class: + il.EmitLoadArg(0); + il.EmitLoadArg(1 + ctor.ClassParamIndex); + il.EmitFieldSet(_classField); + // base ctor call: il.EmitLoadArg(0); @@ -249,10 +255,6 @@ il.Emit(OpCodes.Call, ctor.BaseCtor); } - // _class = class: - il.EmitLoadArg(0); - il.EmitLoadArg(1 + ctor.ClassParamIndex); - il.EmitFieldSet(_classField); il.Emit(OpCodes.Ret); } } =================================================================== edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Runtime/Loader.cs;C904229 File: Loader.cs =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Runtime/Loader.cs;C904229 (server) 6/1/2009 4:08 PM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Runtime/Loader.cs;ClrInteropBugFixes @@ -161,7 +161,6 @@ } } - [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2001:AvoidCallingProblematicMethods", MessageId = "System.Reflection.Assembly.LoadFrom")] // TODO private Dictionary/*!*/ LoadCompiledCode() { Debug.Assert(_context.RubyOptions.LoadFromDisk); @@ -247,7 +246,7 @@ return false; } - if (LoadAssembly(assemblyName, typeName, false)) { + if (LoadAssembly(assemblyName, typeName, false, false)) { FileLoaded(path, flags); return true; } @@ -258,12 +257,27 @@ #region Assemblies - public bool LoadAssembly(string/*!*/ assemblyName, string typeName, bool throwOnError) { + [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2001:AvoidCallingProblematicMethods", MessageId = "System.Reflection.Assembly.LoadWithPartialName")] + public bool LoadAssembly(string/*!*/ assemblyName, string typeName, bool throwOnError, bool tryPartialName) { Utils.Log(String.Format("Loading assembly '{0}' and type '{1}'", assemblyName, typeName), "LOADER"); Assembly assembly; try { - assembly = Platform.LoadAssembly(assemblyName); + try { + assembly = Platform.LoadAssembly(assemblyName); + } catch (FileNotFoundException) { +#if SILVERLIGHT + throw; +#else + if (tryPartialName) { +#pragma warning disable 618,612 // csc, gmcs + assembly = Assembly.LoadWithPartialName(assemblyName); +#pragma warning restore 618,612 + } else { + throw; + } +#endif + } } catch (Exception e) { if (throwOnError) throw new LoadError(e.Message, e); return false; =================================================================== edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Runtime/Calls/RuleGenerators.cs;C790584 File: RuleGenerators.cs =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Runtime/Calls/RuleGenerators.cs;C790584 (server) 6/1/2009 3:55 PM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Runtime/Calls/RuleGenerators.cs;ClrInteropBugFixes @@ -29,12 +29,6 @@ ((RubyClass)args.Target).BuildObjectConstruction(metaBuilder, args, name); } - public static void InstanceConstructorForGroup(MetaObjectBuilder/*!*/ metaBuilder, CallArguments/*!*/ args, string/*!*/ name) { - RubyClass cls = args.RubyContext.GetClass(((TypeGroup)args.Target).Type); - - cls.BuildObjectConstruction(metaBuilder, args, name); - } - public static void InstanceAllocator(MetaObjectBuilder/*!*/ metaBuilder, CallArguments/*!*/ args, string/*!*/ name) { ((RubyClass)args.Target).BuildObjectAllocation(metaBuilder, args, name); } ===================================================================