@@ -358,7 +358,7 @@ namespace IronRuby.StandardLibrary.Yaml { ); module.DefineLibraryMethod("add", 0x11, - new System.Func<IronRuby.Runtime.RubyContext, IronRuby.StandardLibrary.Yaml.RubyYaml.YamlStream, System.Object, IronRuby.Builtins.RubyArray>(IronRuby.StandardLibrary.Yaml.RubyYaml.YamlStream.Add) + new System.Func<IronRuby.StandardLibrary.Yaml.RubyYaml.YamlStream, System.Object, IronRuby.Builtins.RubyArray>(IronRuby.StandardLibrary.Yaml.RubyYaml.YamlStream.Add) ); module.DefineLibraryMethod("documents", 0x11, @@ -370,7 +370,7 @@ namespace IronRuby.StandardLibrary.Yaml { ); module.DefineLibraryMethod("edit", 0x11, - new System.Func<IronRuby.Runtime.RubyContext, IronRuby.StandardLibrary.Yaml.RubyYaml.YamlStream, System.Int32, System.Object, System.Object>(IronRuby.StandardLibrary.Yaml.RubyYaml.YamlStream.EditDocument) + new System.Func<IronRuby.StandardLibrary.Yaml.RubyYaml.YamlStream, System.Int32, System.Object, System.Object>(IronRuby.StandardLibrary.Yaml.RubyYaml.YamlStream.EditDocument) ); module.DefineLibraryMethod("emit", 0x11, Merlin/External.LCA_RESTRICTED/Languages/IronRuby/Yaml/IronRuby.Libraries.Yaml/Initializer.Generated.cs @@ -60,8 +60,8 @@ namespace IronRuby.StandardLibrary.Yaml { } [RubyMethod("add")] - public static RubyArray Add(RubyContext/*!*/ context, YamlStream/*!*/ self, object document) { - IListOps.Append(context, self._documents, document); + public static RubyArray Add(YamlStream/*!*/ self, object document) { + IListOps.Append(self._documents, document); return self._documents; } @@ -71,8 +71,8 @@ namespace IronRuby.StandardLibrary.Yaml { } [RubyMethod("edit")] - public static object EditDocument(RubyContext/*!*/ context, YamlStream/*!*/ self, [DefaultProtocol]int index, object document) { - return IListOps.SetElement(context, self._documents, index, document); + public static object EditDocument(YamlStream/*!*/ self, [DefaultProtocol]int index, object document) { + return IListOps.SetElement(self._documents, index, document); } [RubyMethod("documents")] Merlin/External.LCA_RESTRICTED/Languages/IronRuby/Yaml/IronRuby.Libraries.Yaml/YamlStream.cs @@ -1,3 +1,6 @@ +orig_dir = Dir.pwd +at_exit { Dir.chdir(orig_dir)} +Dir.chdir(File.dirname(__FILE__)) require 'test/unit' require 'load_tests' require 'load_file_tests' @@ -6,4 +9,31 @@ require 'load_stream_tests' require 'collections_tests' require 'dump_tests' require 'tags_tests' + +class Load_tests < Test::Unit::TestCase + def test_to_yaml + end +end require 'test_yaml' + +class YAML_Unit_Tests < Test::Unit::TestCase + def test_spec_builtin_time + end + + def test_spec_private_types + end + + def test_spec_url_escaping + end + + def test_symbol_cycle + end + + def test_time_now_cycle + end + + def test_ypath_parsing + end +end + + Merlin/External.LCA_RESTRICTED/Languages/IronRuby/Yaml/YamlTest/yaml_test_suite.rb @@ -77,4 +77,10 @@ describe "Array#-" do a - [:a, :b, :c] a.should == [1, 2, 3] end + + it "handles nil correctly" do + a = [nil, 1, nil] + (a - [nil]).should == [1] + (a - [1]).should == [nil, nil] + end end Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/rubyspec/core/array/minus_spec.rb @@ -4,6 +4,9 @@ describe :kernel_object_id, :shared => true do it "returns an integer" do mock('fixnum').send(@method).class.should == Fixnum nil.send(@method).class.should == Fixnum + + # this can return Finxum or Bignum depending on the platform + 900_000_000.send(@method).kind_of?(Integer).should be_true end it "returns the same value on all calls to id for a given object" do Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/rubyspec/core/kernel/shared/object_id.rb @@ -93,7 +93,7 @@ module REXML # Creates (and returns) a hash from both the name and value def hash - name.hash + value.hash + name.hash ^ value.hash end # Returns this attribute out as XML source, expanding the name Merlin/External.LCA_RESTRICTED/Languages/Ruby/redist-libs/ruby/1.8/rexml/attribute.rb @@ -112,7 +112,7 @@ class Gem::Dependency end def hash # :nodoc: - name.hash + type.hash + version_requirements.hash + name.hash ^ type.hash ^ version_requirements.hash end end Merlin/External.LCA_RESTRICTED/Languages/Ruby/redist-libs/ruby/site_ruby/1.8/rubygems/dependency.rb @@ -661,9 +661,8 @@ module Gem private :same_attributes? def hash # :nodoc: - @@attributes.inject(0) { |hash_code, (name, default_value)| - n = self.send(name).hash - hash_code + n + @@attributes.inject(612553) { |hash_code, (name, default_value)| + hash_code ^ self.send(name).hash } end Merlin/External.LCA_RESTRICTED/Languages/Ruby/redist-libs/ruby/site_ruby/1.8/rubygems/specification.rb @@ -479,7 +479,7 @@ namespace IronRuby.Builtins { BlockParam block, RubyArray/*!*/ self) { RubyArray result = self.CreateInstance(); - IListOps.Replace(comparisonStorage.Context, result, self); + IListOps.Replace(result, self); return SortInPlace(comparisonStorage, lessThanStorage, greaterThanStorage, block, result); } Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/ArrayOps.cs @@ -26,6 +26,7 @@ using IronRuby.Runtime.Calls; using Microsoft.Scripting.Math; using Microsoft.Scripting.Runtime; using Ast = System.Linq.Expressions.Expression; +using System.Collections; namespace IronRuby.Builtins { @@ -617,10 +618,10 @@ namespace IronRuby.Builtins { public static MutableString/*!*/ ToPrintedString(ConversionStorage<MutableString>/*!*/ tosConversion, object obj) { IDictionary<object, object> hash; - List<object> list; + IList list; MutableString str; - if ((list = obj as List<object>) != null) { + if ((list = obj as IList) != null) { return IListOps.Join(tosConversion, list, NewLine); } else if ((hash = obj as IDictionary<object, object>) != null) { return IDictionaryOps.ToMutableString(tosConversion, hash); Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/IoOps.cs @@ -1049,15 +1049,15 @@ namespace IronRuby.Builtins { #region __id__, id, object_id, class [RubyMethod("id")] - public static int GetId(RubyContext/*!*/ context, object self) { + public static object GetId(RubyContext/*!*/ context, object self) { context.ReportWarning("Object#id will be deprecated; use Object#object_id"); return GetObjectId(context, self); } [RubyMethod("__id__")] [RubyMethod("object_id")] - public static int GetObjectId(RubyContext/*!*/ context, object self) { - return RubyUtils.GetObjectId(context, self); + public static object GetObjectId(RubyContext/*!*/ context, object self) { + return ClrInteger.Narrow(RubyUtils.GetObjectId(context, self)); } [RubyMethod("type")] Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/KernelOps.cs @@ -76,7 +76,8 @@ namespace IronRuby.Builtins { #endregion - #region begin, first + #region begin, first, end, last, exclude_end? + /// <summary> /// Returns the first object in self /// </summary> @@ -84,9 +85,7 @@ namespace IronRuby.Builtins { public static object Begin([NotNull]Range/*!*/ self) { return self.Begin; } - #endregion - #region end, last /// <summary> /// Returns the object that defines the end of self /// </summary> @@ -94,9 +93,7 @@ namespace IronRuby.Builtins { public static object End([NotNull]Range/*!*/ self) { return self.End; } - #endregion - #region exclude_end? /// <summary> /// Returns true if self excludes its end value. /// </summary> @@ -104,6 +101,7 @@ namespace IronRuby.Builtins { public static bool ExcludeEnd([NotNull]Range/*!*/ self) { return self.ExcludeEnd; } + #endregion #region inspect, to_s @@ -168,7 +166,6 @@ namespace IronRuby.Builtins { /// </example> [RubyMethod("eql?")] public static bool Eql(BinaryOpStorage/*!*/ equalsStorage, Range/*!*/ self, [NotNull]Range/*!*/ other) { - if (self == other) { return true; } @@ -221,17 +218,23 @@ namespace IronRuby.Builtins { #endregion #region hash + /// <summary> /// Generate a hash value such that two ranges with the same start and end points, /// and the same value for the "exclude end" flag, generate the same hash value. /// </summary> [RubyMethod("hash")] - public static int GetHashCode(Range/*!*/ self) { - int hash = RubyUtils.GetHashCode(self.Begin); - hash ^= RubyUtils.GetHashCode(self.End); - hash ^= RubyUtils.GetHashCode(self.ExcludeEnd); - return hash; + public static int GetHashCode(UnaryOpStorage/*!*/ hashStorage, Range/*!*/ self) { + // MRI: Ruby treatment of hash return value is inconsistent. + // No conversions happen here (unlike e.g. Array.hash). + var hashSite = hashStorage.GetCallSite("hash"); + return unchecked( + Protocols.ToHashCode(hashSite.Target(hashSite, self.Begin)) ^ + Protocols.ToHashCode(hashSite.Target(hashSite, self.End)) ^ + (self.ExcludeEnd ? 179425693 : 1794210891) + ); } + #endregion #region each @@ -252,7 +255,7 @@ namespace IronRuby.Builtins { UnaryOpStorage/*!*/ succStorage, BlockParam block, Range/*!*/ self) { - // We check that self.begin responds to "succ" even though some of the implementations don't use it. + // MRI: Checks that self.begin responds to "succ" even though it might not be used. CheckBegin(respondToStorage, self.Begin); if (self.Begin is int && self.End is int) { @@ -301,7 +304,7 @@ namespace IronRuby.Builtins { // self.begin is Fixnum; directly call item = item + 1 instead of succ int intStep = Protocols.CastToFixnum(fixnumCast, step); return StepFixnum(block, self, (int)self.Begin, (int)self.End, intStep); - } else if (self.Begin is MutableString ) { + } else if (self.Begin is MutableString) { // self.begin is String; use item.succ and item <=> self.end but make sure you check the length of the strings int intStep = Protocols.CastToFixnum(fixnumCast, step); return StepString(stringCast, comparisonStorage, lessThanStorage, greaterThanStorage, succStorage, Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/RangeOps.cs @@ -200,13 +200,13 @@ namespace IronRuby.Builtins { } [RubyMethod("hash")] - public static int Hash(RubyStruct/*!*/ self) { - return self.GetHashCode(); + public static int Hash(UnaryOpStorage/*!*/ hashStorage, ConversionStorage<int>/*!*/ fixnumCast, RubyStruct/*!*/ self) { + return self.GetHashCode(hashStorage, fixnumCast); } [RubyMethod("eql?")] - public static bool Equal(RubyStruct/*!*/ self, object other) { - return self.Equals(other); + public static bool Equal(BinaryOpStorage/*!*/ eqlStorage, RubyStruct/*!*/ self, object other) { + return self.Equals(eqlStorage, other); } // same pattern as RubyStruct.Equals, but we need to call == instead of eql? Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/StructOps.cs @@ -35,6 +35,14 @@ namespace IronRuby.Builtins { #region Helpers + // MRI: Some operations check frozen flag even if they don't change the array content. + private static void RequireNotFrozen(IList/*!*/ self) { + RubyArray array = self as RubyArray; + if (array != null && array.IsFrozen) { + throw RubyExceptions.CreateTypeError("can't modify frozen object"); + } + } + internal static int NormalizeIndex(IList/*!*/ list, int index) { return NormalizeIndex(list.Count, index); } @@ -99,8 +107,11 @@ namespace IronRuby.Builtins { } private static void InsertRange(IList/*!*/ collection, int index, IEnumerable<object>/*!*/ items) { - List<object> list = collection as List<object>; - if (list != null) { + List<object> list; + RubyArray array; + if ((array = collection as RubyArray) != null) { + array.InsertRange(index, items); + } else if ((list = collection as List<object>) != null) { list.InsertRange(index, items); } else { int i = index; @@ -110,9 +121,19 @@ namespace IronRuby.Builtins { } } - private static void RemoveRange(IList/*!*/ collection, int index, int count) { - List<object> list = collection as List<object>; - if (list != null) { + internal static void RemoveRange(IList/*!*/ collection, int index, int count) { + if (count <= 1) { + if (count > 0) { + collection.RemoveAt(index); + } + return; + } + + List<object> list; + RubyArray array; + if ((array = collection as RubyArray) != null) { + array.RemoveRange(index, count); + } else if ((list = collection as List<object>) != null) { list.RemoveRange(index, count); } else { for (int i = index + count - 1; i >= index; i--) { @@ -122,14 +143,21 @@ namespace IronRuby.Builtins { } internal static void AddRange(IList/*!*/ collection, IList/*!*/ items) { - List<object> list = collection as List<object>; - if (list != null) { - list.Capacity += items.Count; - } - // note: "collection" could be the same as "items" so we can't use an enumerator int count = items.Count; - for (int i = 0; i < count; i++) { - collection.Add(items[i]); + if (count <= 1) { + if (count > 0) { + collection.Add(items[0]); + } + return; + } + + RubyArray array = collection as RubyArray; + if (array != null) { + array.AddRange(items); + } else { + for (int i = 0; i < count; i++) { + collection.Add(items[i]); + } } } @@ -157,17 +185,14 @@ namespace IronRuby.Builtins { [RubyMethod("replace")] [RubyMethod("initialize_copy", RubyMethodAttributes.PrivateInstance)] - public static IList/*!*/ Replace(RubyContext/*!*/ context, IList/*!*/ self, [NotNull, DefaultProtocol]IList/*!*/ other) { - RubyUtils.RequiresNotFrozen(context, self); - + public static IList/*!*/ Replace(IList/*!*/ self, [NotNull, DefaultProtocol]IList/*!*/ other) { self.Clear(); AddRange(self, other); return self; } [RubyMethod("clear")] - public static IList Clear(RubyContext/*!*/ context, IList/*!*/ self) { - RubyUtils.RequiresNotFrozen(context, self); + public static IList Clear(IList/*!*/ self) { self.Clear(); return self; } @@ -228,28 +253,30 @@ namespace IronRuby.Builtins { } [RubyMethod("concat")] - public static IList/*!*/ Concat(RubyContext/*!*/ context, IList/*!*/ self, [DefaultProtocol, NotNull]IList/*!*/ other) { - if (other.Count > 0) { - RubyUtils.RequiresNotFrozen(context, self); - } + public static IList/*!*/ Concat(IList/*!*/ self, [DefaultProtocol, NotNull]IList/*!*/ other) { AddRange(self, other); return self; } [RubyMethod("-")] public static RubyArray/*!*/ Difference(UnaryOpStorage/*!*/ hashStorage, BinaryOpStorage/*!*/ eqlStorage, - RubyContext/*!*/ context, IList/*!*/ self, [DefaultProtocol, NotNull]IList/*!*/ other) { + IList/*!*/ self, [DefaultProtocol, NotNull]IList/*!*/ other) { RubyArray result = new RubyArray(); // cost: (|self| + |other|) * (hash + eql) + dict var remove = new Dictionary<object, bool>(new EqualityComparer(hashStorage, eqlStorage)); + bool removeNull = false; foreach (var item in other) { - remove[item] = true; + if (item != null) { + remove[item] = true; + } else { + removeNull = true; + } } foreach (var item in self) { - if (!remove.ContainsKey(item)) { + if (!(item != null ? remove.ContainsKey(item) : removeNull)) { result.Add(item); } } @@ -408,14 +435,17 @@ namespace IronRuby.Builtins { if (index + length > list.Count) { length = list.Count - index; } - RemoveRange(list, index, length); + + if (length == 0) { + RequireNotFrozen(list); + } else { + RemoveRange(list, index, length); + } } } [RubyMethod("[]=")] - public static object SetElement(RubyContext/*!*/ context, IList/*!*/ self, [DefaultProtocol]int index, object value) { - RubyUtils.RequiresNotFrozen(context, self); - + public static object SetElement(IList/*!*/ self, [DefaultProtocol]int index, object value) { index = NormalizeIndex(self, index); if (index < 0) { @@ -435,8 +465,6 @@ namespace IronRuby.Builtins { [RubyMethod("[]=")] public static object SetElement(ConversionStorage<IList>/*!*/ arrayTryCast, IList/*!*/ self, [DefaultProtocol]int index, [DefaultProtocol]int length, object value) { - RubyUtils.RequiresNotFrozen(arrayTryCast.Context, self); - if (length < 0) { throw RubyExceptions.CreateIndexError(String.Format("negative length ({0})", length)); } @@ -446,16 +474,21 @@ namespace IronRuby.Builtins { throw RubyExceptions.CreateIndexError(String.Format("index {0} out of array", index)); } + if (value == null) { + DeleteItems(self, index, length); + return null; + } + IList valueAsList = value as IList; if (valueAsList == null) { valueAsList = Protocols.TryCastToArray(arrayTryCast, value); } - if (value == null || (valueAsList != null && valueAsList.Count == 0)) { + if (valueAsList != null && valueAsList.Count == 0) { DeleteItems(self, index, length); } else { if (valueAsList == null) { - Insert(arrayTryCast.Context, self, index, value); + Insert(self, index, value); if (length > 0) { RemoveRange(self, index + 1, Math.Min(length, self.Count - index - 1)); @@ -489,8 +522,7 @@ namespace IronRuby.Builtins { [RubyMethod("[]=")] public static object SetElement(ConversionStorage<IList>/*!*/ arrayTryCast, ConversionStorage<int>/*!*/ fixnumCast, IList/*!*/ self, [NotNull]Range/*!*/ range, object value) { - RubyUtils.RequiresNotFrozen(fixnumCast.Context, self); - + int begin = Protocols.CastToFixnum(fixnumCast, range.Begin); int end = Protocols.CastToFixnum(fixnumCast, range.End); @@ -510,8 +542,9 @@ namespace IronRuby.Builtins { #region &, | [RubyMethod("&")] - public static RubyArray/*!*/ Intersection(RubyContext/*!*/ context, IList/*!*/ self, [DefaultProtocol]IList/*!*/ other) { - Dictionary<object, bool> items = new Dictionary<object, bool>(context.EqualityComparer); + public static RubyArray/*!*/ Intersection(UnaryOpStorage/*!*/ hashStorage, BinaryOpStorage/*!*/ eqlStorage, + IList/*!*/ self, [DefaultProtocol]IList/*!*/ other) { + Dictionary<object, bool> items = new Dictionary<object, bool>(new EqualityComparer(hashStorage, eqlStorage)); RubyArray result = new RubyArray(); // first get the items in the RHS @@ -551,8 +584,9 @@ namespace IronRuby.Builtins { } [RubyMethod("|")] - public static RubyArray/*!*/ Union(RubyContext/*!*/ context, IList/*!*/ self, [DefaultProtocol]IList other) { - var seen = new Dictionary<object, bool>(context.EqualityComparer); + public static RubyArray/*!*/ Union(UnaryOpStorage/*!*/ hashStorage, BinaryOpStorage/*!*/ eqlStorage, + IList/*!*/ self, [DefaultProtocol]IList other) { + var seen = new Dictionary<object, bool>(new EqualityComparer(hashStorage, eqlStorage)); bool nilSeen = false; var result = new RubyArray(); @@ -596,15 +630,13 @@ namespace IronRuby.Builtins { [RubyMethod("collect!")] [RubyMethod("map!")] - public static object CollectInPlace(RubyContext/*!*/ context, BlockParam block, IList/*!*/ self) { - Assert.NotNull(context, self); + public static object CollectInPlace(BlockParam block, IList/*!*/ self) { + Assert.NotNull(self); if (self.Count > 0 && block == null) { throw RubyExceptions.NoBlockGiven(); } - RubyUtils.RequiresNotFrozen(context, self); - int i = 0; while (i < self.Count) { object result; @@ -634,8 +666,8 @@ namespace IronRuby.Builtins { } [RubyMethod("compact!")] - public static IList CompactInPlace(RubyContext/*!*/ context, IList/*!*/ self) { - RubyUtils.RequiresNotFrozen(context, self); + public static IList CompactInPlace(IList/*!*/ self) { + RequireNotFrozen(self); bool changed = false; int i = 0; @@ -659,11 +691,10 @@ namespace IronRuby.Builtins { bool removed = false; while (i < self.Count) { if (Protocols.IsEqual(equals, self[i], item)) { - RubyUtils.RequiresNotFrozen(equals.Context, self); self.RemoveAt(i); removed = true; } else { - ++i; + i++; } } return removed; @@ -687,9 +718,7 @@ namespace IronRuby.Builtins { } [RubyMethod("delete_at")] - public static object DeleteAt(RubyContext/*!*/ context, IList/*!*/ self, [DefaultProtocol]int index) { - RubyUtils.RequiresNotFrozen(context, self); - + public static object DeleteAt(IList/*!*/ self, [DefaultProtocol]int index) { index = index < 0 ? index + self.Count : index; if (index < 0 || index > self.Count) { return null; @@ -701,22 +730,30 @@ namespace IronRuby.Builtins { } [RubyMethod("delete_if")] - public static object DeleteIf(RubyContext/*!*/ context, BlockParam block, IList/*!*/ self) { + public static object DeleteIf(BlockParam block, IList/*!*/ self) { bool changed, jumped; - DeleteIf(context, block, self, out changed, out jumped); + DeleteIf(block, self, out changed, out jumped); return self; } - private static object DeleteIf(RubyContext/*!*/ context, BlockParam block, IList/*!*/ self, out bool changed, out bool jumped) { - RubyUtils.RequiresNotFrozen(context, self); + [RubyMethod("reject!")] + public static object RejectInPlace(BlockParam block, IList/*!*/ self) { + bool changed, jumped; + object result = DeleteIf(block, self, out changed, out jumped); + return jumped ? result : changed ? self : null; + } + + private static object DeleteIf(BlockParam block, IList/*!*/ self, out bool changed, out bool jumped) { changed = false; jumped = false; if (block == null && self.Count > 0) { throw RubyExceptions.NoBlockGiven(); } + + RequireNotFrozen(self); - // TODO: if block jumpes the array is not modified: + // TODO: if block jumps the array is not modified: int i = 0; while (i < self.Count) { object result; @@ -735,23 +772,12 @@ namespace IronRuby.Builtins { return null; } - [RubyMethod("reject!")] - public static object RejectInPlace(RubyContext/*!*/ context, BlockParam block, IList/*!*/ self) { - bool changed, jumped; - object result = DeleteIf(context, block, self, out changed, out jumped); - if (jumped) return result; - if (changed) return self; - return null; - } - #endregion #region each, each_index [RubyMethod("each")] - public static object Each(RubyContext/*!*/ context, BlockParam block, IList/*!*/ self) { - Assert.NotNull(context, self); - + public static object Each(BlockParam block, IList/*!*/ self) { if (self.Count > 0 && block == null) { throw RubyExceptions.NoBlockGiven(); } @@ -766,9 +792,7 @@ namespace IronRuby.Builtins { } [RubyMethod("each_index")] - public static object EachIndex(RubyContext/*!*/ context, BlockParam block, IList/*!*/ self) { - Assert.NotNull(context, self); - + public static object EachIndex(BlockParam block, IList/*!*/ self) { if (self.Count > 0 && block == null) { throw RubyExceptions.NoBlockGiven(); } @@ -824,9 +848,7 @@ namespace IronRuby.Builtins { #region fill [RubyMethod("fill")] - public static IList/*!*/ Fill(RubyContext/*!*/ context, IList/*!*/ self, object obj, [DefaultParameterValue(0)]int start) { - RubyUtils.RequiresNotFrozen(context, self); - + public static IList/*!*/ Fill(IList/*!*/ self, object obj, [DefaultParameterValue(0)]int start) { // Note: Array#fill(obj, start) is not equivalent to Array#fill(obj, start, 0) // (as per MRI behavior, the latter can expand the array if start > length, but the former doesn't) start = Math.Max(0, NormalizeIndex(self, start)); @@ -838,9 +860,7 @@ namespace IronRuby.Builtins { } [RubyMethod("fill")] - public static IList/*!*/ Fill(RubyContext/*!*/ context, IList/*!*/ self, object obj, int start, int length) { - RubyUtils.RequiresNotFrozen(context, self); - + public static IList/*!*/ Fill(IList/*!*/ self, object obj, int start, int length) { // Note: Array#fill(obj, start) is not equivalent to Array#fill(obj, start, 0) // (as per MRI behavior, the latter can expand the array if start > length, but the former doesn't) start = Math.Max(0, NormalizeIndex(self, start)); @@ -858,9 +878,9 @@ namespace IronRuby.Builtins { public static IList/*!*/ Fill(ConversionStorage<int>/*!*/ fixnumCast, IList/*!*/ self, object obj, object start, [DefaultParameterValue(null)]object length) { int startFixnum = (start == null) ? 0 : Protocols.CastToFixnum(fixnumCast, start); if (length == null) { - return Fill(fixnumCast.Context, self, obj, startFixnum); + return Fill(self, obj, startFixnum); } else { - return Fill(fixnumCast.Context, self, obj, startFixnum, Protocols.CastToFixnum(fixnumCast, length)); + return Fill(self, obj, startFixnum, Protocols.CastToFixnum(fixnumCast, length)); } } @@ -870,13 +890,11 @@ namespace IronRuby.Builtins { int end = NormalizeIndex(self, Protocols.CastToFixnum(fixnumCast, range.End)); int length = Math.Max(0, end - begin + (range.ExcludeEnd ? 0 : 1)); - return Fill(fixnumCast.Context, self, obj, begin, length); + return Fill(self, obj, begin, length); } [RubyMethod("fill")] - public static object Fill(RubyContext/*!*/ context, [NotNull]BlockParam/*!*/ block, IList/*!*/ self, [DefaultParameterValue(0)]int start) { - RubyUtils.RequiresNotFrozen(context, self); - + public static object Fill([NotNull]BlockParam/*!*/ block, IList/*!*/ self, [DefaultParameterValue(0)]int start) { start = Math.Max(0, NormalizeIndex(self, start)); for (int i = start; i < self.Count; i++) { @@ -890,9 +908,7 @@ namespace IronRuby.Builtins { } [RubyMethod("fill")] - public static object Fill(RubyContext/*!*/ context, [NotNull]BlockParam/*!*/ block, IList/*!*/ self, int start, int length) { - RubyUtils.RequiresNotFrozen(context, self); - + public static object Fill([NotNull]BlockParam/*!*/ block, IList/*!*/ self, int start, int length) { start = Math.Max(0, NormalizeIndex(self, start)); ExpandList(self, Math.Min(start, start + length)); @@ -912,9 +928,9 @@ namespace IronRuby.Builtins { public static object Fill(ConversionStorage<int>/*!*/ fixnumCast, [NotNull]BlockParam/*!*/ block, IList/*!*/ self, object start, [DefaultParameterValue(null)]object length) { int startFixnum = (start == null) ? 0 : Protocols.CastToFixnum(fixnumCast, start); if (length == null) { - return Fill(fixnumCast.Context, block, self, startFixnum); + return Fill(block, self, startFixnum); } else { - return Fill(fixnumCast.Context, block, self, startFixnum, Protocols.CastToFixnum(fixnumCast, length)); + return Fill(block, self, startFixnum, Protocols.CastToFixnum(fixnumCast, length)); } } @@ -924,7 +940,7 @@ namespace IronRuby.Builtins { int end = NormalizeIndex(self, Protocols.CastToFixnum(fixnumCast, range.End)); int length = Math.Max(0, end - begin + (range.ExcludeEnd ? 0 : 1)); - return Fill(fixnumCast.Context, block, self, begin, length); + return Fill(block, self, begin, length); } #endregion @@ -943,7 +959,7 @@ namespace IronRuby.Builtins { } count = count > self.Count ? self.Count : count; - return RubyArray.Create(self as IList<object>, 0, count); + return new RubyArray(self, 0, count); } [RubyMethod("last")] @@ -958,7 +974,7 @@ namespace IronRuby.Builtins { } count = count > self.Count ? self.Count : count; - return RubyArray.Create(self as IList<object>, self.Count - count, count); + return new RubyArray(self, self.Count - count, count); } #endregion @@ -1004,7 +1020,8 @@ namespace IronRuby.Builtins { public static IList/*!*/ Flatten( CallSiteStorage<Func<CallSite, RubyClass, object>>/*!*/ allocateStorage, ConversionStorage<IList>/*!*/ tryToAry, - RubyContext/*!*/ context, IList/*!*/ self) { + IList/*!*/ self) { + IList result; TryFlattenArray(allocateStorage, tryToAry, self, out result); return result; @@ -1014,13 +1031,13 @@ namespace IronRuby.Builtins { public static IList FlattenInPlace( CallSiteStorage<Func<CallSite, RubyClass, object>>/*!*/ allocateStorage, ConversionStorage<IList>/*!*/ tryToAry, - RubyContext/*!*/ context, IList/*!*/ self) { + IList/*!*/ self) { + IList result; if (!TryFlattenArray(allocateStorage, tryToAry, self, out result)) { return null; } - RubyUtils.RequiresNotFrozen(context, self); self.Clear(); AddRange(self, result); return self; @@ -1124,6 +1141,7 @@ namespace IronRuby.Builtins { Assert.NotNull(list, separator, result, seen); RubyContext context = tosConversion.Context; + // TODO: can we get by only tracking List<> ? // (inspect needs to track everything) bool found; @@ -1240,10 +1258,7 @@ namespace IronRuby.Builtins { #region insert, push, pop, shift, unshift, << [RubyMethod("insert")] - public static IList/*!*/ Insert(RubyContext/*!*/ context, IList/*!*/ self, [DefaultProtocol]int index, [NotNull]params object[]/*!*/ args) { - if (args.Length > 0) - RubyUtils.RequiresNotFrozen(context, self); - + public static IList/*!*/ Insert(IList/*!*/ self, [DefaultProtocol]int index, [NotNull]params object[]/*!*/ args) { if (args.Length == 0) { return self; } @@ -1269,30 +1284,24 @@ namespace IronRuby.Builtins { } [RubyMethod("push")] - public static IList/*!*/ Push(RubyContext/*!*/ context, IList/*!*/ self, [NotNull]params object[]/*!*/ values) { - if (values.Length > 0) { - RubyUtils.RequiresNotFrozen(context, self); - } + public static IList/*!*/ Push(IList/*!*/ self, [NotNull]params object[]/*!*/ values) { AddRange(self, values); return self; } [RubyMethod("pop")] - public static object Pop(RubyContext/*!*/ context, IList/*!*/ self) { + public static object Pop(IList/*!*/ self) { if (self.Count == 0) { return null; } - RubyUtils.RequiresNotFrozen(context, self); object result = self[self.Count - 1]; self.RemoveAt(self.Count - 1); return result; } [RubyMethod("shift")] - public static object Shift(RubyContext/*!*/ context, IList/*!*/ self) { - RubyUtils.RequiresNotFrozen(context, self); - + public static object Shift(IList/*!*/ self) { if (self.Count == 0) { return null; } @@ -1303,18 +1312,21 @@ namespace IronRuby.Builtins { } [RubyMethod("unshift")] - public static IList/*!*/ Unshift(RubyContext/*!*/ context, IList/*!*/ self, [NotNull]params object[]/*!*/ args) { + public static IList/*!*/ Unshift(IList/*!*/ self, object/*!*/ arg) { + self.Insert(0, arg); + return self; + } + + [RubyMethod("unshift")] + public static IList/*!*/ Unshift(IList/*!*/ self, [NotNull]params object[]/*!*/ args) { if (args.Length > 0) { - RubyUtils.RequiresNotFrozen(context, self); + InsertRange(self, 0, args); } - - InsertRange(self, 0, args); return self; } [RubyMethod("<<")] - public static IList/*!*/ Append(RubyContext/*!*/ context, IList/*!*/ self, object value) { - RubyUtils.RequiresNotFrozen(context, self); + public static IList/*!*/ Append(IList/*!*/ self, object value) { self.Add(value); return self; } @@ -1325,7 +1337,6 @@ namespace IronRuby.Builtins { [RubyMethod("slice!")] public static object SliceInPlace(ConversionStorage<IList>/*!*/ arrayTryCast, IList/*!*/ self, [DefaultProtocol]int index) { - RubyUtils.RequiresNotFrozen(arrayTryCast.Context, self); index = index < 0 ? index + self.Count : index; if (index >= 0 && index < self.Count) { object result = self[index]; @@ -1337,21 +1348,23 @@ namespace IronRuby.Builtins { } [RubyMethod("slice!")] - public static object SliceInPlace(ConversionStorage<IList>/*!*/ arrayTryCast, + public static object SliceInPlace( + ConversionStorage<IList>/*!*/ arrayTryCast, ConversionStorage<int>/*!*/ fixnumCast, CallSiteStorage<Func<CallSite, RubyClass, object>>/*!*/ allocateStorage, IList/*!*/ self, [NotNull]Range/*!*/ range) { - RubyUtils.RequiresNotFrozen(fixnumCast.Context, self); + object result = GetElement(fixnumCast, allocateStorage, self, range); SetElement(arrayTryCast, fixnumCast, self, range, null); return result; } [RubyMethod("slice!")] - public static IList/*!*/ SliceInPlace(ConversionStorage<IList>/*!*/ arrayTryCast, + public static IList/*!*/ SliceInPlace( + ConversionStorage<IList>/*!*/ arrayTryCast, CallSiteStorage<Func<CallSite, RubyClass, object>>/*!*/ allocateStorage, IList/*!*/ self, [DefaultProtocol]int start, [DefaultProtocol]int length) { - RubyUtils.RequiresNotFrozen(allocateStorage.Context, self); + IList result = GetElements(allocateStorage, self, start, length); SetElement(arrayTryCast, self, start, length, null); return result; @@ -1372,7 +1385,7 @@ namespace IronRuby.Builtins { // TODO: this is not optimal because it makes an extra array copy // (only affects sorting of .NET types, do we need our own quicksort?) IList result = CreateResultArray(allocateStorage, self); - Replace(comparisonStorage.Context, result, ArrayOps.SortInPlace(comparisonStorage, lessThanStorage, greaterThanStorage, block, ToArray(self))); + Replace(result, ArrayOps.SortInPlace(comparisonStorage, lessThanStorage, greaterThanStorage, block, ToArray(self))); return result; } @@ -1383,13 +1396,12 @@ namespace IronRuby.Builtins { BinaryOpStorage/*!*/ greaterThanStorage, BlockParam block, IList/*!*/ self) { - RubyUtils.RequiresNotFrozen(comparisonStorage.Context, self); // this should always call ArrayOps.SortInPlace instead Debug.Assert(!(self is RubyArray)); // TODO: this is not optimal because it makes an extra array copy // (only affects sorting of .NET types, do we need our own quicksort?) - Replace(comparisonStorage.Context, self, ArrayOps.SortInPlace(comparisonStorage, lessThanStorage, greaterThanStorage, block, ToArray(self))); + Replace(self, ArrayOps.SortInPlace(comparisonStorage, lessThanStorage, greaterThanStorage, block, ToArray(self))); return self; } @@ -1410,9 +1422,7 @@ namespace IronRuby.Builtins { } [RubyMethod("reverse!")] - public static IList/*!*/ InPlaceReverse(RubyContext/*!*/ context, IList/*!*/ self) { - RubyUtils.RequiresNotFrozen(context, self); - + public static IList/*!*/ InPlaceReverse(IList/*!*/ self) { int stop = self.Count / 2; int last = self.Count - 1; for (int i = 0; i < stop; i++) { @@ -1425,7 +1435,7 @@ namespace IronRuby.Builtins { } [RubyMethod("transpose")] - public static RubyArray/*!*/ Transpose(ConversionStorage<IList>/*!*/ arrayCast, RubyContext/*!*/ context, IList/*!*/ self) { + public static RubyArray/*!*/ Transpose(ConversionStorage<IList>/*!*/ arrayCast, IList/*!*/ self) { // Get the arrays. Note we need to check length as we go, so we call to_ary on all the // arrays we encounter before the error (if any). RubyArray result = new RubyArray(); @@ -1464,8 +1474,8 @@ namespace IronRuby.Builtins { } [RubyMethod("uniq!")] - public static IList UniqueSelf(RubyContext/*!*/ context, IList/*!*/ self) { - var seen = new Dictionary<object, bool>(context.EqualityComparer); + public static IList UniqueSelf(UnaryOpStorage/*!*/ hashStorage, BinaryOpStorage/*!*/ eqlStorage, IList/*!*/ self) { + var seen = new Dictionary<object, bool>(new EqualityComparer(hashStorage, eqlStorage)); bool nilSeen = false; bool modified = false; int i = 0; @@ -1478,9 +1488,6 @@ namespace IronRuby.Builtins { nilSeen = true; i++; } else { - if (context.IsObjectFrozen(self)) { - throw RubyExceptions.CreateTypeError("can't modify frozen array"); - } self.RemoveAt(i); modified = true; } Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Extensions/IListOps.cs @@ -2518,7 +2518,7 @@ namespace IronRuby.Builtins { private static void LoadKernel_Instance(IronRuby.Builtins.RubyModule/*!*/ module) { module.DefineLibraryMethod("__id__", 0x51, - new System.Func<IronRuby.Runtime.RubyContext, System.Object, System.Int32>(IronRuby.Builtins.KernelOps.GetObjectId) + new System.Func<IronRuby.Runtime.RubyContext, System.Object, System.Object>(IronRuby.Builtins.KernelOps.GetObjectId) ); module.DefineLibraryMethod("__send__", 0x51, @@ -2690,7 +2690,7 @@ namespace IronRuby.Builtins { ); module.DefineLibraryMethod("id", 0x51, - new System.Func<IronRuby.Runtime.RubyContext, System.Object, System.Int32>(IronRuby.Builtins.KernelOps.GetId) + new System.Func<IronRuby.Runtime.RubyContext, System.Object, System.Object>(IronRuby.Builtins.KernelOps.GetId) ); module.DefineLibraryMethod("initialize_copy", 0x52, @@ -2780,7 +2780,7 @@ namespace IronRuby.Builtins { ); module.DefineLibraryMethod("object_id", 0x51, - new System.Func<IronRuby.Runtime.RubyContext, System.Object, System.Int32>(IronRuby.Builtins.KernelOps.GetObjectId) + new System.Func<IronRuby.Runtime.RubyContext, System.Object, System.Object>(IronRuby.Builtins.KernelOps.GetObjectId) ); module.DefineLibraryMethod("open", 0x52, @@ -4247,7 +4247,7 @@ namespace IronRuby.Builtins { ); module.DefineLibraryMethod("hash", 0x51, - new System.Func<IronRuby.Builtins.Range, System.Int32>(IronRuby.Builtins.RangeOps.GetHashCode) + new System.Func<IronRuby.Runtime.UnaryOpStorage, IronRuby.Builtins.Range, System.Int32>(IronRuby.Builtins.RangeOps.GetHashCode) ); module.DefineLibraryMethod("include?", 0x51, @@ -4828,11 +4828,11 @@ namespace IronRuby.Builtins { ); module.DefineLibraryMethod("eql?", 0x51, - new System.Func<IronRuby.Builtins.RubyStruct, System.Object, System.Boolean>(IronRuby.Builtins.RubyStructOps.Equal) + new System.Func<IronRuby.Runtime.BinaryOpStorage, IronRuby.Builtins.RubyStruct, System.Object, System.Boolean>(IronRuby.Builtins.RubyStructOps.Equal) ); module.DefineLibraryMethod("hash", 0x51, - new System.Func<IronRuby.Builtins.RubyStruct, System.Int32>(IronRuby.Builtins.RubyStructOps.Hash) + new System.Func<IronRuby.Runtime.UnaryOpStorage, IronRuby.Runtime.ConversionStorage<System.Int32>, IronRuby.Builtins.RubyStruct, System.Int32>(IronRuby.Builtins.RubyStructOps.Hash) ); module.DefineLibraryMethod("initialize", 0x52, @@ -5135,11 +5135,11 @@ namespace IronRuby.Builtins { private static void LoadSystem__Collections__IList_Instance(IronRuby.Builtins.RubyModule/*!*/ module) { module.DefineLibraryMethod("-", 0x51, - new System.Func<IronRuby.Runtime.UnaryOpStorage, IronRuby.Runtime.BinaryOpStorage, IronRuby.Runtime.RubyContext, System.Collections.IList, System.Collections.IList, IronRuby.Builtins.RubyArray>(IronRuby.Builtins.IListOps.Difference) + new System.Func<IronRuby.Runtime.UnaryOpStorage, IronRuby.Runtime.BinaryOpStorage, System.Collections.IList, System.Collections.IList, IronRuby.Builtins.RubyArray>(IronRuby.Builtins.IListOps.Difference) ); module.DefineLibraryMethod("&", 0x51, - new System.Func<IronRuby.Runtime.RubyContext, System.Collections.IList, System.Collections.IList, IronRuby.Builtins.RubyArray>(IronRuby.Builtins.IListOps.Intersection) + new System.Func<IronRuby.Runtime.UnaryOpStorage, IronRuby.Runtime.BinaryOpStorage, System.Collections.IList, System.Collections.IList, IronRuby.Builtins.RubyArray>(IronRuby.Builtins.IListOps.Intersection) ); module.DefineLibraryMethod("*", 0x51, @@ -5155,13 +5155,13 @@ namespace IronRuby.Builtins { ); module.DefineLibraryMethod("[]=", 0x51, - new System.Func<IronRuby.Runtime.RubyContext, System.Collections.IList, System.Int32, System.Object, System.Object>(IronRuby.Builtins.IListOps.SetElement), + new System.Func<System.Collections.IList, System.Int32, System.Object, System.Object>(IronRuby.Builtins.IListOps.SetElement), new System.Func<IronRuby.Runtime.ConversionStorage<System.Collections.IList>, System.Collections.IList, System.Int32, System.Int32, System.Object, System.Object>(IronRuby.Builtins.IListOps.SetElement), new System.Func<IronRuby.Runtime.ConversionStorage<System.Collections.IList>, IronRuby.Runtime.ConversionStorage<System.Int32>, System.Collections.IList, IronRuby.Builtins.Range, System.Object, System.Object>(IronRuby.Builtins.IListOps.SetElement) ); module.DefineLibraryMethod("|", 0x51, - new System.Func<IronRuby.Runtime.RubyContext, System.Collections.IList, System.Collections.IList, IronRuby.Builtins.RubyArray>(IronRuby.Builtins.IListOps.Union) + new System.Func<IronRuby.Runtime.UnaryOpStorage, IronRuby.Runtime.BinaryOpStorage, System.Collections.IList, System.Collections.IList, IronRuby.Builtins.RubyArray>(IronRuby.Builtins.IListOps.Union) ); module.DefineLibraryMethod("+", 0x51, @@ -5169,7 +5169,7 @@ namespace IronRuby.Builtins { ); module.DefineLibraryMethod("<<", 0x51, - new System.Func<IronRuby.Runtime.RubyContext, System.Collections.IList, System.Object, System.Collections.IList>(IronRuby.Builtins.IListOps.Append) + new System.Func<System.Collections.IList, System.Object, System.Collections.IList>(IronRuby.Builtins.IListOps.Append) ); module.DefineLibraryMethod("<=>", 0x51, @@ -5190,11 +5190,11 @@ namespace IronRuby.Builtins { ); module.DefineLibraryMethod("clear", 0x51, - new System.Func<IronRuby.Runtime.RubyContext, System.Collections.IList, System.Collections.IList>(IronRuby.Builtins.IListOps.Clear) + new System.Func<System.Collections.IList, System.Collections.IList>(IronRuby.Builtins.IListOps.Clear) ); module.DefineLibraryMethod("collect!", 0x51, - new System.Func<IronRuby.Runtime.RubyContext, IronRuby.Runtime.BlockParam, System.Collections.IList, System.Object>(IronRuby.Builtins.IListOps.CollectInPlace) + new System.Func<IronRuby.Runtime.BlockParam, System.Collections.IList, System.Object>(IronRuby.Builtins.IListOps.CollectInPlace) ); module.DefineLibraryMethod("compact", 0x51, @@ -5202,11 +5202,11 @@ namespace IronRuby.Builtins { ); module.DefineLibraryMethod("compact!", 0x51, - new System.Func<IronRuby.Runtime.RubyContext, System.Collections.IList, System.Collections.IList>(IronRuby.Builtins.IListOps.CompactInPlace) + new System.Func<System.Collections.IList, System.Collections.IList>(IronRuby.Builtins.IListOps.CompactInPlace) ); module.DefineLibraryMethod("concat", 0x51, - new System.Func<IronRuby.Runtime.RubyContext, System.Collections.IList, System.Collections.IList, System.Collections.IList>(IronRuby.Builtins.IListOps.Concat) + new System.Func<System.Collections.IList, System.Collections.IList, System.Collections.IList>(IronRuby.Builtins.IListOps.Concat) ); module.DefineLibraryMethod("delete", 0x51, @@ -5215,19 +5215,19 @@ namespace IronRuby.Builtins { ); module.DefineLibraryMethod("delete_at", 0x51, - new System.Func<IronRuby.Runtime.RubyContext, System.Collections.IList, System.Int32, System.Object>(IronRuby.Builtins.IListOps.DeleteAt) + new System.Func<System.Collections.IList, System.Int32, System.Object>(IronRuby.Builtins.IListOps.DeleteAt) ); module.DefineLibraryMethod("delete_if", 0x51, - new System.Func<IronRuby.Runtime.RubyContext, IronRuby.Runtime.BlockParam, System.Collections.IList, System.Object>(IronRuby.Builtins.IListOps.DeleteIf) + new System.Func<IronRuby.Runtime.BlockParam, System.Collections.IList, System.Object>(IronRuby.Builtins.IListOps.DeleteIf) ); module.DefineLibraryMethod("each", 0x51, - new System.Func<IronRuby.Runtime.RubyContext, IronRuby.Runtime.BlockParam, System.Collections.IList, System.Object>(IronRuby.Builtins.IListOps.Each) + new System.Func<IronRuby.Runtime.BlockParam, System.Collections.IList, System.Object>(IronRuby.Builtins.IListOps.Each) ); module.DefineLibraryMethod("each_index", 0x51, - new System.Func<IronRuby.Runtime.RubyContext, IronRuby.Runtime.BlockParam, System.Collections.IList, System.Object>(IronRuby.Builtins.IListOps.EachIndex) + new System.Func<IronRuby.Runtime.BlockParam, System.Collections.IList, System.Object>(IronRuby.Builtins.IListOps.EachIndex) ); module.DefineLibraryMethod("empty?", 0x51, @@ -5243,12 +5243,12 @@ namespace IronRuby.Builtins { ); module.DefineLibraryMethod("fill", 0x51, - new System.Func<IronRuby.Runtime.RubyContext, System.Collections.IList, System.Object, System.Int32, System.Collections.IList>(IronRuby.Builtins.IListOps.Fill), - new System.Func<IronRuby.Runtime.RubyContext, System.Collections.IList, System.Object, System.Int32, System.Int32, System.Collections.IList>(IronRuby.Builtins.IListOps.Fill), + new System.Func<System.Collections.IList, System.Object, System.Int32, System.Collections.IList>(IronRuby.Builtins.IListOps.Fill), + new System.Func<System.Collections.IList, System.Object, System.Int32, System.Int32, System.Collections.IList>(IronRuby.Builtins.IListOps.Fill), new System.Func<IronRuby.Runtime.ConversionStorage<System.Int32>, System.Collections.IList, System.Object, System.Object, System.Object, System.Collections.IList>(IronRuby.Builtins.IListOps.Fill), new System.Func<IronRuby.Runtime.ConversionStorage<System.Int32>, System.Collections.IList, System.Object, IronRuby.Builtins.Range, System.Collections.IList>(IronRuby.Builtins.IListOps.Fill), - new System.Func<IronRuby.Runtime.RubyContext, IronRuby.Runtime.BlockParam, System.Collections.IList, System.Int32, System.Object>(IronRuby.Builtins.IListOps.Fill), - new System.Func<IronRuby.Runtime.RubyContext, IronRuby.Runtime.BlockParam, System.Collections.IList, System.Int32, System.Int32, System.Object>(IronRuby.Builtins.IListOps.Fill), + new System.Func<IronRuby.Runtime.BlockParam, System.Collections.IList, System.Int32, System.Object>(IronRuby.Builtins.IListOps.Fill), + new System.Func<IronRuby.Runtime.BlockParam, System.Collections.IList, System.Int32, System.Int32, System.Object>(IronRuby.Builtins.IListOps.Fill), new System.Func<IronRuby.Runtime.ConversionStorage<System.Int32>, IronRuby.Runtime.BlockParam, System.Collections.IList, System.Object, System.Object, System.Object>(IronRuby.Builtins.IListOps.Fill), new System.Func<IronRuby.Runtime.ConversionStorage<System.Int32>, IronRuby.Runtime.BlockParam, System.Collections.IList, IronRuby.Builtins.Range, System.Object>(IronRuby.Builtins.IListOps.Fill) ); @@ -5259,11 +5259,11 @@ namespace IronRuby.Builtins { ); module.DefineLibraryMethod("flatten", 0x51, - new System.Func<IronRuby.Runtime.CallSiteStorage<System.Func<System.Runtime.CompilerServices.CallSite, IronRuby.Builtins.RubyClass, System.Object>>, IronRuby.Runtime.ConversionStorage<System.Collections.IList>, IronRuby.Runtime.RubyContext, System.Collections.IList, System.Collections.IList>(IronRuby.Builtins.IListOps.Flatten) + new System.Func<IronRuby.Runtime.CallSiteStorage<System.Func<System.Runtime.CompilerServices.CallSite, IronRuby.Builtins.RubyClass, System.Object>>, IronRuby.Runtime.ConversionStorage<System.Collections.IList>, System.Collections.IList, System.Collections.IList>(IronRuby.Builtins.IListOps.Flatten) ); module.DefineLibraryMethod("flatten!", 0x51, - new System.Func<IronRuby.Runtime.CallSiteStorage<System.Func<System.Runtime.CompilerServices.CallSite, IronRuby.Builtins.RubyClass, System.Object>>, IronRuby.Runtime.ConversionStorage<System.Collections.IList>, IronRuby.Runtime.RubyContext, System.Collections.IList, System.Collections.IList>(IronRuby.Builtins.IListOps.FlattenInPlace) + new System.Func<IronRuby.Runtime.CallSiteStorage<System.Func<System.Runtime.CompilerServices.CallSite, IronRuby.Builtins.RubyClass, System.Object>>, IronRuby.Runtime.ConversionStorage<System.Collections.IList>, System.Collections.IList, System.Collections.IList>(IronRuby.Builtins.IListOps.FlattenInPlace) ); module.DefineLibraryMethod("hash", 0x51, @@ -5287,11 +5287,11 @@ namespace IronRuby.Builtins { ); module.DefineLibraryMethod("initialize_copy", 0x52, - new System.Func<IronRuby.Runtime.RubyContext, System.Collections.IList, System.Collections.IList, System.Collections.IList>(IronRuby.Builtins.IListOps.Replace) + new System.Func<System.Collections.IList, System.Collections.IList, System.Collections.IList>(IronRuby.Builtins.IListOps.Replace) ); module.DefineLibraryMethod("insert", 0x51, - new System.Func<IronRuby.Runtime.RubyContext, System.Collections.IList, System.Int32, System.Object[], System.Collections.IList>(IronRuby.Builtins.IListOps.Insert) + new System.Func<System.Collections.IList, System.Int32, System.Object[], System.Collections.IList>(IronRuby.Builtins.IListOps.Insert) ); module.DefineLibraryMethod("inspect", 0x51, @@ -5313,7 +5313,7 @@ namespace IronRuby.Builtins { ); module.DefineLibraryMethod("map!", 0x51, - new System.Func<IronRuby.Runtime.RubyContext, IronRuby.Runtime.BlockParam, System.Collections.IList, System.Object>(IronRuby.Builtins.IListOps.CollectInPlace) + new System.Func<IronRuby.Runtime.BlockParam, System.Collections.IList, System.Object>(IronRuby.Builtins.IListOps.CollectInPlace) ); module.DefineLibraryMethod("nitems", 0x51, @@ -5321,11 +5321,11 @@ namespace IronRuby.Builtins { ); module.DefineLibraryMethod("pop", 0x51, - new System.Func<IronRuby.Runtime.RubyContext, System.Collections.IList, System.Object>(IronRuby.Builtins.IListOps.Pop) + new System.Func<System.Collections.IList, System.Object>(IronRuby.Builtins.IListOps.Pop) ); module.DefineLibraryMethod("push", 0x51, - new System.Func<IronRuby.Runtime.RubyContext, System.Collections.IList, System.Object[], System.Collections.IList>(IronRuby.Builtins.IListOps.Push) + new System.Func<System.Collections.IList, System.Object[], System.Collections.IList>(IronRuby.Builtins.IListOps.Push) ); module.DefineLibraryMethod("rassoc", 0x51, @@ -5333,11 +5333,11 @@ namespace IronRuby.Builtins { ); module.DefineLibraryMethod("reject!", 0x51, - new System.Func<IronRuby.Runtime.RubyContext, IronRuby.Runtime.BlockParam, System.Collections.IList, System.Object>(IronRuby.Builtins.IListOps.RejectInPlace) + new System.Func<IronRuby.Runtime.BlockParam, System.Collections.IList, System.Object>(IronRuby.Builtins.IListOps.RejectInPlace) ); module.DefineLibraryMethod("replace", 0x51, - new System.Func<IronRuby.Runtime.RubyContext, System.Collections.IList, System.Collections.IList, System.Collections.IList>(IronRuby.Builtins.IListOps.Replace) + new System.Func<System.Collections.IList, System.Collections.IList, System.Collections.IList>(IronRuby.Builtins.IListOps.Replace) ); module.DefineLibraryMethod("reverse", 0x51, @@ -5345,7 +5345,7 @@ namespace IronRuby.Builtins { ); module.DefineLibraryMethod("reverse!", 0x51, - new System.Func<IronRuby.Runtime.RubyContext, System.Collections.IList, System.Collections.IList>(IronRuby.Builtins.IListOps.InPlaceReverse) + new System.Func<System.Collections.IList, System.Collections.IList>(IronRuby.Builtins.IListOps.InPlaceReverse) ); module.DefineLibraryMethod("rindex", 0x51, @@ -5353,7 +5353,7 @@ namespace IronRuby.Builtins { ); module.DefineLibraryMethod("shift", 0x51, - new System.Func<IronRuby.Runtime.RubyContext, System.Collections.IList, System.Object>(IronRuby.Builtins.IListOps.Shift) + new System.Func<System.Collections.IList, System.Object>(IronRuby.Builtins.IListOps.Shift) ); module.DefineLibraryMethod("size", 0x51, @@ -5393,7 +5393,7 @@ namespace IronRuby.Builtins { ); module.DefineLibraryMethod("transpose", 0x51, - new System.Func<IronRuby.Runtime.ConversionStorage<System.Collections.IList>, IronRuby.Runtime.RubyContext, System.Collections.IList, IronRuby.Builtins.RubyArray>(IronRuby.Builtins.IListOps.Transpose) + new System.Func<IronRuby.Runtime.ConversionStorage<System.Collections.IList>, System.Collections.IList, IronRuby.Builtins.RubyArray>(IronRuby.Builtins.IListOps.Transpose) ); module.DefineLibraryMethod("uniq", 0x51, @@ -5401,11 +5401,12 @@ namespace IronRuby.Builtins { ); module.DefineLibraryMethod("uniq!", 0x51, - new System.Func<IronRuby.Runtime.RubyContext, System.Collections.IList, System.Collections.IList>(IronRuby.Builtins.IListOps.UniqueSelf) + new System.Func<IronRuby.Runtime.UnaryOpStorage, IronRuby.Runtime.BinaryOpStorage, System.Collections.IList, System.Collections.IList>(IronRuby.Builtins.IListOps.UniqueSelf) ); module.DefineLibraryMethod("unshift", 0x51, - new System.Func<IronRuby.Runtime.RubyContext, System.Collections.IList, System.Object[], System.Collections.IList>(IronRuby.Builtins.IListOps.Unshift) + new System.Func<System.Collections.IList, System.Object, System.Collections.IList>(IronRuby.Builtins.IListOps.Unshift), + new System.Func<System.Collections.IList, System.Object[], System.Collections.IList>(IronRuby.Builtins.IListOps.Unshift) ); module.DefineLibraryMethod("values_at", 0x51, Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Initializers.Generated.cs @@ -153,13 +153,13 @@ namespace IronRuby.Builtins { public static MutableString/*!*/ CreateMutable(string/*!*/ str, RubyEncoding/*!*/ encoding) { ContractUtils.RequiresNotNull(encoding, "encoding"); - return new MutableString(str.ToCharArray(), encoding); + return new MutableString(str, encoding); } public static MutableString/*!*/ Create(string/*!*/ str, RubyEncoding/*!*/ encoding) { ContractUtils.RequiresNotNull(str, "str"); ContractUtils.RequiresNotNull(encoding, "encoding"); - return new MutableString(str.ToCharArray(), encoding); + return new MutableString(str, encoding); } public static MutableString/*!*/ CreateBinary() { Merlin/Main/Languages/Ruby/Ruby/Builtins/MutableString.cs @@ -25,43 +25,56 @@ using IronRuby.Runtime.Calls; namespace IronRuby.Builtins { /// <summary> - /// Array inherits from Object, mixes in Enumerable. - /// Ruby's Array is a List{object}, but it overrides Equals and GetHashCode so - /// .NET dictionaries will hash it correctly. + /// Implements Ruby array. + /// Not thread safe (even when frozen). /// </summary> [DebuggerDisplay("{GetDebugView()}")] - public partial class RubyArray : List<object>, IDuplicable { + public partial class RubyArray : IList<object>, IList, IRubyObjectState, IDuplicable { + private readonly List<object>/*!*/ _content; + + // The lowest bit is tainted flag. + // The version is set to FrozenVersion when the string is frozen. FrozenVersion is the maximum version, so any update to the version + // triggers an OverflowException, which we convert to InvalidOperationException. + private uint _versionAndFlags; + + private const uint IsTaintedFlag = 1; + private const int FlagCount = 1; + private const uint FlagsMask = (1U << FlagCount) - 1; + private const uint VersionMask = ~FlagsMask; + private const uint FrozenVersion = VersionMask; + #region Construction public RubyArray() { + _content = new List<object>(); } - public RubyArray(int capacity) - : base(capacity) { + public RubyArray(int capacity) { + _content = new List<object>(capacity); } - public RubyArray(IEnumerable<object>/*!*/ collection) - : base(collection) { + public RubyArray(IEnumerable<object>/*!*/ collection) { + _content = new List<object>(collection); } public RubyArray(IEnumerable/*!*/ collection) - : base(CollectionUtils.ToEnumerable<object>(collection)) { + : this(CollectionUtils.ToEnumerable<object>(collection)) { } - public static RubyArray/*!*/ Create<T>(IList<T>/*!*/ list, int start, int count) { + public RubyArray(IList/*!*/ list, int start, int count) { ContractUtils.RequiresNotNull(list, "list"); - ContractUtils.RequiresArrayRange(list, start, count, "start", "count"); + ContractUtils.RequiresArrayRange(list.Count, start, count, "start", "count"); - RubyArray result = new RubyArray(); + var data = new List<object>(); for (int i = 0; i < count; i++) { - result.Add(list[start + i]); + data.Add(list[start + i]); } - return result; + _content = data; } public static RubyArray/*!*/ Create(object item) { var result = new RubyArray(); - result.Add(item); + result._content.Add(item); return result; } @@ -89,6 +102,45 @@ namespace IronRuby.Builtins { #endregion + #region Versioning, Flags + + private void Mutate() { + try { + checked { _versionAndFlags += (1 << FlagCount); } + } catch (OverflowException) { + throw RubyExceptions.CreateTypeError("can't modify frozen object"); + } + } + + public bool IsTainted { + get { + return (_versionAndFlags & IsTaintedFlag) != 0; + } + set { + Mutate(); + _versionAndFlags = (_versionAndFlags & ~IsTaintedFlag) | (value ? IsTaintedFlag : 0); + } + } + + public bool IsFrozen { + get { + return (_versionAndFlags & VersionMask) == FrozenVersion; + } + } + + void IRubyObjectState.Freeze() { + Freeze(); + } + + public RubyArray/*!*/ Freeze() { + _versionAndFlags |= FrozenVersion; + return this; + } + + #endregion + + #region HashCode, Equality + [MultiRuntimeAware] private static RubyUtils.RecursionTracker _HashTracker = new RubyUtils.RecursionTracker(); @@ -138,28 +190,220 @@ namespace IronRuby.Builtins { return true; } + #endregion + + #region IList<object> Members + + public int IndexOf(object item) { + return _content.IndexOf(item); + } + + public object this[int index] { + get { + return _content[index]; + } + set { + Mutate(); + _content[index] = value; + } + } + + public void Insert(int index, object item) { + Mutate(); + _content.Insert(index, item); + } + + public void RemoveAt(int index) { + Mutate(); + _content.RemoveAt(index); + } + + #endregion + + #region ICollection<object> Members + + public int Count { + get { return _content.Count; } + } + + public bool IsReadOnly { + get { return IsFrozen; } + } + + public bool Contains(object item) { + return _content.Contains(item); + } + + public void CopyTo(object[]/*!*/ array, int arrayIndex) { + _content.CopyTo(array, arrayIndex); + } + + public void Add(object item) { + Mutate(); + _content.Add(item); + } + + public void Clear() { + Mutate(); + _content.Clear(); + } + + public bool Remove(object item) { + Mutate(); + return _content.Remove(item); + } + + #endregion + + #region IEnumerable<object> Members + + public IEnumerator<object>/*!*/ GetEnumerator() { + return _content.GetEnumerator(); + } + + #endregion + + #region IEnumerable Members + + IEnumerator/*!*/ IEnumerable.GetEnumerator() { + return ((IEnumerable)_content).GetEnumerator(); + } + + #endregion + + #region IList Members + + bool IList.IsFixedSize { + get { return IsReadOnly; } + } + + void IList.Remove(object value) { + Remove(value); + } + + int IList.Add(object value) { + Mutate(); + int result = _content.Count; + _content.Add(value); + return result; + } + + #endregion + + #region ICollection Members (read-only) + + void ICollection.CopyTo(Array array, int index) { + ((ICollection)_content).CopyTo(array, index); + } + + bool ICollection.IsSynchronized { + get { return ((ICollection)_content).IsSynchronized; } + } + + object ICollection.SyncRoot { + get { return ((ICollection)_content).SyncRoot; } + } + + #endregion + + #region List specific + + // read-only // + + public int Capacity { + get { return _content.Capacity; } + // cannot remove items: + set { _content.Capacity = value; } + } + + public void CopyTo(object[]/*!*/ result) { + _content.CopyTo(result); + } + + public int FindIndex(Predicate<object> match) { + return _content.FindIndex(match); + } + +#if !SILVERLIGHT + public int FindIndex(int startIndex, Predicate<object> match) { + return _content.FindIndex(startIndex, match); + } + + public int FindIndex(int startIndex, int count, Predicate<object> match) { + return _content.FindIndex(startIndex, count, match); + } +#endif + public int BinarySearch(object item) { + return _content.BinarySearch(item); + } + + public int BinarySearch(object item, IComparer<object> comparer) { + return _content.BinarySearch(item, comparer); + } + + public int BinarySearch(int index, int count, object item, IComparer<object> comparer) { + return _content.BinarySearch(index, count, item, comparer); + } + + // mutating // + + public void Reverse() { + Mutate(); + _content.Reverse(); + } + public RubyArray/*!*/ AddMultiple(int count, object value) { + Mutate(); + _content.Capacity += count; for (int i = 0; i < count; i++) { - Add(value); + _content.Add(value); } return this; } public RubyArray/*!*/ AddRange(IList/*!*/ items) { - Capacity += items.Count; - for (int i = 0; i < items.Count; i++) { - Add(items[i]); + Mutate(); + + // items could be equal to this => we need to capture the count before we iterate: + int count = items.Count; + + _content.Capacity += count; + for (int i = 0; i < count; i++) { + _content.Add(items[i]); } return this; } public RubyArray/*!*/ AddRange(IEnumerable/*!*/ items) { + Mutate(); foreach (var item in items) { - Add(item); + _content.Add(item); } return this; } + public void InsertRange(int index, IEnumerable<object>/*!*/ collection) { + Mutate(); + _content.InsertRange(index, collection); + } + + public void RemoveRange(int index, int count) { + Mutate(); + _content.RemoveRange(index, count); + } + + public void Sort() { + Mutate(); + _content.Sort(); + } + + public void Sort(Comparison<object>/*!*/ comparison) { + Mutate(); + _content.Sort(comparison); + } + + #endregion + #region DebugView internal string/*!*/ GetDebugView() { Merlin/Main/Languages/Ruby/Ruby/Builtins/RubyArray.cs @@ -205,29 +205,18 @@ namespace IronRuby.Builtins { throw RubyExceptions.CreateNameError(String.Format("no member `{0}' in struct", name)); } - public override int GetHashCode() { + public int GetHashCode(UnaryOpStorage/*!*/ hashStorage, ConversionStorage<int>/*!*/ fixnumCast) { // hash is: struct's hash, plus data hashes - int hash = StructInfo.GetHashCode(); - foreach (object obj in _data) { - hash ^= RubyUtils.GetHashCode(obj); - } - return hash; + return StructInfo.GetHashCode() ^ RubyArray.GetHashCode(hashStorage, fixnumCast, _data); } - public override bool Equals(object obj) { + public bool Equals(BinaryOpStorage/*!*/ eqlStorage, object obj) { var other = obj as RubyStruct; if (!StructReferenceEquals(other)) { return false; } - Debug.Assert(_data.Length == other._data.Length); - for (int i = 0; i < _data.Length; i++) { - if (!RubyUtils.ValueEquals(_data[i], other._data[i])) { - return false; - } - } - - return true; + return RubyArray.Equals(eqlStorage, _data, other._data); } public bool StructReferenceEquals(RubyStruct other) { Merlin/Main/Languages/Ruby/Ruby/Builtins/RubyStruct.cs @@ -20,7 +20,7 @@ using System.Diagnostics; namespace IronRuby.Builtins { #if GENERATOR - Stateless = ['Hash', 'MatchData', 'Proc', 'Range', 'RubyRegex'] + Stateless = ['MatchData', 'Proc', 'Range', 'RubyRegex'] def generate Stateless.each do |cls| @@ -33,8 +33,8 @@ namespace IronRuby.Builtins { @class end #else - public partial class /*$Class{*/RubyArray/*}*/ { - public sealed partial class Subclass : /*$Class{*/RubyArray/*}*/, IRubyObject { + public partial class /*$Class{*/Hash/*}*/ { + public sealed partial class Subclass : /*$Class{*/Hash/*}*/, IRubyObject { private RubyInstanceData _instanceData; private RubyClass/*!*/ _immediateClass; @@ -82,8 +82,8 @@ namespace IronRuby.Builtins { } #endif #region Generated by Subclasses.Generator.rb - public partial class Hash { - public sealed partial class Subclass : Hash, IRubyObject { + public partial class MatchData { + public sealed partial class Subclass : MatchData, IRubyObject { private RubyInstanceData _instanceData; private RubyClass/*!*/ _immediateClass; @@ -129,8 +129,8 @@ namespace IronRuby.Builtins { } } } - public partial class MatchData { - public sealed partial class Subclass : MatchData, IRubyObject { + public partial class Proc { + public sealed partial class Subclass : Proc, IRubyObject { private RubyInstanceData _instanceData; private RubyClass/*!*/ _immediateClass; @@ -176,8 +176,8 @@ namespace IronRuby.Builtins { } } } - public partial class Proc { - public sealed partial class Subclass : Proc, IRubyObject { + public partial class Range { + public sealed partial class Subclass : Range, IRubyObject { private RubyInstanceData _instanceData; private RubyClass/*!*/ _immediateClass; @@ -223,8 +223,8 @@ namespace IronRuby.Builtins { } } } - public partial class Range { - public sealed partial class Subclass : Range, IRubyObject { + public partial class RubyRegex { + public sealed partial class Subclass : RubyRegex, IRubyObject { private RubyInstanceData _instanceData; private RubyClass/*!*/ _immediateClass; @@ -270,8 +270,24 @@ namespace IronRuby.Builtins { } } } - public partial class RubyRegex { - public sealed partial class Subclass : RubyRegex, IRubyObject { +#endregion + +#if GENERATOR + Stateful = ['RubyArray'] + + def generate + Stateful.each do |cls| + @class = cls + super + end + end + + def Class *a + @class + end +#else + public partial class /*$Class{*/MutableString/*}*/ { + public sealed partial class Subclass : /*$Class{*/MutableString/*}*/, IRubyObject { private RubyInstanceData _instanceData; private RubyClass/*!*/ _immediateClass; @@ -295,19 +311,6 @@ namespace IronRuby.Builtins { return _instanceData; } - public bool IsFrozen { - get { return _instanceData != null && _instanceData.Frozen; } - } - - public bool IsTainted { - get { return _instanceData != null && _instanceData.Tainted; } - set { GetInstanceData().Tainted = value; } - } - - public void Freeze() { - GetInstanceData().Freeze(); - } - public int BaseGetHashCode() { return base.GetHashCode(); } @@ -317,14 +320,24 @@ namespace IronRuby.Builtins { } } } -#endregion - - public partial class MutableString { - public sealed partial class Subclass : MutableString, IRubyObject { +#endif +#region Generated by Subclasses.Generator.rb + public partial class RubyArray { + public sealed partial class Subclass : RubyArray, IRubyObject { private RubyInstanceData _instanceData; - + private RubyClass/*!*/ _immediateClass; + [Emitted] - public RubyClass/*!*/ ImmediateClass { get; set; } + public RubyClass/*!*/ ImmediateClass { + get { + return _immediateClass; + } + set { + // once a singleton immediate class is set it can't be changed: + Debug.Assert((_immediateClass == null || !_immediateClass.IsSingletonClass) && value != null); + _immediateClass = value; + } + } public RubyInstanceData/*!*/ GetInstanceData() { return RubyOps.GetInstanceData(ref _instanceData); @@ -343,4 +356,5 @@ namespace IronRuby.Builtins { } } } +#endregion } Merlin/Main/Languages/Ruby/Ruby/Builtins/Subclasses.Generated.cs @@ -733,13 +733,10 @@ namespace IronRuby.Runtime { [Emitted] public static IList/*!*/ SplatAppend(IList/*!*/ array, object splattee) { - IEnumerable<object> objList; - IEnumerable iList; + IList list; - if ((objList = splattee as IEnumerable<object>) != null) { - array.AddRange(objList); - } else if ((iList = splattee as IEnumerable) != null) { - array.AddRange(iList); + if ((list = splattee as IList) != null) { + Utils.AddRange(array, list); } else { array.Add(splattee); } Merlin/Main/Languages/Ruby/Ruby/Runtime/RubyOps.cs @@ -41,16 +41,6 @@ namespace IronRuby.Runtime { public static readonly int TrueObjectId = 2; public static readonly int NilObjectId = 4; - // TODO: this is not correct, because it won't call singleton "eql?" methods - public static bool ValueEquals(object self, object other) { - return object.Equals(self, other); - } - - // TODO: this is not correct, because it won't call singleton "hash" methods - public static int GetHashCode(object self) { - return self != null ? self.GetHashCode() : RubyUtils.NilObjectId; - } - /// <summary> /// Determines whether the given object is a value type in Ruby (i.e. they have value equality) /// @@ -121,7 +111,7 @@ namespace IronRuby.Runtime { } } - public static MutableString/*!*/ FormatObjectPrefix(string/*!*/ className, int objectId, bool isTainted) { + public static MutableString/*!*/ FormatObjectPrefix(string/*!*/ className, long objectId, bool isTainted) { MutableString str = MutableString.CreateMutable(); str.Append("#<"); str.Append(className); @@ -134,7 +124,7 @@ namespace IronRuby.Runtime { return str; } - public static MutableString/*!*/ FormatObject(string/*!*/ className, int objectId, bool isTainted) { + public static MutableString/*!*/ FormatObject(string/*!*/ className, long objectId, bool isTainted) { return FormatObjectPrefix(className, objectId, isTainted).Append(">"); } @@ -146,7 +136,7 @@ namespace IronRuby.Runtime { return FormatObjectPrefix(context.GetClassDisplayName(obj), GetObjectId(context, obj), context.IsObjectTainted(obj)); } - public static MutableString/*!*/ AppendFormatHexObjectId(MutableString/*!*/ str, int objectId) { + public static MutableString/*!*/ AppendFormatHexObjectId(MutableString/*!*/ str, long objectId) { return str.AppendFormat("0x{0:x7}", 2 * objectId); } @@ -183,11 +173,11 @@ namespace IronRuby.Runtime { return true; } - public static int GetFixnumId(int number) { - return number * 2 + 1; + public static long GetFixnumId(int number) { + return ((long)number << 1) + 1; } - public static int GetObjectId(RubyContext/*!*/ context, object obj) { + public static long GetObjectId(RubyContext/*!*/ context, object obj) { if (obj == null) return NilObjectId; if (obj is bool) return (bool)obj ? TrueObjectId : FalseObjectId; if (obj is int) return GetFixnumId((int)obj); Merlin/Main/Languages/Ruby/Ruby/Runtime/RubyUtils.cs @@ -20,6 +20,7 @@ using System.Text; using System.Reflection; using System.Collections; using System.Collections.Generic; +using IronRuby.Builtins; namespace IronRuby.Runtime { public static class Utils { @@ -132,12 +133,6 @@ namespace IronRuby.Runtime { } } - private static void Copy(string/*!*/ src, int srcOffset, char[]/*!*/ dst, int dstOffset, int count) { - for (int i = 0; i < count; i++) { - dst[dstOffset + i] = src[srcOffset + i]; - } - } - internal static int Append<T>(ref T[]/*!*/ array, int itemCount, T item, int repeatCount) { Resize(ref array, itemCount + repeatCount); Fill(array, itemCount, item, repeatCount); @@ -147,7 +142,7 @@ namespace IronRuby.Runtime { internal static int Append(ref char[]/*!*/ array, int itemCount, string/*!*/ other, int start, int count) { int newCount = itemCount + count; Resize(ref array, newCount); - Copy(other, start, array, itemCount, count); + other.CopyTo(start, array, itemCount, count); return newCount; } @@ -166,7 +161,7 @@ namespace IronRuby.Runtime { internal static int InsertAt(ref char[]/*!*/ array, int itemCount, int index, string/*!*/ other, int start, int count) { ResizeForInsertion(ref array, itemCount, index, count); - Copy(other, start, array, index, count); + other.CopyTo(start, array, index, count); return itemCount + count; } @@ -344,25 +339,16 @@ namespace IronRuby.Runtime { return result; } - internal static void AddRange(this IList/*!*/ list, IEnumerable<object>/*!*/ range) { - Assert.NotNull(list, range); - - List<object> objList; - if ((objList = list as List<object>) != null) { - objList.AddRange(range); - } else { - foreach (var item in range) { - list.Add(item); - } - } - } - - internal static void AddRange(this IList/*!*/ list, IEnumerable/*!*/ range) { + internal static void AddRange(IList/*!*/ list, IList/*!*/ range) { Assert.NotNull(list, range); List<object> objList; - if ((objList = list as List<object>) != null) { - objList.AddRange(range); + IEnumerable<object> enumerableRange; + RubyArray array; + if ((array = list as RubyArray) != null) { + array.AddRange(range); + } else if ((objList = list as List<object>) != null && (enumerableRange = range as IEnumerable<object>) != null) { + objList.AddRange(enumerableRange); } else { foreach (var item in range) { list.Add(item); Merlin/Main/Languages/Ruby/Ruby/Runtime/Utils.cs @@ -19,6 +19,7 @@ class IRTest :RubySpec_C => "#{mspec_base} :core2 :lib2", :RubyGems => "#{ir} #{@root}\\Languages\\Ruby\\Tests\\Scripts\\RubyGemsTests.rb", :Rake => "#{ir} #{@root}\\Languages\\Ruby\\Tests\\Scripts\\RakeTests.rb", + :Yaml => "#{ir} #{@root}\\..\\External.LCA_RESTRICTED\\Languages\\IronRuby\\yaml\\YamlTest\\yaml_test_suite.rb" } end Merlin/Main/Languages/Ruby/Scripts/irtests.rb @@ -1,6 +1,6 @@ require "rubygems" -rake_tests_dir = File.expand_path("../External.LCA_RESTRICTED/Languages/Ruby/RakeTests", ENV["MERLIN_ROOT"]) +rake_tests_dir = File.expand_path("../External.LCA_RESTRICTED/Languages/IronRuby/RakeTests", ENV["MERLIN_ROOT"]) all_test_files = Dir.glob("#{rake_tests_dir}/test/test*.rb") + Dir.glob("#{rake_tests_dir}/test/contrib/test*.rb") + Dir.glob("#{rake_tests_dir}/test/fun*.rb") # Do some sanity checks abort("Did not find enough Rake tests files...") unless all_test_files.size > 25 Merlin/Main/Languages/Ruby/Tests/Scripts/RakeTests.rb @@ -52,8 +52,8 @@ namespace :test do IRTest.test(:Legacy) end - desc "Run app specific tests (Rubygems and Rake)" - task :apps => [:gems, :rake] + desc "Run app specific tests (Rubygems, Rake and YAML)" + task :apps => [:gems, :rake, :yaml] desc "Run rake tests" task :rake => :happy do @@ -65,6 +65,11 @@ namespace :test do IRTest.test(:RubyGems) end + desc "Run Yaml tests" + task :yaml => :happy do + IRTest.test(:Yaml) + end + desc "(NOT IMPLEMENTED) Run tests corresponding to samples" task :samples => :happy do Merlin/Main/Languages/Ruby/rake/test.rake @@ -95,6 +95,7 @@ namespace Microsoft.Scripting.Generation { return Expression.Lambda<T>( body, node.Name + "$" + Interlocked.Increment(ref _uniqueNameId), + node.TailCall, node.Parameters ); Merlin/Main/Runtime/Microsoft.Scripting/Generation/ToDiskRewriter.cs @@ -90,7 +90,7 @@ namespace Microsoft.Scripting.Interpreter { if (b == node.Body) { return node; } - return Expression.Lambda<T>(b, node.Name, node.Parameters); + return Expression.Lambda<T>(b, node.Name, node.TailCall, node.Parameters); } protected override Expression VisitBlock(BlockExpression node) { Merlin/Main/Runtime/Microsoft.Scripting/Interpreter/LightLambdaClosureVisitor.cs @@ -93,17 +93,26 @@ namespace Microsoft.Scripting.Utils { /// <summary> /// Requires the range [offset, offset + count] to be a subset of [0, array.Count]. /// </summary> - /// <exception cref="ArgumentNullException">Array is <c>null</c>.</exception> /// <exception cref="ArgumentOutOfRangeException">Offset or count are out of range.</exception> public static void RequiresArrayRange<T>(IList<T> array, int offset, int count, string offsetName, string countName) { + Assert.NotNull(array); + RequiresArrayRange(array.Count, offset, count, offsetName, countName); + } + + /// <summary> + /// Requires the range [offset, offset + count] to be a subset of [0, array.Count]. + /// </summary> + /// <exception cref="ArgumentOutOfRangeException">Offset or count are out of range.</exception> + public static void RequiresArrayRange(int arraySize, int offset, int count, string offsetName, string countName) { Assert.NotEmpty(offsetName); Assert.NotEmpty(countName); - Assert.NotNull(array); + Debug.Assert(arraySize >= 0); if (count < 0) throw new ArgumentOutOfRangeException(countName); - if (offset < 0 || array.Count - offset < count) throw new ArgumentOutOfRangeException(offsetName); + if (offset < 0 || arraySize - offset < count) throw new ArgumentOutOfRangeException(offsetName); } + /// <summary> /// Requires the range [offset, offset + count] to be a subset of [0, array.Count]. /// </summary> Merlin/Main/Runtime/Microsoft.Scripting/Utils/ContractUtils.cs @@ -21,8 +21,6 @@ using System.Dynamic.Utils; using System.Linq.Expressions; using System.Linq.Expressions.Compiler; using System.Reflection; -using System.Threading; -using System.Collections; namespace System.Runtime.CompilerServices { @@ -433,10 +431,7 @@ namespace System.Runtime.CompilerServices { ); } - Expression getRule = Expression.Assign( - rule, - Expression.ArrayAccess(applicable, index) - ); + Expression getRule = Expression.Assign(rule, Expression.ArrayAccess(applicable, index)); var @break = Expression.Label(); @@ -486,8 +481,12 @@ namespace System.Runtime.CompilerServices { //// //// Level 2 cache lookup //// - // i = 0; - // var cache = @this.Binder.GetRuleCache<%(funcType)s>(); + // + //// + //// Any applicable rules in level 2 cache? + //// + // + // var cache = CallSiteOps.GetRuleCache(@this); var cache = Expression.Variable(typeof(RuleCache<T>), "cache"); vars.Add(cache); @@ -499,38 +498,17 @@ namespace System.Runtime.CompilerServices { ) ); - body.Add( - Expression.Assign( - index, - Expression.Constant(0) - ) - ); - - //// - //// Any applicable rules in level 2 cache? - //// - // foreach (var cachedRule in CallSiteOps.GetCachedRules<%(funcType)s>(cache)) { - - ParameterExpression enumerator = Expression.Parameter(typeof(IEnumerator<>).MakeGenericType(typeArgs), "enum"); - vars.Add(enumerator); + // applicable = cache.GetRules(); body.Add( Expression.Assign( - enumerator, - Expression.Call( - Expression.Call( - typeof(CallSiteOps), - "GetCachedRules", - typeArgs, - cache - ), - typeof(IEnumerable<>).MakeGenericType(typeArgs).GetMethod("GetEnumerator") - ) + applicable, + Expression.Call(typeof(CallSiteOps), "GetCachedRules", typeArgs, cache) ) ); - - // @this.Target = rule; + // for (int i = 0, count = applicable.Length; i < count; i++) { + // @this.Target = rule = applicable[i]; // // // // // Execute the rule @@ -589,28 +567,13 @@ namespace System.Runtime.CompilerServices { ) ); - body.Add( - Expression.Assign(index, Expression.Constant(0)) - ); - - breakIfDone = Expression.IfThen( - Expression.Not( - Expression.Call( - enumerator, - typeof(IEnumerator).GetMethod("MoveNext") - ) - ), - Expression.Break(@break) - ); - getRule = Expression.Assign( - rule, - Expression.Assign( - Expression.Field(@this, "Target"), - Expression.Property(enumerator, "Current") - ) + Expression.Field(@this, "Target"), + Expression.Assign(rule, Expression.ArrayAccess(applicable, index)) ); + body.Add(Expression.Assign(index, Expression.Constant(0))); + body.Add(Expression.Assign(count, Expression.ArrayLength(applicable))); body.Add( Expression.Loop( Expression.Block( @@ -729,10 +692,5 @@ namespace System.Runtime.CompilerServices { } return Expression.Convert(arg, type); } - - [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic")] - internal CallSiteRule<T> MakeRule(T target) { - return new CallSiteRule<T>(null, target); - } } } ndp/fx/src/Core/Microsoft/Scripting/Actions/CallSite.cs @@ -20,6 +20,7 @@ using System.Dynamic; using System.Dynamic.Utils; using System.Linq.Expressions; using System.Threading; +using System.Reflection; namespace System.Runtime.CompilerServices { /// <summary> @@ -49,6 +50,34 @@ namespace System.Runtime.CompilerServices { get { return _updateLabel; } } + private sealed class LambdaSignature<T> where T : class { + internal static readonly LambdaSignature<T> Instance = new LambdaSignature<T>(); + + internal readonly ReadOnlyCollection<ParameterExpression> Parameters; + internal readonly LabelTarget ReturnLabel; + + private LambdaSignature() { + Type target = typeof(T); + if (!typeof(Delegate).IsAssignableFrom(target)) { + throw Error.TypeParameterIsNotDelegate(target); + } + + MethodInfo invoke = target.GetMethod("Invoke"); + ParameterInfo[] pis = invoke.GetParametersCached(); + if (pis[0].ParameterType != typeof(CallSite)) { + throw Error.FirstArgumentMustBeCallSite(); + } + + var @params = new ParameterExpression[pis.Length - 1]; + for (int i = 0; i < @params.Length; i++) { + @params[i] = Expression.Parameter(pis[i + 1].ParameterType, "$arg" + i); + } + + Parameters = new TrueReadOnlyCollection<ParameterExpression>(@params); + ReturnLabel = Expression.Label(invoke.GetReturnType()); + } + } + /// <summary> /// Performs the runtime binding of the dynamic operation on a set of arguments. /// </summary> @@ -89,7 +118,8 @@ namespace System.Runtime.CompilerServices { // // Get the Expression for the binding // - Expression binding = Bind(args, CallSiteRule<T>.Parameters, CallSiteRule<T>.ReturnLabel); + var signature = LambdaSignature<T>.Instance; + Expression binding = Bind(args, signature.Parameters, signature.ReturnLabel); // // Check the produced rule @@ -99,37 +129,21 @@ namespace System.Runtime.CompilerServices { } // - // see if we have an old rule to template off - // - T oldTarget = site.Target; - - RuleCache<T> cache = GetRuleCache<T>(); - CallSiteRule<T> newRule = null; - foreach (CallSiteRule<T> cachedRule in cache.GetRules()) { - if ((object)cachedRule.Target == (object)oldTarget) { - newRule = AutoRuleTemplate.CopyOrCreateTemplatedRule(cachedRule, binding); - break; - } - } - - // // finally produce the new rule if we need to // - if (newRule == null) { #if !MICROSOFT_SCRIPTING_CORE - // We cannot compile rules in the heterogeneous app domains since they - // may come from less trusted sources - if (!AppDomain.CurrentDomain.IsHomogenous) { - throw Error.HomogenousAppDomainRequired(); - } -#endif - Expression<T> e = Stitch<T>(binding); - newRule = new CallSiteRule<T>(binding, e.Compile()); + // We cannot compile rules in the heterogeneous app domains since they + // may come from less trusted sources + if (!AppDomain.CurrentDomain.IsHomogenous) { + throw Error.HomogenousAppDomainRequired(); } +#endif + Expression<T> e = Stitch(binding, signature); + T newRule = e.Compile(); - cache.AddRule(newRule); + CacheTarget(newRule); - return newRule.Target; + return newRule; } /// <summary> @@ -139,10 +153,10 @@ namespace System.Runtime.CompilerServices { /// <typeparam name="T">The type of target being added.</typeparam> /// <param name="target">The target delegate to be added to the cache.</param> protected void CacheTarget<T>(T target) where T : class { - GetRuleCache<T>().AddRule(new CallSiteRule<T>(null, target)); + GetRuleCache<T>().AddRule(target); } - internal static Expression<T> Stitch<T>(Expression binding) where T : class { + private static Expression<T> Stitch<T>(Expression binding, LambdaSignature<T> signature) where T : class { Type targetType = typeof(T); Type siteType = typeof(CallSite<T>); @@ -150,7 +164,7 @@ namespace System.Runtime.CompilerServices { body.Add(binding); var site = Expression.Parameter(typeof(CallSite), "$site"); - var @params = CallSiteRule<T>.Parameters.AddFirst(site); + var @params = signature.Parameters.AddFirst(site); Expression updLabel = Expression.Label(CallSiteBinder.UpdateLabel); @@ -165,13 +179,13 @@ namespace System.Runtime.CompilerServices { body.Add(updLabel); body.Add( Expression.Label( - CallSiteRule<T>.ReturnLabel, + signature.ReturnLabel, Expression.Condition( Expression.Call( typeof(CallSiteOps).GetMethod("SetNotMatched"), @params.First() ), - Expression.Default(CallSiteRule<T>.ReturnLabel.Type), + Expression.Default(signature.ReturnLabel.Type), Expression.Invoke( Expression.Property( Expression.Convert(site, siteType), ndp/fx/src/Core/Microsoft/Scripting/Actions/CallSiteBinder.cs @@ -142,10 +142,8 @@ namespace System.Runtime.CompilerServices { /// <param name="cache">The cache.</param> /// <returns>The collection of applicable rules.</returns> [Obsolete("do not use this method", true), EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable<T> GetCachedRules<T>(RuleCache<T> cache) where T : class { - foreach (CallSiteRule<T> rule in cache.GetRules()) { - yield return rule.Target; - } + public static T[] GetCachedRules<T>(RuleCache<T> cache) where T : class { + return cache.GetRules(); } /// <summary> ndp/fx/src/Core/Microsoft/Scripting/Actions/CallSiteOps.cs @@ -16,9 +16,8 @@ using System.ComponentModel; using System.Diagnostics; using System.Dynamic.Utils; -using System.Runtime.CompilerServices; -namespace System.Dynamic { +namespace System.Runtime.CompilerServices { /// <summary> /// This API supports the .NET Framework infrastructure and is not intended to be used directly from your code. /// Represents a cache of runtime binding rules. @@ -26,14 +25,14 @@ namespace System.Dynamic { /// <typeparam name="T">The delegate type.</typeparam> [EditorBrowsable(EditorBrowsableState.Never), DebuggerStepThrough] public class RuleCache<T> where T : class { - private CallSiteRule<T>[] _rules = new CallSiteRule<T>[0]; + private T[] _rules = new T[0]; private readonly Object cacheLock = new Object(); private const int MaxRules = 128; internal RuleCache() { } - internal CallSiteRule<T>[] GetRules() { + internal T[] GetRules() { return _rules; } @@ -53,7 +52,7 @@ namespace System.Dynamic { int oldIndex = -1; int max = Math.Min(_rules.Length, i + count); for (int index = i; index < max; index++) { - if (_rules[index].Target == rule) { + if (_rules[index] == rule) { oldIndex = index; break; } @@ -61,21 +60,21 @@ namespace System.Dynamic { if (oldIndex < 0) { return; } - CallSiteRule<T> oldRule = _rules[oldIndex]; + T oldRule = _rules[oldIndex]; _rules[oldIndex] = _rules[oldIndex - 1]; _rules[oldIndex - 1] = _rules[oldIndex - 2]; _rules[oldIndex - 2] = oldRule; } } - internal void AddRule(CallSiteRule<T> newRule) { + internal void AddRule(T newRule) { // need a lock to make sure we are not loosing rules. lock (cacheLock) { _rules = AddOrInsert(_rules, newRule); } } - internal void ReplaceRule(CallSiteRule<T> oldRule, CallSiteRule<T> newRule) { + internal void ReplaceRule(T oldRule, T newRule) { // need a lock to make sure we are replacing the right rule lock (cacheLock) { int i = Array.IndexOf(_rules, oldRule); @@ -93,19 +92,19 @@ namespace System.Dynamic { // Adds to end or or inserts items at InsertPosition private const int InsertPosition = MaxRules / 2; - private static CallSiteRule<T>[] AddOrInsert(CallSiteRule<T>[] rules, CallSiteRule<T> item) { + private static T[] AddOrInsert(T[] rules, T item) { if (rules.Length < InsertPosition) { return rules.AddLast(item); } - CallSiteRule<T>[] newRules; + T[] newRules; int newLength = rules.Length + 1; if (newLength > MaxRules) { newLength = MaxRules; newRules = rules; } else { - newRules = new CallSiteRule<T>[newLength]; + newRules = new T[newLength]; } Array.Copy(rules, 0, newRules, 0, InsertPosition); ndp/fx/src/Core/Microsoft/Scripting/Actions/RuleCache.cs @@ -1,4 +1,4 @@ -/* **************************************************************************** +/* **************************************************************************** * * Copyright (c) Microsoft Corporation. * @@ -86,9 +86,9 @@ namespace System.Dynamic { var cache = CallSiteOps.GetRuleCache(@this); - var cachedRules = cache.GetRules(); - for (int i = 0; i < cachedRules.Length; i++) { - rule = cachedRules[i].Target; + applicable = cache.GetRules(); + for (int i = 0; i < applicable.Length; i++) { + rule = applicable[i]; // // Execute the rule @@ -211,9 +211,9 @@ namespace System.Dynamic { var cache = CallSiteOps.GetRuleCache(@this); - var cachedRules = cache.GetRules(); - for (int i = 0; i < cachedRules.Length; i++) { - rule = cachedRules[i].Target; + applicable = cache.GetRules(); + for (int i = 0; i < applicable.Length; i++) { + rule = applicable[i]; // // Execute the rule @@ -336,9 +336,9 @@ namespace System.Dynamic { var cache = CallSiteOps.GetRuleCache(@this); - var cachedRules = cache.GetRules(); - for (int i = 0; i < cachedRules.Length; i++) { - rule = cachedRules[i].Target; + applicable = cache.GetRules(); + for (int i = 0; i < applicable.Length; i++) { + rule = applicable[i]; // // Execute the rule @@ -461,9 +461,9 @@ namespace System.Dynamic { var cache = CallSiteOps.GetRuleCache(@this); - var cachedRules = cache.GetRules(); - for (int i = 0; i < cachedRules.Length; i++) { - rule = cachedRules[i].Target; + applicable = cache.GetRules(); + for (int i = 0; i < applicable.Length; i++) { + rule = applicable[i]; // // Execute the rule @@ -586,9 +586,9 @@ namespace System.Dynamic { var cache = CallSiteOps.GetRuleCache(@this); - var cachedRules = cache.GetRules(); - for (int i = 0; i < cachedRules.Length; i++) { - rule = cachedRules[i].Target; + applicable = cache.GetRules(); + for (int i = 0; i < applicable.Length; i++) { + rule = applicable[i]; // // Execute the rule @@ -711,9 +711,9 @@ namespace System.Dynamic { var cache = CallSiteOps.GetRuleCache(@this); - var cachedRules = cache.GetRules(); - for (int i = 0; i < cachedRules.Length; i++) { - rule = cachedRules[i].Target; + applicable = cache.GetRules(); + for (int i = 0; i < applicable.Length; i++) { + rule = applicable[i]; // // Execute the rule @@ -836,9 +836,9 @@ namespace System.Dynamic { var cache = CallSiteOps.GetRuleCache(@this); - var cachedRules = cache.GetRules(); - for (int i = 0; i < cachedRules.Length; i++) { - rule = cachedRules[i].Target; + applicable = cache.GetRules(); + for (int i = 0; i < applicable.Length; i++) { + rule = applicable[i]; // // Execute the rule @@ -961,9 +961,9 @@ namespace System.Dynamic { var cache = CallSiteOps.GetRuleCache(@this); - var cachedRules = cache.GetRules(); - for (int i = 0; i < cachedRules.Length; i++) { - rule = cachedRules[i].Target; + applicable = cache.GetRules(); + for (int i = 0; i < applicable.Length; i++) { + rule = applicable[i]; // // Execute the rule @@ -1086,9 +1086,9 @@ namespace System.Dynamic { var cache = CallSiteOps.GetRuleCache(@this); - var cachedRules = cache.GetRules(); - for (int i = 0; i < cachedRules.Length; i++) { - rule = cachedRules[i].Target; + applicable = cache.GetRules(); + for (int i = 0; i < applicable.Length; i++) { + rule = applicable[i]; // // Execute the rule @@ -1211,9 +1211,9 @@ namespace System.Dynamic { var cache = CallSiteOps.GetRuleCache(@this); - var cachedRules = cache.GetRules(); - for (int i = 0; i < cachedRules.Length; i++) { - rule = cachedRules[i].Target; + applicable = cache.GetRules(); + for (int i = 0; i < applicable.Length; i++) { + rule = applicable[i]; // // Execute the rule @@ -1336,9 +1336,9 @@ namespace System.Dynamic { var cache = CallSiteOps.GetRuleCache(@this); - var cachedRules = cache.GetRules(); - for (int i = 0; i < cachedRules.Length; i++) { - rule = cachedRules[i].Target; + applicable = cache.GetRules(); + for (int i = 0; i < applicable.Length; i++) { + rule = applicable[i]; // // Execute the rule @@ -1460,9 +1460,9 @@ namespace System.Dynamic { var cache = CallSiteOps.GetRuleCache(@this); - var cachedRules = cache.GetRules(); - for (int i = 0; i < cachedRules.Length; i++) { - rule = cachedRules[i].Target; + applicable = cache.GetRules(); + for (int i = 0; i < applicable.Length; i++) { + rule = applicable[i]; // // Execute the rule @@ -1584,9 +1584,9 @@ namespace System.Dynamic { var cache = CallSiteOps.GetRuleCache(@this); - var cachedRules = cache.GetRules(); - for (int i = 0; i < cachedRules.Length; i++) { - rule = cachedRules[i].Target; + applicable = cache.GetRules(); + for (int i = 0; i < applicable.Length; i++) { + rule = applicable[i]; // // Execute the rule @@ -1708,9 +1708,9 @@ namespace System.Dynamic { var cache = CallSiteOps.GetRuleCache(@this); - var cachedRules = cache.GetRules(); - for (int i = 0; i < cachedRules.Length; i++) { - rule = cachedRules[i].Target; + applicable = cache.GetRules(); + for (int i = 0; i < applicable.Length; i++) { + rule = applicable[i]; // // Execute the rule @@ -1832,9 +1832,9 @@ namespace System.Dynamic { var cache = CallSiteOps.GetRuleCache(@this); - var cachedRules = cache.GetRules(); - for (int i = 0; i < cachedRules.Length; i++) { - rule = cachedRules[i].Target; + applicable = cache.GetRules(); + for (int i = 0; i < applicable.Length; i++) { + rule = applicable[i]; // // Execute the rule @@ -1956,9 +1956,9 @@ namespace System.Dynamic { var cache = CallSiteOps.GetRuleCache(@this); - var cachedRules = cache.GetRules(); - for (int i = 0; i < cachedRules.Length; i++) { - rule = cachedRules[i].Target; + applicable = cache.GetRules(); + for (int i = 0; i < applicable.Length; i++) { + rule = applicable[i]; // // Execute the rule @@ -2080,9 +2080,9 @@ namespace System.Dynamic { var cache = CallSiteOps.GetRuleCache(@this); - var cachedRules = cache.GetRules(); - for (int i = 0; i < cachedRules.Length; i++) { - rule = cachedRules[i].Target; + applicable = cache.GetRules(); + for (int i = 0; i < applicable.Length; i++) { + rule = applicable[i]; // // Execute the rule @@ -2204,9 +2204,9 @@ namespace System.Dynamic { var cache = CallSiteOps.GetRuleCache(@this); - var cachedRules = cache.GetRules(); - for (int i = 0; i < cachedRules.Length; i++) { - rule = cachedRules[i].Target; + applicable = cache.GetRules(); + for (int i = 0; i < applicable.Length; i++) { + rule = applicable[i]; // // Execute the rule @@ -2328,9 +2328,9 @@ namespace System.Dynamic { var cache = CallSiteOps.GetRuleCache(@this); - var cachedRules = cache.GetRules(); - for (int i = 0; i < cachedRules.Length; i++) { - rule = cachedRules[i].Target; + applicable = cache.GetRules(); + for (int i = 0; i < applicable.Length; i++) { + rule = applicable[i]; // // Execute the rule @@ -2452,9 +2452,9 @@ namespace System.Dynamic { var cache = CallSiteOps.GetRuleCache(@this); - var cachedRules = cache.GetRules(); - for (int i = 0; i < cachedRules.Length; i++) { - rule = cachedRules[i].Target; + applicable = cache.GetRules(); + for (int i = 0; i < applicable.Length; i++) { + rule = applicable[i]; // // Execute the rule @@ -2576,9 +2576,9 @@ namespace System.Dynamic { var cache = CallSiteOps.GetRuleCache(@this); - var cachedRules = cache.GetRules(); - for (int i = 0; i < cachedRules.Length; i++) { - rule = cachedRules[i].Target; + applicable = cache.GetRules(); + for (int i = 0; i < applicable.Length; i++) { + rule = applicable[i]; // // Execute the rule ndp/fx/src/Core/Microsoft/Scripting/Actions/UpdateDelegates.Generated.cs @@ -384,7 +384,7 @@ namespace System.Linq.Expressions { if (b == node.Body && p == node.Parameters) { return node; } - return Expression.Lambda<T>(b, node.Name, p); + return Expression.Lambda<T>(b, node.Name, node.TailCall, p); } /// <summary> ndp/fx/src/Core/Microsoft/Scripting/Ast/ExpressionVisitor.cs @@ -525,6 +525,22 @@ namespace System.Linq.Expressions { } } + private static bool ValidateTryGetFuncActionArgs(Type[] typeArgs) { + if (typeArgs == null) { + throw new ArgumentNullException("typeArgs"); + } + for (int i = 0, n = typeArgs.Length; i < n; i++) { + var a = typeArgs[i]; + if (a == null) { + throw new ArgumentNullException("typeArgs"); + } + if (a.IsByRef) { + return false; + } + } + return true; + } + /// <summary> /// Creates a <see cref="Type"/> object that represents a generic System.Func delegate type that has specific type arguments. /// The last type argument specifies the return type of the created delegate. @@ -532,8 +548,8 @@ namespace System.Linq.Expressions { /// <param name="typeArgs">An array of Type objects that specify the type arguments for the System.Func delegate type.</param> /// <returns>The type of a System.Func delegate that has the specified type arguments.</returns> public static Type GetFuncType(params Type[] typeArgs) { - ContractUtils.RequiresNotNull(typeArgs, "typeArgs"); - ContractUtils.RequiresNotNullItems(typeArgs, "typeArgs"); + ContractUtils.Requires(ValidateTryGetFuncActionArgs(typeArgs), "typeArgs", Strings.TypeMustNotBeByRef); + Type result = DelegateHelpers.GetFuncType(typeArgs); if (result == null) { throw Error.IncorrectNumberOfTypeArgsForFunc(); @@ -549,11 +565,11 @@ namespace System.Linq.Expressions { /// <param name="funcType">When this method returns, contains the generic System.Func delegate type that has specific type arguments. Contains null if there is no generic System.Func delegate that matches the <paramref name="typeArgs"/>.This parameter is passed uninitialized.</param> /// <returns>true if generic System.Func delegate type was created for specific <paramref name="typeArgs"/>; false otherwise.</returns> public static bool TryGetFuncType(Type[] typeArgs, out Type funcType) { - ContractUtils.RequiresNotNull(typeArgs, "typeArgs"); - ContractUtils.RequiresNotNullItems(typeArgs, "typeArgs"); - Type result; - funcType = result = DelegateHelpers.GetFuncType(typeArgs); - return result != null; + if (ValidateTryGetFuncActionArgs(typeArgs)) { + return (funcType = DelegateHelpers.GetFuncType(typeArgs)) != null; + } + funcType = null; + return false; } /// <summary> @@ -562,8 +578,8 @@ namespace System.Linq.Expressions { /// <param name="typeArgs">An array of Type objects that specify the type arguments for the System.Action delegate type.</param> /// <returns>The type of a System.Action delegate that has the specified type arguments.</returns> public static Type GetActionType(params Type[] typeArgs) { - ContractUtils.RequiresNotNull(typeArgs, "typeArgs"); - ContractUtils.RequiresNotNullItems(typeArgs, "typeArgs"); + ContractUtils.Requires(ValidateTryGetFuncActionArgs(typeArgs), "typeArgs", Strings.TypeMustNotBeByRef); + Type result = DelegateHelpers.GetActionType(typeArgs); if (result == null) { throw Error.IncorrectNumberOfTypeArgsForAction(); @@ -578,11 +594,11 @@ namespace System.Linq.Expressions { /// <param name="actionType">When this method returns, contains the generic System.Action delegate type that has specific type arguments. Contains null if there is no generic System.Action delegate that matches the <paramref name="typeArgs"/>.This parameter is passed uninitialized.</param> /// <returns>true if generic System.Action delegate type was created for specific <paramref name="typeArgs"/>; false otherwise.</returns> public static bool TryGetActionType(Type[] typeArgs, out Type actionType) { - ContractUtils.RequiresNotNull(typeArgs, "typeArgs"); - ContractUtils.RequiresNotNullItems(typeArgs, "typeArgs"); - Type result; - actionType = result = DelegateHelpers.GetActionType(typeArgs); - return result != null; + if (ValidateTryGetFuncActionArgs(typeArgs)) { + return (actionType = DelegateHelpers.GetActionType(typeArgs)) != null; + } + actionType = null; + return false; } /// <summary> ndp/fx/src/Core/Microsoft/Scripting/Ast/LambdaExpression.cs @@ -75,7 +75,7 @@ namespace System.Runtime.CompilerServices { if (b == node.Body) { return node; } - return Expression.Lambda<T>(b, node.Name, node.Parameters); + return Expression.Lambda<T>(b, node.Name, node.TailCall, node.Parameters); } protected internal override Expression VisitBlock(BlockExpression node) { ndp/fx/src/Core/Microsoft/Scripting/Compiler/ExpressionQuoter.cs @@ -114,7 +114,6 @@ <Compile Include="Actions\BinaryOperationBinder.cs" /> <Compile Include="Actions\CallSite.cs" /> <Compile Include="Actions\CallSiteBinder.cs" /> - <Compile Include="Actions\CallSiteRule.cs" /> <Compile Include="Actions\CallSiteHelpers.cs" /> <Compile Include="Actions\ConvertBinder.cs" /> <Compile Include="Actions\DeleteIndexBinder.cs" /> @@ -150,7 +149,6 @@ <Compile Include="Compiler\RuntimeVariableList.cs" /> <Compile Include="Actions\UpdateDelegates.Generated.cs" /> <Compile Include="Ast\DynamicExpression.cs" /> - <Compile Include="Actions\AutoRuleTemplate.cs" /> <Compile Include="Ast\BinaryExpression.cs" /> <Compile Include="Ast\BlockExpression.cs" /> <Compile Include="Ast\CatchBlock.cs" /> @@ -180,7 +178,6 @@ <Compile Include="Ast\ParameterExpression.cs" /> <Compile Include="Ast\SwitchCase.cs" /> <Compile Include="Ast\SwitchExpression.cs" /> - <Compile Include="Ast\TreeComparer.cs" /> <Compile Include="Ast\TryExpression.cs" /> <Compile Include="Ast\TypeBinaryExpression.cs" /> <Compile Include="Ast\TypeUtils.cs" /> ndp/fx/src/Core/Microsoft/Scripting/Microsoft.Scripting.Core.csproj Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/README Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/Rakefile Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/bin/rake Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/install.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/capture_stdout.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/check_expansion.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/contrib/test_sys.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/data/chains/.cvsignore Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/data/chains/Rakefile Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/data/default/Rakefile Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/data/dryrun/.cvsignore Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/data/dryrun/Rakefile Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/data/file_creation_task/.cvsignore Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/data/file_creation_task/.gitignore Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/data/file_creation_task/Rakefile Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/data/imports/.cvsignore Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/data/imports/Rakefile Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/data/imports/deps.mf Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/data/imports/static_deps Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/data/multidesc/Rakefile Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/data/namespace/Rakefile Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/data/nosearch/dummy Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/data/rakelib/test1.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/data/rakelib/test2.rake Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/data/rbext/rakefile.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/data/sample.mf Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/data/statusreturn/Rakefile Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/data/sys/sys1.rake Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/data/unittest/Rakefile Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/data/unittest/subdir/README Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/filecreation.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/functional.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/in_environment.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/rake_test_setup.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/reqfile.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/reqfile2.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/reqfile3.rake Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/session_functional.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/shellcommand.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/test_application.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/test_clean.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/test_definitions.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/test_earlytime.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/test_extension.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/test_file_creation_task.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/test_file_task.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/test_filelist.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/test_fileutils.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/test_ftp.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/test_invocation_chain.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/test_makefile_loader.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/test_multitask.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/test_namespace.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/test_package_task.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/test_pathmap.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/test_rake.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/test_rdoc_task.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/test_require.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/test_rules.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/test_task_arguments.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/test_task_manager.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/test_tasklib.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/test_tasks.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/test_test_task.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/test_top_level_functions.rb Merlin/External.LCA_RESTRICTED/Languages/Ruby/RakeTests/test/test_win32.rb ndp/fx/src/Core/Microsoft/Scripting/Actions/AutoRuleTemplate.cs ndp/fx/src/Core/Microsoft/Scripting/Actions/CallSiteRule.cs ndp/fx/src/Core/Microsoft/Scripting/Ast/TreeComparer.cs 33211840f7482ffaa4970a6e630725fad2a70f5d Jim Deville jdeville@microsoft.com http://github.com/ironruby/ironruby/commit/483c07b24e02bc67425a697f5fd686ef7825da12 483c07b24e02bc67425a697f5fd686ef7825da12 2009-06-24T19:46:59-07:00 2009-06-24T16:21:07-07:00 syncing to head of tfs dfec6ffc44b47247129d9953c602961b10d34018 Jim Deville jdeville@microsoft.com