edit: $/Dev10/feature/vs_langs01_s/Merlin/Main/Languages/Ruby/IronRuby.Tests/Runtime/RubyUtilsTests.cs;C1042261 File: RubyUtilsTests.cs =================================================================== --- $/Dev10/feature/vs_langs01_s/Merlin/Main/Languages/Ruby/IronRuby.Tests/Runtime/RubyUtilsTests.cs;C1042261 (server) 9/21/2009 1:08 PM +++ Shelved Change: $/Dev10/feature/vs_langs01_s/Merlin/Main/Languages/Ruby/IronRuby.Tests/Runtime/RubyUtilsTests.cs;BugFixes @@ -21,7 +21,7 @@ Assert(RubyUtils.TryUnmangleName("stack") == "Stack"); Assert(RubyUtils.TryUnmangleName("this_is_my_long_name") == "ThisIsMyLongName"); Assert(RubyUtils.TryUnmangleName("f") == "F"); - Assert(RubyUtils.TryUnmangleName("initialize") == null); + Assert(RubyUtils.TryUnmangleName("initialize") == "Initialize"); // non-alpha characters are treated as lower-case letters: Assert(RubyUtils.TryUnmangleName("foo_bar=") == "FooBar="); @@ -72,13 +72,18 @@ Assert(RubyUtils.TryUnmangleName("foo__bar") == null); Assert(RubyUtils.TryUnmangleName("_foo") == null); Assert(RubyUtils.TryUnmangleName("foo_") == null); + + // special method names: + Assert(RubyUtils.TryUnmangleMethodName("initialize") == null); + Assert(RubyUtils.TryUnmangleMethodName("class") == null); + Assert(RubyUtils.TryUnmangleMethodName("message") == "Message"); // we don't special case Exception.Message } public void NameMangling2() { Assert(RubyUtils.TryMangleName("Stack") == "stack"); Assert(RubyUtils.TryMangleName("ThisIsMyLongName") == "this_is_my_long_name"); Assert(RubyUtils.TryMangleName("F") == "f"); - Assert(RubyUtils.TryMangleName("Initialize") == null); + Assert(RubyUtils.TryMangleName("Initialize") == "initialize"); Assert(RubyUtils.TryMangleName("fooBar") == "foo_bar"); // characters that are not upper case letters are treated as lower-case: @@ -139,6 +144,11 @@ Assert(RubyUtils.TryMangleName("foo__bar") == null); Assert(RubyUtils.TryMangleName("_foo") == null); Assert(RubyUtils.TryMangleName("foo_") == null); + + // special method names: + Assert(RubyUtils.TryMangleMethodName("Initialize") == null); + Assert(RubyUtils.TryMangleMethodName("Class") == null); + Assert(RubyUtils.TryMangleMethodName("Message") == "message"); // we don't special case Exception.Message } } } =================================================================== edit: $/Dev10/feature/vs_langs01_s/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Initializers.Generated.cs;C1134885 File: Initializers.Generated.cs =================================================================== --- $/Dev10/feature/vs_langs01_s/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Initializers.Generated.cs;C1134885 (server) 9/21/2009 1:08 PM +++ Shelved Change: $/Dev10/feature/vs_langs01_s/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Initializers.Generated.cs;BugFixes @@ -2022,7 +2022,7 @@ module.DefineLibraryMethod("==", 0x51, new Func(IronRuby.Builtins.ClrBigInteger.Equal), new Func(IronRuby.Builtins.ClrBigInteger.Equal), - new Func(IronRuby.Builtins.ClrBigInteger.Equal), + new Func(IronRuby.Builtins.ClrBigInteger.Equal), new Func(IronRuby.Builtins.ClrBigInteger.Equal) ); @@ -2119,42 +2119,42 @@ private static void LoadIronRuby__Clr__Float_Instance(IronRuby.Builtins.RubyModule/*!*/ module) { module.DefineLibraryMethod("-", 0x51, new Func(IronRuby.Builtins.ClrFloat.Subtract), - new Func(IronRuby.Builtins.ClrFloat.Subtract), + new Func(IronRuby.Builtins.ClrFloat.Subtract), new Func(IronRuby.Builtins.ClrFloat.Subtract), new Func(IronRuby.Builtins.ClrFloat.Subtract) ); module.DefineLibraryMethod("%", 0x51, new Func(IronRuby.Builtins.ClrFloat.Modulo), - new Func(IronRuby.Builtins.ClrFloat.Modulo), + new Func(IronRuby.Builtins.ClrFloat.Modulo), new Func(IronRuby.Builtins.ClrFloat.Modulo), new Func(IronRuby.Builtins.ClrFloat.ModuloOp) ); module.DefineLibraryMethod("*", 0x51, new Func(IronRuby.Builtins.ClrFloat.Multiply), - new Func(IronRuby.Builtins.ClrFloat.Multiply), + new Func(IronRuby.Builtins.ClrFloat.Multiply), new Func(IronRuby.Builtins.ClrFloat.Multiply), new Func(IronRuby.Builtins.ClrFloat.Multiply) ); module.DefineLibraryMethod("**", 0x51, new Func(IronRuby.Builtins.ClrFloat.Power), - new Func(IronRuby.Builtins.ClrFloat.Power), + new Func(IronRuby.Builtins.ClrFloat.Power), new Func(IronRuby.Builtins.ClrFloat.Power), new Func(IronRuby.Builtins.ClrFloat.Power) ); module.DefineLibraryMethod("/", 0x51, new Func(IronRuby.Builtins.ClrFloat.Divide), - new Func(IronRuby.Builtins.ClrFloat.Divide), + new Func(IronRuby.Builtins.ClrFloat.Divide), new Func(IronRuby.Builtins.ClrFloat.Divide), new Func(IronRuby.Builtins.ClrFloat.Divide) ); module.DefineLibraryMethod("+", 0x51, new Func(IronRuby.Builtins.ClrFloat.Add), - new Func(IronRuby.Builtins.ClrFloat.Add), + new Func(IronRuby.Builtins.ClrFloat.Add), new Func(IronRuby.Builtins.ClrFloat.Add), new Func(IronRuby.Builtins.ClrFloat.Add) ); @@ -2162,21 +2162,21 @@ module.DefineLibraryMethod("<", 0x51, new Func(IronRuby.Builtins.ClrFloat.LessThan), new Func(IronRuby.Builtins.ClrFloat.LessThan), - new Func(IronRuby.Builtins.ClrFloat.LessThan), + new Func(IronRuby.Builtins.ClrFloat.LessThan), new Func(IronRuby.Builtins.ClrFloat.LessThan) ); module.DefineLibraryMethod("<=", 0x51, new Func(IronRuby.Builtins.ClrFloat.LessThanOrEqual), new Func(IronRuby.Builtins.ClrFloat.LessThanOrEqual), - new Func(IronRuby.Builtins.ClrFloat.LessThanOrEqual), + new Func(IronRuby.Builtins.ClrFloat.LessThanOrEqual), new Func(IronRuby.Builtins.ClrFloat.LessThanOrEqual) ); module.DefineLibraryMethod("<=>", 0x51, new Func(IronRuby.Builtins.ClrFloat.Compare), new Func(IronRuby.Builtins.ClrFloat.Compare), - new Func(IronRuby.Builtins.ClrFloat.Compare), + new Func(IronRuby.Builtins.ClrFloat.Compare), new Func(IronRuby.Builtins.ClrFloat.Compare) ); @@ -2188,14 +2188,14 @@ module.DefineLibraryMethod(">", 0x51, new Func(IronRuby.Builtins.ClrFloat.GreaterThan), new Func(IronRuby.Builtins.ClrFloat.GreaterThan), - new Func(IronRuby.Builtins.ClrFloat.GreaterThan), + new Func(IronRuby.Builtins.ClrFloat.GreaterThan), new Func(IronRuby.Builtins.ClrFloat.GreaterThan) ); module.DefineLibraryMethod(">=", 0x51, new Func(IronRuby.Builtins.ClrFloat.GreaterThanOrEqual), new Func(IronRuby.Builtins.ClrFloat.GreaterThanOrEqual), - new Func(IronRuby.Builtins.ClrFloat.GreaterThanOrEqual), + new Func(IronRuby.Builtins.ClrFloat.GreaterThanOrEqual), new Func(IronRuby.Builtins.ClrFloat.GreaterThanOrEqual) ); @@ -2213,7 +2213,7 @@ module.DefineLibraryMethod("divmod", 0x51, new Func(IronRuby.Builtins.ClrFloat.DivMod), - new Func(IronRuby.Builtins.ClrFloat.DivMod), + new Func(IronRuby.Builtins.ClrFloat.DivMod), new Func(IronRuby.Builtins.ClrFloat.DivMod), new Func(IronRuby.Builtins.ClrFloat.DivMod) ); @@ -2236,7 +2236,7 @@ module.DefineLibraryMethod("modulo", 0x51, new Func(IronRuby.Builtins.ClrFloat.Modulo), - new Func(IronRuby.Builtins.ClrFloat.Modulo), + new Func(IronRuby.Builtins.ClrFloat.Modulo), new Func(IronRuby.Builtins.ClrFloat.Modulo), new Func(IronRuby.Builtins.ClrFloat.Modulo) ); @@ -2766,7 +2766,7 @@ module.DefineLibraryMethod("fail", 0x52, new Action(IronRuby.Builtins.KernelOps.RaiseException), new Action(IronRuby.Builtins.KernelOps.RaiseException), - new Action>, System.Object, System.Object, System.Object, IronRuby.Builtins.RubyArray>(IronRuby.Builtins.KernelOps.RaiseException) + new Action>, System.Object, System.Object, System.Object, IronRuby.Builtins.RubyArray>(IronRuby.Builtins.KernelOps.RaiseException) ); module.DefineLibraryMethod("Float", 0x52, @@ -2955,7 +2955,7 @@ module.DefineLibraryMethod("raise", 0x52, new Action(IronRuby.Builtins.KernelOps.RaiseException), new Action(IronRuby.Builtins.KernelOps.RaiseException), - new Action>, System.Object, System.Object, System.Object, IronRuby.Builtins.RubyArray>(IronRuby.Builtins.KernelOps.RaiseException) + new Action>, System.Object, System.Object, System.Object, IronRuby.Builtins.RubyArray>(IronRuby.Builtins.KernelOps.RaiseException) ); module.DefineLibraryMethod("rand", 0x52, @@ -3159,7 +3159,7 @@ module.DefineLibraryMethod("fail", 0x61, new Action(IronRuby.Builtins.KernelOps.RaiseException), new Action(IronRuby.Builtins.KernelOps.RaiseException), - new Action>, System.Object, System.Object, System.Object, IronRuby.Builtins.RubyArray>(IronRuby.Builtins.KernelOps.RaiseException) + new Action>, System.Object, System.Object, System.Object, IronRuby.Builtins.RubyArray>(IronRuby.Builtins.KernelOps.RaiseException) ); module.DefineLibraryMethod("Float", 0x61, @@ -3257,7 +3257,7 @@ module.DefineLibraryMethod("raise", 0x61, new Action(IronRuby.Builtins.KernelOps.RaiseException), new Action(IronRuby.Builtins.KernelOps.RaiseException), - new Action>, System.Object, System.Object, System.Object, IronRuby.Builtins.RubyArray>(IronRuby.Builtins.KernelOps.RaiseException) + new Action>, System.Object, System.Object, System.Object, IronRuby.Builtins.RubyArray>(IronRuby.Builtins.KernelOps.RaiseException) ); module.DefineLibraryMethod("rand", 0x61, @@ -5804,7 +5804,7 @@ module.DefineLibraryMethod("raise", 0x51, new Action(IronRuby.Builtins.ThreadOps.RaiseException), new Action(IronRuby.Builtins.ThreadOps.RaiseException), - new Action>, System.Threading.Thread, System.Object, System.Object, IronRuby.Builtins.RubyArray>(IronRuby.Builtins.ThreadOps.RaiseException) + new Action>, System.Threading.Thread, System.Object, System.Object, IronRuby.Builtins.RubyArray>(IronRuby.Builtins.ThreadOps.RaiseException) ); #if !SILVERLIGHT =================================================================== edit: $/Dev10/feature/vs_langs01_s/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/ModuleOps.cs;C1116095 File: ModuleOps.cs =================================================================== --- $/Dev10/feature/vs_langs01_s/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/ModuleOps.cs;C1116095 (server) 9/21/2009 1:08 PM +++ Shelved Change: $/Dev10/feature/vs_langs01_s/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/ModuleOps.cs;BugFixes @@ -891,13 +891,13 @@ var symbolicNames = self.Context.RubyOptions.Compatibility > RubyCompatibility.Ruby18; using (self.Context.ClassHierarchyLocker()) { - self.ForEachMember(inherited, attributes, foreignMembers, (name, module, member) => - result.Add( - member.IsInteropMember && (module.Restrictions & ModuleRestrictions.NoNameMangling) == 0 ? - new ClrName(name) : - CreateMethodName(name, symbolicNames) - ) - ); + self.ForEachMember(inherited, attributes, foreignMembers, (name, module, member) => { + if (member.IsInteropMember && (module.Restrictions & ModuleRestrictions.NoNameMangling) == 0 && RubyUtils.HasMangledName(name)) { + result.Add(new ClrName(name)); + } else { + result.Add(CreateMethodName(name, symbolicNames)); + } + }); } return result; } =================================================================== edit: $/Dev10/feature/vs_langs01_s/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Extensions/ClrBigInteger.cs;C1090806 File: ClrBigInteger.cs =================================================================== --- $/Dev10/feature/vs_langs01_s/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Extensions/ClrBigInteger.cs;C1090806 (server) 9/21/2009 1:08 PM +++ Shelved Change: $/Dev10/feature/vs_langs01_s/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Extensions/ClrBigInteger.cs;BugFixes @@ -621,9 +621,8 @@ /// true or false /// Returns false if other is NaN. [RubyMethod("==")] - public static bool Equal(BigInteger/*!*/ self, double other) { - if (Double.IsNaN(other)) return false; - return (double)self == other; + public static bool Equal(RubyContext/*!*/ context, BigInteger/*!*/ self, double other) { + return !Double.IsNaN(other) && Protocols.ConvertToDouble(context, self) == other; } /// @@ -902,13 +901,7 @@ /// self as a Float [RubyMethod("to_f")] public static double ToFloat(RubyContext/*!*/ context, BigInteger/*!*/ self) { - try { - return self.ToFloat64(); - } catch (OverflowException) { - // If the BigInteger is too big for a float then we return infinity. - context.ReportWarning("Bignum out of Float range"); - return self.Sign > 0 ? Double.PositiveInfinity : Double.NegativeInfinity; - } + return Protocols.ConvertToDouble(context, self); } #endregion =================================================================== edit: $/Dev10/feature/vs_langs01_s/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Extensions/ClrFloat.cs;C1042261 File: ClrFloat.cs =================================================================== --- $/Dev10/feature/vs_langs01_s/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Extensions/ClrFloat.cs;C1042261 (server) 9/21/2009 1:08 PM +++ Shelved Change: $/Dev10/feature/vs_langs01_s/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Extensions/ClrFloat.cs;BugFixes @@ -86,8 +86,8 @@ /// /// Float [RubyMethod("*")] - public static double Multiply(double self, [NotNull]BigInteger/*!*/ other) { - return self * (double)other; + public static double Multiply(RubyContext/*!*/ context, double self, [NotNull]BigInteger/*!*/ other) { + return self * Protocols.ConvertToDouble(context, other); } /// @@ -126,8 +126,8 @@ /// /// Float [RubyMethod("+")] - public static double Add(double self, [NotNull]BigInteger/*!*/ other) { - return self + (double)other; + public static double Add(RubyContext/*!*/ context, double self, [NotNull]BigInteger/*!*/ other) { + return self + Protocols.ConvertToDouble(context, other); } /// @@ -166,8 +166,8 @@ /// /// Float [RubyMethod("-")] - public static double Subtract(double self, [NotNull]BigInteger/*!*/ other) { - return self - (double)other; + public static double Subtract(RubyContext/*!*/ context, double self, [NotNull]BigInteger/*!*/ other) { + return self - Protocols.ConvertToDouble(context, other); } /// @@ -206,8 +206,8 @@ /// /// Float [RubyMethod("/")] - public static double Divide(double self, [NotNull]BigInteger/*!*/ other) { - return self / (double)other; + public static double Divide(RubyContext/*!*/ context, double self, [NotNull]BigInteger/*!*/ other) { + return self / Protocols.ConvertToDouble(context, other); } /// @@ -246,8 +246,8 @@ /// /// Float [RubyMethod("%"), RubyMethod("modulo")] - public static double Modulo(double self, [NotNull]BigInteger/*!*/ other) { - return (double)InternalDivMod(self, (double)other)[1]; + public static double Modulo(RubyContext/*!*/ context, double self, [NotNull]BigInteger/*!*/ other) { + return (double)InternalDivMod(self, Protocols.ConvertToDouble(context, other))[1]; } /// @@ -293,8 +293,8 @@ /// Raises self the other power, where other is Bignum. /// [RubyMethod("**")] - public static double Power(double self, [NotNull]BigInteger/*!*/ other) { - return Math.Pow(self, (double)other); + public static double Power(RubyContext/*!*/ context, double self, [NotNull]BigInteger/*!*/ other) { + return Math.Pow(self, Protocols.ConvertToDouble(context, other)); } /// @@ -347,8 +347,8 @@ /// The quotient is rounded toward -infinity /// [RubyMethod("divmod")] - public static RubyArray DivMod(double self, [NotNull]BigInteger/*!*/ other) { - return DivMod(self, (double)other); + public static RubyArray DivMod(RubyContext/*!*/ context, double self, [NotNull]BigInteger/*!*/ other) { + return DivMod(self, Protocols.ConvertToDouble(context, other)); } /// @@ -642,11 +642,11 @@ /// This is the basis for the tests in Comparable. /// [RubyMethod("<=>")] - public static object Compare(double self, [NotNull]BigInteger/*!*/ other) { + public static object Compare(RubyContext/*!*/ context, double self, [NotNull]BigInteger/*!*/ other) { if (Double.IsNaN(self)) { return null; } - return self.CompareTo((double)other); + return self.CompareTo(Protocols.ConvertToDouble(context, other)); } /// @@ -693,8 +693,8 @@ /// Returns true if self is less than other, where other is Bignum. /// [RubyMethod("<")] - public static bool LessThan(double self, [NotNull]BigInteger/*!*/ other) { - return LessThan(self, (double)other); + public static bool LessThan(RubyContext/*!*/ context, double self, [NotNull]BigInteger/*!*/ other) { + return LessThan(self, Protocols.ConvertToDouble(context, other)); } /// @@ -732,8 +732,8 @@ /// Returns true if self is less than or equal to other, where other is Bignum. /// [RubyMethod("<=")] - public static bool LessThanOrEqual(double self, [NotNull]BigInteger/*!*/ other) { - return LessThanOrEqual(self, (double)other); + public static bool LessThanOrEqual(RubyContext/*!*/ context, double self, [NotNull]BigInteger/*!*/ other) { + return LessThanOrEqual(self, Protocols.ConvertToDouble(context, other)); } /// @@ -771,8 +771,8 @@ /// Returns true if self is greater than other, where other is Bignum. /// [RubyMethod(">")] - public static bool GreaterThan(double self, [NotNull]BigInteger/*!*/ other) { - return GreaterThan(self, (double)other); + public static bool GreaterThan(RubyContext/*!*/ context, double self, [NotNull]BigInteger/*!*/ other) { + return GreaterThan(self, Protocols.ConvertToDouble(context, other)); } /// @@ -810,8 +810,8 @@ /// Returns true if self is greater than or equal to other, where other is Bignum. /// [RubyMethod(">=")] - public static bool GreaterThanOrEqual(double self, [NotNull]BigInteger/*!*/ other) { - return GreaterThanOrEqual(self, (double)other); + public static bool GreaterThanOrEqual(RubyContext/*!*/ context, double self, [NotNull]BigInteger/*!*/ other) { + return GreaterThanOrEqual(self, Protocols.ConvertToDouble(context, other)); } /// =================================================================== edit: $/Dev10/feature/vs_langs01_s/Merlin/Main/Languages/Ruby/Ruby/Builtins/RubyModule.cs;C1116095 File: RubyModule.cs =================================================================== --- $/Dev10/feature/vs_langs01_s/Merlin/Main/Languages/Ruby/Ruby/Builtins/RubyModule.cs;C1116095 (server) 9/21/2009 1:08 PM +++ Shelved Change: $/Dev10/feature/vs_langs01_s/Merlin/Main/Languages/Ruby/Ruby/Builtins/RubyModule.cs;BugFixes @@ -1674,7 +1674,6 @@ internal bool TryGetMethod(string/*!*/ name, ref bool skipHidden, bool virtualLookup, out RubyMemberInfo method) { Context.RequiresClassHierarchyLock(); - Assert.NotNull(name); Debug.Assert(_methods != null); // lookup Ruby method first: @@ -1684,7 +1683,8 @@ if (virtualLookup) { string mangled; - if ((mangled = RubyUtils.TryMangleName(name)) != null && TryGetDefinedMethod(mangled, ref skipHidden, out method) + // TODO: set/get_FooBar?? + if ((mangled = RubyUtils.TryMangleMethodName(name)) != null && TryGetDefinedMethod(mangled, ref skipHidden, out method) && method.IsRubyMember) { return true; } =================================================================== edit: $/Dev10/feature/vs_langs01_s/Merlin/Main/Languages/Ruby/Ruby/Runtime/Protocols.cs;C1120203 File: Protocols.cs =================================================================== --- $/Dev10/feature/vs_langs01_s/Merlin/Main/Languages/Ruby/Ruby/Runtime/Protocols.cs;C1120203 (server) 9/21/2009 1:08 PM +++ Shelved Change: $/Dev10/feature/vs_langs01_s/Merlin/Main/Languages/Ruby/Ruby/Runtime/Protocols.cs;BugFixes @@ -92,6 +92,15 @@ return x; } + public static double ConvertToDouble(RubyContext/*!*/ context, BigInteger/*!*/ bignum) { + double result; + if (bignum.TryToFloat64(out result)) { + return result; + } + context.ReportWarning("Bignum out of Float range"); + return bignum.Sign > 0 ? Double.PositiveInfinity : Double.NegativeInfinity; + } + #endregion #region CastToString, TryCastToString, ConvertToString =================================================================== edit: $/Dev10/feature/vs_langs01_s/Merlin/Main/Languages/Ruby/Ruby/Runtime/RubyOps.cs;C1134885 File: RubyOps.cs =================================================================== --- $/Dev10/feature/vs_langs01_s/Merlin/Main/Languages/Ruby/Ruby/Runtime/RubyOps.cs;C1134885 (server) 9/21/2009 1:08 PM +++ Shelved Change: $/Dev10/feature/vs_langs01_s/Merlin/Main/Languages/Ruby/Ruby/Runtime/RubyOps.cs;BugFixes @@ -1010,10 +1010,10 @@ ScopeStorage scopeStorage = ((object)scope.Storage) as ScopeStorage; if (scopeStorage != null) { return scopeStorage.TryGetValue(name, false, out value) - || (unmangled = RubyUtils.TryUnmangleName(name)) != null && scopeStorage.TryGetValue(unmangled, false, out value); + || (unmangled = RubyUtils.TryUnmangleMethodName(name)) != null && scopeStorage.TryGetValue(unmangled, false, out value); } else { return context.Operations.TryGetMember(scope, name, out value) - || (unmangled = RubyUtils.TryUnmangleName(name)) != null && context.Operations.TryGetMember(scope, unmangled, out value); + || (unmangled = RubyUtils.TryUnmangleMethodName(name)) != null && context.Operations.TryGetMember(scope, unmangled, out value); } } =================================================================== edit: $/Dev10/feature/vs_langs01_s/Merlin/Main/Languages/Ruby/Ruby/Runtime/RubyUtils.cs;C1116095 File: RubyUtils.cs =================================================================== --- $/Dev10/feature/vs_langs01_s/Merlin/Main/Languages/Ruby/Ruby/Runtime/RubyUtils.cs;C1116095 (server) 9/21/2009 1:08 PM +++ Shelved Change: $/Dev10/feature/vs_langs01_s/Merlin/Main/Languages/Ruby/Ruby/Runtime/RubyUtils.cs;BugFixes @@ -196,6 +196,14 @@ #region Names + public static bool HasUnmangledName(string/*!*/ name) { + return !NotUnmangledObject.Contains(name); + } + + public static string TryUnmangleMethodName(string/*!*/ name) { + return HasUnmangledName(name) ? TryUnmangleName(name) : null; + } + /// /// Converts a Ruby name to PascalCase name (foo_bar -> FooBar). /// Returns null if the name is not a well-formed Ruby name (it contains upper-case latter or subsequent underscores). @@ -203,7 +211,7 @@ /// public static string TryUnmangleName(string/*!*/ name) { ContractUtils.RequiresNotNull(name, "name"); - if (name.Length == 0 || name == "initialize") { + if (name.Length == 0) { return null; } @@ -253,6 +261,14 @@ return mangled.ToString(); } + public static bool HasMangledName(string/*!*/ name) { + return !NotMangledObject.Contains(name); + } + + public static string TryMangleMethodName(string/*!*/ name) { + return HasMangledName(name) ? TryMangleName(name) : null; + } + /// /// Converts a camelCase or PascalCase name to a Ruby name (FooBar -> foo_bar). /// Returns null if the name is not in camelCase or PascalCase (FooBAR, foo, etc.). @@ -260,9 +276,6 @@ /// public static string TryMangleName(string/*!*/ name) { ContractUtils.RequiresNotNull(name, "name"); - if (name == "Initialize") { - return null; - } StringBuilder mangled = null; int i = 0; @@ -363,6 +376,69 @@ return (str[index + 1] & 0xff00) == 0 ? (str[index].ToLowerInvariant() << 8) | str[index + 1].ToLowerInvariant() : -1; } + /// + /// A list of Kernel/Object methods that are expected by common Ruby libraries to work on all objects. + /// We don't unmangled them to allow Ruby programs work with .NET objects that define e.g. Class property. + /// + internal static readonly HashSet NotUnmangledObject = new HashSet() { + // Kernel + "class", + "clone", + "display", + "dup", + "extend", + "freeze", + "hash", + // "id", Kernel#id is deprecated + "initialize", + "inspect", + "instance_eval", + "instance_exec", + "instance_variable_get", + "instance_variable_set", + "instance_variables", + "method", + "methods", + "object_id", + "private_methods", + "protected_methods", + "public_methods", + "send", + "singleton_methods", + "taint", + // "type", Kernel#type is deprecated + "untaint", + }; + + internal static readonly HashSet NotMangledObject = new HashSet() { + "Class", + "Clone", + "Display", + "Dup", + "Extend", + "Freeze", + "Hash", + // "Id", Kernel#id is deprecated + "Initialize", + "Inspect", + "InstanceEval", + "InstanceExec", + "InstanceVariableGet", + "InstanceVariableSet", + "InstanceVariables", + "Method", + "Methods", + "ObjectId", + "PrivateMethods", + "ProtectedMethods", + "PublicMethods", + "Send", + "SingletonMethods", + "Taint", + // "Type", Kernel#type is deprecated + "Untaint", + }; + #endregion #region Constants ===================================================================