Merlin/Main/Languages/Ruby/Licenses/CHANGELOG.txt Merlin/Main/Languages/Ruby/Licenses/LICENSE.CPL.txt Merlin/Main/Languages/Ruby/Licenses/LICENSE.MSPL.html Merlin/Main/Languages/Ruby/Licenses/LICENSE.Ruby.txt Merlin/Main/Languages/Ruby/Licenses/README.txt Merlin/Main/Languages/Ruby/Ruby/Runtime/Conversions/CompositeConversionAction.cs Merlin/Main/Languages/Ruby/Ruby/Runtime/Conversions/ConvertToSAction.cs Merlin/Main/Languages/Ruby/Ruby/Runtime/Conversions/Converter.Generated.cs Merlin/Main/Languages/Ruby/Ruby/Runtime/Conversions/Converter.Generator.rb Merlin/Main/Languages/Ruby/Ruby/Runtime/Conversions/Converter.cs Merlin/Main/Languages/Ruby/Ruby/Runtime/Conversions/GenericConversionAction.cs Merlin/Main/Languages/Ruby/Ruby/Runtime/Conversions/ProtocolConversionAction.cs Merlin/Main/Languages/Ruby/Ruby/Runtime/RubyOps.FlowControl.cs Merlin/Main/Languages/Ruby/Ruby4.sln Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/flagenumeration/and_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/flagenumeration/complement_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/flagenumeration/or_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/flagenumeration/xor_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/float/abs_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/float/ceil_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/float/coerce_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/float/comparison_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/float/divide_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/float/divmod_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/float/equal_value_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/float/exponent_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/float/finite_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/float/floor_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/float/gt_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/float/gte_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/float/hash_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/float/induced_from_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/float/infinite_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/float/lt_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/float/lte_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/float/minus_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/float/modulo_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/float/multiply_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/float/nan_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/float/plus_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/float/round_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/float/to_f_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/float/to_i_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/float/to_int_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/float/to_s_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/float/truncate_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/float/zero_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/integer/abs_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/integer/and_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/integer/append_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/integer/comparison_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/integer/complement_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/integer/div_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/integer/divide_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/integer/divmod_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/integer/element_reference_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/integer/equal_value_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/integer/exponent_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/integer/gt_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/integer/gte_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/integer/lt_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/integer/lte_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/integer/minus_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/integer/modulo_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/integer/multiply_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/integer/or_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/integer/plus_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/integer/quo_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/integer/right_shift_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/integer/to_f_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/integer/to_s_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/integer/uminus_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/integer/xor_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/integer/zero_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/multidimensionalarray/element_reference_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/multidimensionalarray/element_set_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/name/ActualName_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/name/Equals_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/name/GetHashCode_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/name/HasMangledName_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/name/MangledName_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/name/clr_name_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/name/clr_to_ruby_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/name/comparison_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/name/dump_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/name/equal_value_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/name/inspect_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/name/mangle_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/name/ruby_name_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/name/ruby_to_clr_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/name/to_s_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/name/to_str_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/name/to_sym_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/name/unmangle_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/profile_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/scope/Clear_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/scope/ContainsName_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/scope/ContainsVariable_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/scope/Dict_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/scope/GetAllItems_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/scope/GetAllKeys_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/scope/GetExtension_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/scope/GetVariable_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/scope/IsVisible_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/scope/Items_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/scope/Keys_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/scope/Parent_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/scope/SetExtension_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/scope/SetName_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/scope/SetObjectName_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/scope/SetVariable_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/scope/TryGetName_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/scope/TryGetObjectName_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/scope/TryGetVariable_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/scope/TryRemoveObjectName_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/scope/TryRemoveVariable_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/string/case_compare_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/string/comparison_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/string/dump_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/string/empty_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/string/encoding_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/string/equal_value_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/string/hex_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/string/inspect_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/string/intern_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/string/modulo_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/string/multiply_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/string/oct_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/string/plus_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/string/size_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/string/to_clr_string_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/string/to_f_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/string/to_i_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/string/to_s_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/string/to_str_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/clr/string/to_sym_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/configuration_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/create_engine_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/create_ruby_setup_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/create_runtime_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/get_engine_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/get_execution_context_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/globals_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/load_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/loaded_assemblies_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/loaded_scripts_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/require_file_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/IronRuby/require_spec.rb Merlin/Main/Languages/Ruby/Tests/Interop/net/method/invocation/internal_spec.rb Merlin/Main/Runtime/Microsoft.Scripting/Runtime/IConvertibleMetaObject.cs @@ -33,6 +33,17 @@ describe "Kernel.rand" do (rand(100) < 100).should == true end end + + it "returns different values each time" do + result = false + 5.times do + #this tests for caching the callsite when on the same line. Repeated 5 + #times for the random chance that the two numbers are equal + a = [rand(100), rand(100)] + result |= (a[0] != a[1]) + end + result.should == true + end end describe "Kernel#rand" do Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/rubyspec/core/kernel/rand_spec.rb @@ -1,9 +1,9 @@ <?xml version="1.0" encoding="utf-8"?> -<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> +<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> <PropertyGroup> <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> - <ProductVersion>9.0.30729</ProductVersion> + <ProductVersion>10.0.20624</ProductVersion> <SchemaVersion>2.0</SchemaVersion> <ProjectGuid>{ED82A346-1CD9-4CB0-9C00-4CDD4CF577CF}</ProjectGuid> <OutputType>Library</OutputType> @@ -140,4 +140,4 @@ <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" Condition=" '$(SilverlightTreeBuild)' != 'true' " /> <Import Project="..\..\silverlight.build.targets" Condition=" '$(SilverlightTreeBuild)' == 'true' " /> <Import Condition=" '$(Golden)' == 'True'" Project="..\..\External\Build\Microsoft.VersionNumber.targets" /> -</Project> +</Project> \ No newline at end of file Merlin/Main/Debugging/Microsoft.Scripting.Debugging/Microsoft.Scripting.Debugging.csproj @@ -1,9 +1,9 @@ <?xml version="1.0" encoding="utf-8"?> -<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> +<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> <PropertyGroup> <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> - <ProductVersion>9.0.30729</ProductVersion> + <ProductVersion>10.0.20624</ProductVersion> <SchemaVersion>2.0</SchemaVersion> <ProjectGuid>{7D07B0CE-FFA3-4402-BFF2-5F42B4267D2A}</ProjectGuid> <OutputType>Exe</OutputType> @@ -23,6 +23,7 @@ <SignedDir Condition="'$(SignAssembly)' == 'true'">Signed</SignedDir> <SignedDir Condition="$(SignAssembly) != true">Unsigned</SignedDir> <DelaySign>true</DelaySign> + <TargetFrameworkVersion>v3.5</TargetFrameworkVersion> </PropertyGroup> <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> <DebugSymbols>true</DebugSymbols> Merlin/Main/Hosts/SilverLight/Chiron/Chiron.csproj @@ -1,8 +1,9 @@ -<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="3.5"> +<?xml version="1.0" encoding="utf-8"?> +<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0"> <PropertyGroup> <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> - <ProductVersion>9.0.21022</ProductVersion> + <ProductVersion>10.0.20624</ProductVersion> <SchemaVersion>2.0</SchemaVersion> <ProjectGuid>{C86A7A7B-3086-4136-9B56-17E8DCB38C8D}</ProjectGuid> <OutputType>Library</OutputType> @@ -19,6 +20,7 @@ <DelaySign>true</DelaySign> <SilverlightBuild>true</SilverlightBuild> <SilverlightPath Condition="$(SilverlightPath) == ''">..\..\..\Utilities\Silverlight\x86ret\</SilverlightPath> + <TargetFrameworkVersion>v2.0</TargetFrameworkVersion> </PropertyGroup> <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Silverlight Debug|AnyCPU' "> <DebugSymbols>true</DebugSymbols> @@ -127,4 +129,4 @@ <PostBuildEvent> </PostBuildEvent> </PropertyGroup> -</Project> +</Project> \ No newline at end of file Merlin/Main/Hosts/SilverLight/Microsoft.Scripting.SilverLight/Microsoft.Scripting.Silverlight.csproj @@ -1,8 +1,9 @@ -<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="3.5"> +<?xml version="1.0" encoding="utf-8"?> +<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0"> <PropertyGroup> <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> - <ProductVersion>9.0.30729</ProductVersion> + <ProductVersion>10.0.20624</ProductVersion> <SchemaVersion>2.0</SchemaVersion> <ProjectGuid>{155CE436-1669-4A48-8095-410F2430237F}</ProjectGuid> <OutputType>Library</OutputType> @@ -13,7 +14,6 @@ <SccLocalPath>SAK</SccLocalPath> <SccAuxPath>SAK</SccAuxPath> <SccProvider>SAK</SccProvider> - <OldToolsVersion>2.0</OldToolsVersion> <WarningsNotAsErrors>618,1685</WarningsNotAsErrors> <AssemblyOriginatorKeyFile>..\..\..\Support\MSSharedLibKey.snk</AssemblyOriginatorKeyFile> <SignAssembly Condition="'$(SignAssembly)' == '' And Exists('$(AssemblyOriginatorKeyFile)')">true</SignAssembly> @@ -21,6 +21,7 @@ <DelaySign>true</DelaySign> <SilverlightPath Condition="'$(SilverlightPath)' == ''">..\..\..\Utilities\Silverlight\x86ret\</SilverlightPath> <BaseAddress>885063680</BaseAddress> + <TargetFrameworkVersion>v2.0</TargetFrameworkVersion> </PropertyGroup> <PropertyGroup Condition=" '$(Configuration)' == 'Debug' "> <DebugSymbols>true</DebugSymbols> Merlin/Main/Languages/IronPython/IronPython.Modules/IronPython.Modules.csproj @@ -1,8 +1,9 @@ -<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="3.5"> +<?xml version="1.0" encoding="utf-8"?> +<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0"> <PropertyGroup> <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> - <ProductVersion>9.0.30729</ProductVersion> + <ProductVersion>10.0.20624</ProductVersion> <SchemaVersion>2.0</SchemaVersion> <ProjectGuid>{95289EA9-5778-489D-AB48-F81F2CE2DA32}</ProjectGuid> <OutputType>Library</OutputType> @@ -13,7 +14,6 @@ <SccLocalPath>SAK</SccLocalPath> <SccAuxPath>SAK</SccAuxPath> <SccProvider>SAK</SccProvider> - <OldToolsVersion>2.0</OldToolsVersion> <TreatWarningsAsErrors>true</TreatWarningsAsErrors> <WarningsNotAsErrors>618,1685</WarningsNotAsErrors> <AssemblyOriginatorKeyFile>..\..\..\Support\MSSharedLibKey.snk</AssemblyOriginatorKeyFile> @@ -22,6 +22,7 @@ <DelaySign>true</DelaySign> <SilverlightPath Condition="$(SilverlightPath) == ''">..\..\..\Utilities\Silverlight\x86ret\</SilverlightPath> <BaseAddress>879755264</BaseAddress> + <TargetFrameworkVersion>v2.0</TargetFrameworkVersion> </PropertyGroup> <PropertyGroup Condition=" '$(Configuration)' == 'Debug' "> <DebugSymbols>true</DebugSymbols> Merlin/Main/Languages/IronPython/IronPython/IronPython.csproj @@ -34,7 +34,7 @@ namespace IronPython.Runtime.Binding { using Ast = System.Linq.Expressions.Expression; using AstUtils = Microsoft.Scripting.Ast.Utils; - class MetaPythonFunction : MetaPythonObject, IPythonInvokable, IPythonOperable, IPythonConvertible, IInferableInvokable { + class MetaPythonFunction : MetaPythonObject, IPythonInvokable, IPythonOperable, IPythonConvertible, IInferableInvokable, IConvertibleMetaObject { public MetaPythonFunction(Expression/*!*/ expression, BindingRestrictions/*!*/ restrictions, PythonFunction/*!*/ value) : base(expression, BindingRestrictions.Empty, value) { Assert.NotNull(value); @@ -930,5 +930,13 @@ namespace IronPython.Runtime.Binding { } #endregion + + #region IConvertibleMetaObject Members + + bool IConvertibleMetaObject.CanConvertTo(Type/*!*/ type, bool @explicit) { + return type.IsSubclassOf(typeof(Delegate)); + } + + #endregion } } Merlin/Main/Languages/IronPython/IronPython/Runtime/Binding/MetaPythonFunction.cs @@ -75,7 +75,7 @@ namespace IronPython.Runtime.Binding { } } - public override bool CanConvertFrom(Type fromType, ParameterWrapper toParameter, NarrowingLevel level) { + public override bool CanConvertFrom(Type fromType, DynamicMetaObject fromArg, ParameterWrapper toParameter, NarrowingLevel level) { if ((fromType == typeof(List) || fromType.IsSubclassOf(typeof(List)))) { if (toParameter.Type.IsGenericType && toParameter.Type.GetGenericTypeDefinition() == typeof(IList<>) && @@ -98,7 +98,7 @@ namespace IronPython.Runtime.Binding { } } - return base.CanConvertFrom(fromType, toParameter, level); + return base.CanConvertFrom(fromType, fromArg, toParameter, level); } protected override BitArray MapSpecialParameters(ParameterMapping/*!*/ mapping) { Merlin/Main/Languages/IronPython/IronPython/Runtime/Binding/PythonOverloadResolver.cs @@ -60,11 +60,6 @@ internal sealed class PythonConsoleHost : ConsoleHost { Environment.SetEnvironmentVariable("TERM", "dumb"); } - if (typeof(DynamicMethod).GetConstructor(new Type[] { typeof(string), typeof(Type), typeof(Type[]), typeof(bool) }) == null) { - Console.WriteLine("IronPython requires .NET 2.0 SP1 or later to run."); - Environment.Exit(1); - } - return new PythonConsoleHost().Run(args); } } \ No newline at end of file Merlin/Main/Languages/IronPython/IronPythonConsole/Console.cs @@ -1,8 +1,9 @@ -<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="3.5"> +<?xml version="1.0" encoding="utf-8"?> +<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0"> <PropertyGroup> <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> - <ProductVersion>9.0.30729</ProductVersion> + <ProductVersion>10.0.20624</ProductVersion> <SchemaVersion>2.0</SchemaVersion> <ProjectGuid>{811AC32C-11F3-4ED8-92A7-A7E39C2BB704}</ProjectGuid> <OutputType>Exe</OutputType> @@ -14,7 +15,6 @@ <SccAuxPath>SAK</SccAuxPath> <SccProvider>SAK</SccProvider> <ApplicationIcon>ipy.ico</ApplicationIcon> - <OldToolsVersion>2.0</OldToolsVersion> <WarningsNotAsErrors>618,1685</WarningsNotAsErrors> <AssemblyOriginatorKeyFile>..\..\..\Support\MSSharedLibKey.snk</AssemblyOriginatorKeyFile> <SignAssembly Condition="'$(SignAssembly)' == '' And Exists('$(AssemblyOriginatorKeyFile)')">true</SignAssembly> @@ -23,6 +23,7 @@ <SignedDir Condition="$(SignAssembly) != true">Unsigned</SignedDir> <DelaySign>true</DelaySign> <PlatformTarget>x86</PlatformTarget> + <TargetFrameworkVersion>v2.0</TargetFrameworkVersion> </PropertyGroup> <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> <DebugSymbols>true</DebugSymbols> Merlin/Main/Languages/IronPython/IronPythonConsole/IronPythonConsole.csproj @@ -1,8 +1,9 @@ -<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="3.5"> +<?xml version="1.0" encoding="utf-8"?> +<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0"> <PropertyGroup> <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> - <ProductVersion>9.0.30729</ProductVersion> + <ProductVersion>10.0.20624</ProductVersion> <SchemaVersion>2.0</SchemaVersion> <ProjectGuid>{F1D861C5-D9D5-4CDA-968B-8275F5D9F6D2}</ProjectGuid> <OutputType>Exe</OutputType> @@ -14,7 +15,6 @@ <SccAuxPath>SAK</SccAuxPath> <SccProvider>SAK</SccProvider> <ApplicationIcon>..\IronPythonConsole\ipy.ico</ApplicationIcon> - <OldToolsVersion>2.0</OldToolsVersion> <WarningsNotAsErrors>618,1685</WarningsNotAsErrors> <AssemblyOriginatorKeyFile>..\..\..\Support\MSSharedLibKey.snk</AssemblyOriginatorKeyFile> <SignAssembly Condition="'$(SignAssembly)' == '' And Exists('$(AssemblyOriginatorKeyFile)')">true</SignAssembly> @@ -22,6 +22,7 @@ <SignedDir Condition="'$(SignAssembly)' == 'true'">Signed</SignedDir> <SignedDir Condition="$(SignAssembly) != true">Unsigned</SignedDir> <DelaySign>true</DelaySign> + <TargetFrameworkVersion>v2.0</TargetFrameworkVersion> </PropertyGroup> <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> <DebugSymbols>true</DebugSymbols> Merlin/Main/Languages/IronPython/IronPythonConsoleAny/IronPythonConsoleAny.csproj @@ -252,6 +252,12 @@ namespace IronPythonTest.BinderTest { // generics public void M130(Int32 arg) { Flag.Value = 130; } public void M130<T>(T arg) { Flag.Value = 230; } + + // narrowing levels and __int__ conversion: + // If 2 instances of a Python subclass of C3 that implements __int__ are passed as arguments this + // the first overload should be preferred. + public void M140(C3 a, int b) { Flag.Value = 140; } + public void M140(int a, int b) { Flag.Value = 240; } } public interface I1 { void M(); } Merlin/Main/Languages/IronPython/IronPythonTest/BinderTest.cs @@ -1,8 +1,9 @@ -<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="3.5"> +<?xml version="1.0" encoding="utf-8"?> +<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0"> <PropertyGroup> <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> - <ProductVersion>9.0.30729</ProductVersion> + <ProductVersion>10.0.20624</ProductVersion> <SchemaVersion>2.0</SchemaVersion> <ProjectGuid>{B6B42537-07F8-4F6C-A99A-B155CAEB124E}</ProjectGuid> <OutputType>Library</OutputType> @@ -16,12 +17,12 @@ <StartupObject> </StartupObject> <WarningsNotAsErrors>618,1685</WarningsNotAsErrors> - <OldToolsVersion>2.0</OldToolsVersion> <AssemblyOriginatorKeyFile>..\..\..\Support\MSSharedLibKey.snk</AssemblyOriginatorKeyFile> <SignAssembly Condition="'$(SignAssembly)' == '' And Exists('$(AssemblyOriginatorKeyFile)')">true</SignAssembly> <SignedSym Condition="'$(SignAssembly)' == 'true'">SIGNED</SignedSym> <DelaySign>true</DelaySign> <SilverlightPath Condition="'$(SilverlightPath)' == ''">..\..\..\Utilities\Silverlight\x86ret\</SilverlightPath> + <TargetFrameworkVersion>v2.0</TargetFrameworkVersion> </PropertyGroup> <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> <DebugSymbols>true</DebugSymbols> Merlin/Main/Languages/IronPython/IronPythonTest/IronPythonTest.csproj @@ -1,8 +1,9 @@ -<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="3.5"> +<?xml version="1.0" encoding="utf-8"?> +<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0"> <PropertyGroup> <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> - <ProductVersion>9.0.30729</ProductVersion> + <ProductVersion>10.0.20624</ProductVersion> <SchemaVersion>2.0</SchemaVersion> <ProjectGuid>{81DA19C7-4FEC-47E7-981B-D9310D549F95}</ProjectGuid> <OutputType>WinExe</OutputType> @@ -16,7 +17,7 @@ <SccAuxPath>SAK</SccAuxPath> <SccProvider>SAK</SccProvider> <ApplicationIcon>ipy.ico</ApplicationIcon> - <OldToolsVersion>2.0</OldToolsVersion> + <TargetFrameworkVersion>v2.0</TargetFrameworkVersion> <PublishUrl>publish\</PublishUrl> <Install>true</Install> <InstallFrom>Disk</InstallFrom> Merlin/Main/Languages/IronPython/IronPythonWindow/IronPythonWindow.csproj @@ -1,8 +1,8 @@ -<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="3.5"> +<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0"> <PropertyGroup> <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> - <ProductVersion>9.0.30729</ProductVersion> + <ProductVersion>10.0.20624</ProductVersion> <SchemaVersion>2.0</SchemaVersion> <ProjectGuid>{7F6F9AB3-9943-4316-BD4C-A10F580BC75C}</ProjectGuid> <OutputType>WinExe</OutputType> @@ -16,7 +16,7 @@ <SccAuxPath>SAK</SccAuxPath> <SccProvider>SAK</SccProvider> <ApplicationIcon>..\IronPythonWindow\ipy.ico</ApplicationIcon> - <OldToolsVersion>2.0</OldToolsVersion> + <TargetFrameworkVersion>v2.0</TargetFrameworkVersion> <PublishUrl>publish\</PublishUrl> <Install>true</Install> <InstallFrom>Disk</InstallFrom> Merlin/Main/Languages/IronPython/IronPythonWindowAny/IronPythonWindowAny.csproj @@ -1,8 +1,9 @@ -<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="3.5"> +<?xml version="1.0" encoding="utf-8"?> +<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0"> <PropertyGroup> <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> - <ProductVersion>9.0.30718</ProductVersion> + <ProductVersion>10.0.20624</ProductVersion> <SchemaVersion>2.0</SchemaVersion> <ProjectGuid>{166940A1-2C91-4BD0-B72B-A517FBD8BF0B}</ProjectGuid> <OutputType>Exe</OutputType> @@ -13,12 +14,12 @@ <SccLocalPath>SAK</SccLocalPath> <SccAuxPath>SAK</SccAuxPath> <SccProvider>SAK</SccProvider> - <OldToolsVersion>2.0</OldToolsVersion> <WarningLevel>4</WarningLevel> <AssemblyOriginatorKeyFile>..\..\..\Support\MSSharedLibKey.snk</AssemblyOriginatorKeyFile> <SignAssembly Condition="'$(SignAssembly)' == '' And Exists('$(AssemblyOriginatorKeyFile)')">true</SignAssembly> <SignedSym Condition="'$(SignAssembly)' == 'true'">SIGNED</SignedSym> <DelaySign>true</DelaySign> + <TargetFrameworkVersion>v2.0</TargetFrameworkVersion> </PropertyGroup> <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> <DebugSymbols>true</DebugSymbols> @@ -69,4 +70,4 @@ <Target Name="AfterBuild"> </Target> --> -</Project> +</Project> \ No newline at end of file Merlin/Main/Languages/Ruby/ClassInitGenerator/ClassInitGenerator.csproj @@ -140,6 +140,10 @@ internal class LibraryDef { public IDictionary<string, HiddenMethod>/*!*/ HiddenInstanceMethods = new SortedDictionary<string, HiddenMethod>(); public IDictionary<string, HiddenMethod>/*!*/ HiddenClassMethods = new SortedDictionary<string, HiddenMethod>(); + // { new_name -> old_name } + public IDictionary<string, string>/*!*/ ClassMethodAliases = new SortedDictionary<string, string>(); + public IDictionary<string, string>/*!*/ InstanceMethodAliases = new SortedDictionary<string, string>(); + public List<MethodInfo>/*!*/ Factories = new List<MethodInfo>(); public List<MixinRef>/*!*/ Mixins = new List<MixinRef>(); @@ -206,7 +210,10 @@ internal class LibraryDef { } public bool HasInstanceInitializer { - get { return InstanceMethods.Count > 0 || HiddenInstanceMethods.Count > 0 || HasCopyInclusions || IsPrimitive; } + get { + return InstanceMethods.Count > 0 || HiddenInstanceMethods.Count > 0 || InstanceMethodAliases.Count > 0 + || HasCopyInclusions || IsPrimitive; + } } public bool HasConstantsInitializer { @@ -214,7 +221,10 @@ internal class LibraryDef { } public bool HasClassInitializer { - get { return ClassMethods.Count > 0 || HiddenClassMethods.Count > 0 || HasCopyInclusions || IsPrimitive; } + get { + return ClassMethods.Count > 0 || HiddenClassMethods.Count > 0 || ClassMethodAliases.Count > 0 + || HasCopyInclusions || IsPrimitive; + } } public const string/*!*/ ObjectClassRef = "Context.ObjectClass"; @@ -396,21 +406,35 @@ internal class LibraryDef { // hidden CLR methods: foreach (HideMethodAttribute method in trait.GetCustomAttributes(typeof(HideMethodAttribute), false)) { - // TODO: warning, method already removed, method not found ... - if (method.IsStatic) { - def.HiddenClassMethods[method.Name] = HiddenMethod.ClrInvisible; + var dict = (method.IsStatic) ? def.HiddenClassMethods : def.HiddenInstanceMethods; + if (dict.ContainsKey(method.Name)) { + LogError("Method {0} is already hidden/removed", method.Name); } else { - def.HiddenInstanceMethods[method.Name] = HiddenMethod.ClrInvisible; + dict.Add(method.Name, HiddenMethod.ClrInvisible); } } // undefined methods: foreach (UndefineMethodAttribute method in trait.GetCustomAttributes(typeof(UndefineMethodAttribute), false)) { - // TODO: warning, method already removed, method not found ... - if (method.IsStatic) { - def.HiddenClassMethods[method.Name] = HiddenMethod.Undefined; + var dict = (method.IsStatic) ? def.HiddenClassMethods : def.HiddenInstanceMethods; + if (dict.ContainsKey(method.Name)) { + LogError("Method {0} is already hidden/removed", method.Name); + } else { + dict.Add(method.Name, HiddenMethod.Undefined); + } + } + + // aliased methods: + foreach (AliasMethodAttribute method in trait.GetCustomAttributes(typeof(AliasMethodAttribute), false)) { + var aliasDict = (method.IsStatic) ? def.ClassMethodAliases : def.InstanceMethodAliases; + var hiddenDict = (method.IsStatic) ? def.HiddenClassMethods : def.HiddenInstanceMethods; + + if (hiddenDict.ContainsKey(method.NewName)) { + LogError("Cannot alias hidden/removed method {0}", method.NewName); + } else if (aliasDict.ContainsKey(method.NewName)) { + LogError("Duplicate method alias {0} {1}", method.NewName, method.OldName); } else { - def.HiddenInstanceMethods[method.Name] = HiddenMethod.Undefined; + aliasDict.Add(method.NewName, method.OldName); } } } @@ -421,6 +445,10 @@ internal class LibraryDef { // declaring modules, build configurations: foreach (ModuleDef def in _moduleDefs.Values) { if (!def.IsExtension) { + if (def.Extends.IsGenericTypeDefinition) { + LogError("Only extension modules or classes can be generic type definitions '{0}'", def.QualifiedName); + } + // finds the inner most Ruby module def containing this module def: ModuleDef declaringDef = GetDeclaringModuleDef(def); if (declaringDef != null) { @@ -497,6 +525,10 @@ internal class LibraryDef { } else if (!mixin.Copy) { // define a module ref-variable for the type of the mixin: mixin.Module.RefName = MakeModuleReference(mixin.Module.Type); + } else { + LogError("Cannot copy-include a mixin not defined in this library ('{0}' includes '{1}')", + def.QualifiedName, mixin.Module.Type + ); } } } @@ -1102,6 +1134,7 @@ internal class LibraryDef { GenerateIncludedTraitLoaders(moduleDef, isInstance); GenerateHiddenMethods(isInstance ? moduleDef.HiddenInstanceMethods : moduleDef.HiddenClassMethods); GenerateMethods(moduleDef.Trait, isInstance ? moduleDef.InstanceMethods : moduleDef.ClassMethods); + GenerateMethodAliases(isInstance ? moduleDef.InstanceMethodAliases : moduleDef.ClassMethodAliases); _output.Indent--; _output.WriteLine("}"); @@ -1177,6 +1210,12 @@ internal class LibraryDef { } } + private void GenerateMethodAliases(IDictionary<string, string>/*!*/ aliases) { + foreach (var alias in aliases) { + _output.WriteLine("module.AddMethodAlias(\"{0}\", \"{1}\");", alias.Key, alias.Value); + } + } + private void GenerateMethods(Type/*!*/ type, IDictionary<string, MethodDef>/*!*/ methods) { foreach (MethodDef def in methods.Values) { if (def.BuildConfig != null) { Merlin/Main/Languages/Ruby/ClassInitGenerator/Libraries/LibraryDef.cs @@ -1,8 +1,9 @@ -<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="3.5"> +<?xml version="1.0" encoding="utf-8"?> +<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0"> <PropertyGroup> <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> - <ProductVersion>9.0.30729</ProductVersion> + <ProductVersion>10.0.20624</ProductVersion> <SchemaVersion>2.0</SchemaVersion> <ProjectGuid>{D6AB587D-A888-4B98-85AC-F15E36F53838}</ProjectGuid> <OutputType>Exe</OutputType> @@ -22,6 +23,7 @@ <SignedDir Condition="$(SignAssembly) != true">Unsigned</SignedDir> <DelaySign>true</DelaySign> <PlatformTarget>x86</PlatformTarget> + <TargetFrameworkVersion>v2.0</TargetFrameworkVersion> </PropertyGroup> <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> <DebugSymbols>true</DebugSymbols> Merlin/Main/Languages/Ruby/Console/Ruby.Console.csproj @@ -1,8 +1,8 @@ -<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="3.5"> +<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0"> <PropertyGroup> <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> - <ProductVersion>9.0.30729</ProductVersion> + <ProductVersion>10.0.20624</ProductVersion> <SchemaVersion>2.0</SchemaVersion> <ProjectGuid>{6EE7A428-D803-41BC-8248-1297C3ACE369}</ProjectGuid> <OutputType>Exe</OutputType> @@ -21,6 +21,7 @@ <SignedDir Condition="'$(SignAssembly)' == 'true'">Signed</SignedDir> <SignedDir Condition="$(SignAssembly) != true">Unsigned</SignedDir> <DelaySign>true</DelaySign> + <TargetFrameworkVersion>v2.0</TargetFrameworkVersion> </PropertyGroup> <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> <DebugSymbols>true</DebugSymbols> Merlin/Main/Languages/Ruby/Console/Ruby.ConsoleAny.csproj @@ -1,8 +1,9 @@ -<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="3.5"> +<?xml version="1.0" encoding="utf-8"?> +<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0"> <PropertyGroup> <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> - <ProductVersion>9.0.21022</ProductVersion> + <ProductVersion>10.0.20624</ProductVersion> <SchemaVersion>2.0</SchemaVersion> <ProjectGuid>{8103D91B-89D8-4A18-9A40-426992602EA2}</ProjectGuid> <OutputType>Exe</OutputType> @@ -23,6 +24,7 @@ <SignedDir Condition="'$(SignAssembly)' == 'true'">Signed</SignedDir> <SignedDir Condition="$(SignAssembly) != true">Unsigned</SignedDir> <DelaySign>true</DelaySign> + <TargetFrameworkVersion>v2.0</TargetFrameworkVersion> </PropertyGroup> <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> <DebugSymbols>true</DebugSymbols> Merlin/Main/Languages/Ruby/IronRuby.Tests/IronRuby.Tests.csproj @@ -51,7 +51,8 @@ namespace IronRuby.Tests { OverloadResolution_Block1, OverloadResolution_ParamArrays1, - AmbiguousMatch, + OverloadResolution_Numeric1, + AmbiguousMatch1, Interpreter1, Interpreter2, Interpreter3, @@ -406,6 +407,7 @@ namespace IronRuby.Tests { ClrConstructor4, ClrPrimitiveNumericTypes1, ClrArrays1, + ClrArrays2, ClrChar1, ClrOperators1, ClrOperators2, @@ -617,7 +619,6 @@ namespace IronRuby.Tests { Dlr_Convertible, Dlr_Indexable, Dlr_Number, - Dlr_Enumerable, Dlr_Comparable, Dlr_RubyObjects, Dlr_Methods, Merlin/Main/Languages/Ruby/IronRuby.Tests/RubyTests.cs @@ -1251,6 +1251,47 @@ p C[Fixnum, Fixnum] InteropTests::Generics1::D[String] InteropTests::Generics1::C[Fixnum, Fixnum] "); + + TestOutput(@" +include InteropTests::Generics1 +p C[0] +p C[1] +p C[2] +C[30] rescue p $! +p C[1][Fixnum] +p C[Fixnum][] +p C[Fixnum][0] +C[Fixnum][Fixnum] rescue p $! +C[Fixnum][1] rescue p $! +", @" +InteropTests::Generics1::C +InteropTests::Generics1::C[T] +InteropTests::Generics1::C[T, S] +#<ArgumentError: Type group `C' does not contain a type of generic arity 30> +InteropTests::Generics1::C[Fixnum] +InteropTests::Generics1::C[Fixnum] +InteropTests::Generics1::C[Fixnum] +#<ArgumentError: `InteropTests::Generics1::C[Fixnum]' is not a generic type definition> +#<ArgumentError: `InteropTests::Generics1::C[Fixnum]' is not a generic type definition> +"); + + // C<T> instantiations are subclasses of C<>: + TestOutput(@" +include InteropTests::Generics1 +C[1].class_eval do + def foo + p self.class + end +end + +C[Fixnum].new.foo +C[String].new.foo +p C[Float].ancestors[0..2] +", @" +InteropTests::Generics1::C[Fixnum] +InteropTests::Generics1::C[String] +[InteropTests::Generics1::C[Float], InteropTests::Generics1::C[T], Object] +"); } public class ClassWithNestedGenericTypes1 { @@ -1984,16 +2025,15 @@ init /// Shelveset "Numerics-MetaOpsWithNarrowing" contains prototype implementation of the narrowing. /// </summary> public void ClrPrimitiveNumericTypes1() { - AssertOutput(delegate() { - CompilerTest(@" + TestOutput(@" [System::Byte, System::SByte, System::UInt16, System::Int16, System::UInt32, System::Int64, System::UInt64, System::Single].each_with_index do |t,i| p t.ancestors p t.new(i).class p x = t.new(i) + 1, x.class p t.new(i).size rescue puts 'no size method' end -"); - }, @" +", +@" [System::Byte, Integer, Precision, Numeric, Comparable, Object, Kernel] System::Byte 1 @@ -2039,8 +2079,7 @@ no size method public void ClrArrays1() { Context.SetGlobalConstant("A2", Context.GetClass(typeof(int[,]))); - AssertOutput(delegate() { - CompilerTest(@" + TestOutput(@" # multi-dim array: a2 = A2.new(2,4) a2[0,1] = 123 @@ -2051,11 +2090,7 @@ p System::Array[Fixnum].new(10) { |i| i + 1 } p System::Array[Fixnum].new(3) p System::Array[Fixnum].new([1,2,3]) p System::Array[Fixnum].new(3, 12) - -# TODO: conversions: -# p System::Array[System::Char].new(3, 'x') -"); - }, @" +", @" 123 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] [0, 0, 0] @@ -2063,14 +2098,41 @@ p System::Array[Fixnum].new(3, 12) [12, 12, 12] "); } - + + public void ClrArrays2() { + TestOutput(@" +class C + def to_str + 'c' + end +end + +a = System::Array[System::String].new(3) +a[0] = 'x' +a[1] = C.new +a[2] = :z + +# TODO: params array parameter of 'p' binds to the vector if passed alone +p a, + System::Array[System::String].new(3, C.new), + System::Array[System::String].new([C.new, C.new]), + System::Array[System::Byte].new(3) { |x| x }, + System::Array[System::Byte].new(3, 1) +", @" +['x', 'c', 'z'] +['c', 'c', 'c'] +['c', 'c'] +[0 (Byte), 1 (Byte), 2 (Byte)] +[1 (Byte), 1 (Byte), 1 (Byte)] +"); + } + public void ClrChar1() { - AssertOutput(delegate() { - CompilerTest(@" + TestOutput(@" p System::Char.ancestors p System::String.ancestors -a = System::Array[System::Char].new([System::Char.new('a'), System::Char.new('b')]) # TODO: implicit conversion +a = System::Array[System::Char].new(['a', 'b']) p System::Char.new(a) x = System::Char.new('foo') @@ -2079,8 +2141,7 @@ p x.index('f') p x + 'oo' p x == 'f' p System::Char.new('9').to_i -"); - }, @" +", @" [System::Char, IronRuby::Clr::String, Enumerable, Comparable, System::ValueType, Object, Kernel] [System::String, IronRuby::Clr::String, Enumerable, Comparable, Object, Kernel] 'a' @@ -2232,6 +2293,10 @@ false return d; } + public Delegate Delegate(int bogusOverload) { + return new Func<object, object>((x) => x); + } + public int Foo(int a) { return a + 1; } @@ -2240,22 +2305,10 @@ false return (int)a; } - public int FixnumDefaultProtocol([DefaultProtocol]int a) { - return a + 2; - } - public string Bool([Optional]bool a) { return a ? "T" : "F"; } - public int ListOrString(IList a) { - return a.Count; - } - - public int ListOrString([DefaultProtocol]MutableString str) { - return 0; - } - public int ListAndStrings(IList a, MutableString str1) { return a.Count + str1.GetCharCount(); } @@ -2322,16 +2375,16 @@ p Inst.Double(2.0), Inst.Double(4), Inst.Double(System::Byte.new(8)), Inst.Doubl // primitive numerics: TestOutput(@" -p Inst.numerics(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11) +p(*Inst.numerics(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)) ", @" -1 -2 -3 -4 +1 (Byte) +2 (SByte) +3 (Int16) +4 (UInt16) 5 -6 -7 -8 +6 (UInt32) +7 (Int64) +8 (UInt64) 9 (10+0j) Convertible(11) @@ -2348,13 +2401,11 @@ class C 'xxx' end end -p Inst.ListOrString(C.new) p Inst.ListAndStrings(C.new, C.new) -p Inst.FixnumDefaultProtocol(Conv) +p Inst.Foo(Conv) ", @" -0 8 -13 +12 "); // protocol conversions: @@ -2372,11 +2423,15 @@ p Inst.Foo(a) rescue p $! 101 "); // meta-object conversions: - TestOutput(@" -p Inst.delegate(Proc.new { |x| x + 1 }).invoke(123) -", @" -124 -"); + var r1 = Engine.Execute<int>("Inst.delegate(Proc.new { |x| x + 1 }).invoke(123)"); + Assert(r1 == 124); + + // foreign meta-object conversion: + var py = Runtime.GetEngine("python"); + var scope = Runtime.CreateScope(); + py.Execute(@"def foo(x): return x + 2", scope); + var r2 = Engine.Execute<int>(@"Inst.delegate(foo).invoke(123)", scope); + Assert(r2 == 125); } #endregion Merlin/Main/Languages/Ruby/IronRuby.Tests/Runtime/ClrTests.cs @@ -216,7 +216,7 @@ namespace IronRuby.Tests { } - internal static T Invoke<T>(object obj, T fallbackResult) { + internal static T Convert<T>(object obj, T fallbackResult) { var site = CallSite<Func<CallSite, object, T>>.Create(new MyConvertBinder(typeof(T), fallbackResult)); return site.Target(site, obj); } @@ -386,27 +386,6 @@ end self.misc = Miscellaneous.new #------------------------------------------------------------------------------ -class Convertible - def initialize v - @val = v - end - - def to_i - @val.to_i - end - - def to_f - @val.to_f - end - - def to_str - @val.to_str - end -end - -self.convertible = Convertible.new('0') - -#------------------------------------------------------------------------------ class Indexable def initialize a=nil if a then @@ -494,20 +473,6 @@ class Helpers end #------------------------------------------------------------------------------ -class RubyEnumerable - include Enumerable - def initialize a - @array = a - end - - def each - @array.each {|elem| yield elem } - end -end - -self.ruby_enumerable = RubyEnumerable.new([1,2,3]) - -#------------------------------------------------------------------------------ class RubyComparable include Comparable def initialize val @@ -596,11 +561,6 @@ class SanityTest assert_equal main.misc.ruby_callable_called, true assert_equal main.misc.ToString(), 'to_s' - # main.convertible - assert_error lambda { System::GC.Collect(main.convertible) }, TypeError # convert to int - Bug!!!!!!!!!! - assert_equal System::Exception.new(main.convertible).class, Exception - # need to convert to float - # main.indexable assert_equal main.indexable[2], 2 main.indexable[10] = 100 @@ -613,9 +573,6 @@ class SanityTest assert_equal((main.number * 2), 200) assert_equal((main.number / 2), 50) - # RubyEnumerable - assert_equal main.ruby_enumerable.min, 1 - # RubyComparable assert_equal((main.ruby_comparable == 100), true) assert_equal((main.ruby_comparable > 100), false) @@ -725,13 +682,38 @@ end AreEqual(MyInvokeMemberBinder.Invoke(misc_class, "ToString"), "FallbackInvokeMember"); } - // TODO: conversions public void Dlr_Convertible() { - var scope = CreateInteropScope(); - object convertible = scope.GetVariable("convertible"); - AreEqualBug(MyConvertBinder.Invoke<int>(convertible, -1234), 0, -1234); - AreEqualBug(MyConvertBinder.Invoke<string>(convertible, "FallbackConvert"), "0", "FallbackConvert"); - AreEqualBug(MyConvertBinder.Invoke<float>(convertible, -1234.0f), 0.0, -1234.0f); + Engine.Execute(@" +class C + def to_int + 1 + end + + def to_f + 2.0 + end + + def to_str + 'str' + end + + def each + [1,2,3].each {|x| yield x } + end +end +"); + var classC = Runtime.Globals.GetVariable("C"); + var c = Engine.Operations.CreateInstance(classC); + + // TODO: + //AreEqual(MyConvertBinder.Convert<int>(c, 10), 1); + //AreEqual(MyConvertBinder.Convert<byte>(c, 10), 1); + //AreEqual(MyConvertBinder.Convert<string>(c, "FallbackConvert"), "str"); + //AreEqual(MyConvertBinder.Convert<double>(c, -8.0), 2.0); + //AreEqual(MyConvertBinder.Convert<float>(c, -8.0f), 2.0f); + //IEnumerable e = MyConvertBinder.Convert<IEnumerable>(c, null) + //Assert(e != null); + //new List<object>(e); } public void Dlr_Indexable() { @@ -754,16 +736,6 @@ end AreEqual(MyUnaryOperationBinder.Invoke(ExpressionType.OnesComplement, one_hundred), ~100); } - // TODO: conversion to IEnumerable - public void Dlr_Enumerable() { - var scope = CreateInteropScope(); - object ruby_enumerable = scope.GetVariable("ruby_enumerable"); - IEnumerable e = MyConvertBinder.Invoke<IEnumerable>(ruby_enumerable, null); - AreEqualBug(e != null, true, false); - IEnumerable<object> e2 = MyConvertBinder.Invoke<IEnumerable<object>>(ruby_enumerable, null); - AreEqualBug(e2 != null, true, false); - } - public void Dlr_Comparable() { var scope = CreateInteropScope(); object ruby_comparable = scope.GetVariable("ruby_comparable"); Merlin/Main/Languages/Ruby/IronRuby.Tests/Runtime/DlrInteropTests.cs @@ -20,6 +20,9 @@ using System.Reflection; using IronRuby.Builtins; using IronRuby.Runtime; using IronRuby.Runtime.Calls; +using Microsoft.Scripting; +using Microsoft.Scripting.Actions.Calls; +using Microsoft.Scripting.Math; using Microsoft.Scripting.Runtime; using Ast = System.Linq.Expressions.Expression; @@ -36,6 +39,10 @@ namespace IronRuby.Tests { return Array.ConvertAll(type.GetMember(name, BindingFlags.Public | BindingFlags.Static), (mi) => (MethodInfo)mi); } + private static MethodInfo/*!*/[]/*!*/ GetInstanceMethods(Type/*!*/ type, string/*!*/ name) { + return Array.ConvertAll(type.GetMember(name, BindingFlags.Public | BindingFlags.Instance), (mi) => (MethodInfo)mi); + } + #region Block public class OverloadsWithBlock { @@ -81,10 +88,10 @@ namespace IronRuby.Tests { var metaBuilder = new MetaObjectBuilder(null); for (int i = 0; i < arguments.Length; i++) { - RubyOverloadResolver parameterBinder; + RubyOverloadResolver resolver; var bindingTarget = RubyMethodGroupInfo.ResolveOverload( metaBuilder, arguments[i], "times", GetStaticMethods(typeof(OverloadsWithBlock), "Times*"), SelfCallConvention.SelfIsParameter, - false, out parameterBinder + false, out resolver ); Assert(bindingTarget.Success); @@ -92,6 +99,95 @@ namespace IronRuby.Tests { } } + public class Overloads1 { + public class X { + } + + public void F1(int a) { } + public void F2(BigInteger a) { } + public void F3(double a) { } + + public void G1([DefaultProtocol]int a) { } + public void G2(BigInteger a) { } + public void G3(double a) { } + + public void I1(int a) { } + public void I2([NotNull]MutableString a) { } + public void I3([DefaultProtocol]Union<int, MutableString> a) { } + + public void J1(int a) { } + public void J2([NotNull]BigInteger a) { } + public void J3([DefaultProtocol]IntegerValue a) { } + + // This is rather useless overload combination: + // If DP parameter behaved exaclty like object it would be ambiguous. + // Since we try implicit conversions first, all types but numerics assignable to integer prefer K1. + // Therefore [DP] is irrelevant here. + public void K1(object a) { } + public void K2([DefaultProtocol]int a) { } + + // level 0: no overload applicable + // level 1: {L1, L3} applicable, MutableString <-/-> SymbolId + public void L1(SymbolId a, [DefaultProtocol, NotNull]string b) { } + public void L2([NotNull]string a, [DefaultProtocol, NotNull]string b) { } + public void L3([DefaultProtocol]MutableString a, [DefaultProtocol, NotNull]string b) { } + } + + public void OverloadResolution_Numeric1() { + var metaBuilder = new MetaObjectBuilder(null); + Context.ObjectClass.SetConstant("X", Context.GetClass(typeof(Overloads1.X))); + + var c = Engine.Execute(@"class C < X; new; end"); + var sym = SymbolTable.StringToId("x"); + var ms = MutableString.Create("x"); + + var cases = new[] { + // F + new { Args = new[] { MO(1) }, Overloads = "F*", Result = "F1" }, + new { Args = new[] { MO((byte)1) }, Overloads = "F*", Result = "F1" }, + new { Args = new[] { MO(1L) }, Overloads = "F*", Result = "F2" }, + new { Args = new[] { MO(1.2F) }, Overloads = "F*", Result = "F3" }, + + // G + new { Args = new[] { MO(1) }, Overloads = "G*", Result = "G1" }, + new { Args = new[] { MO((byte)1) }, Overloads = "G*", Result = "G1" }, + new { Args = new[] { MO(1L) }, Overloads = "G*", Result = "G2" }, + new { Args = new[] { MO(1.2F) }, Overloads = "G*", Result = "G3" }, + new { Args = new[] { MO(c) }, Overloads = "G*", Result = "G1" }, + + // I + new { Args = new[] { MO(c) }, Overloads = "I*", Result = "I3" }, + + // J + new { Args = new[] { MO(1) }, Overloads = "J*", Result = "J1" }, + new { Args = new[] { MO((BigInteger)1000) }, Overloads = "J*", Result = "J2" }, + new { Args = new[] { MO((byte)12) }, Overloads = "J*", Result = "J1" }, + new { Args = new[] { MO(c) }, Overloads = "J*", Result = "J3" }, + new { Args = new[] { MO(1.0) }, Overloads = "J*", Result = "J3" }, + + // K + new { Args = new[] { MO(1) }, Overloads = "K*", Result = "K2" }, + new { Args = new[] { MO(c) }, Overloads = "K*", Result = "K1" }, + new { Args = new[] { MO("x") }, Overloads = "K*", Result = "K1" }, + + // L + new { Args = new[] { MO(sym), MO(sym) }, Overloads = "L*", Result = "L1" }, + new { Args = new[] { MO("x"), MO(sym) }, Overloads = "L*", Result = "L2" }, + new { Args = new[] { MO(ms), MO(sym) }, Overloads = "L*", Result = "L3" }, + new { Args = new[] { MO(null), MO(sym) }, Overloads = "L*", Result = "L3" }, + new { Args = new[] { MO(c), MO(sym) }, Overloads = "L*", Result = "L3" }, + }; + + for (int i = 0; i < cases.Length; i++) { + var args = new CallArguments(Context, MO(new Overloads1()), cases[i].Args, RubyCallSignature.Simple(cases[i].Args.Length)); + var resolver = new RubyOverloadResolver(metaBuilder, args, SelfCallConvention.SelfIsInstance, false); + var overloads = GetInstanceMethods(typeof(Overloads1), cases[i].Overloads); + var result = resolver.ResolveOverload(i.ToString(), overloads, NarrowingLevel.None, NarrowingLevel.All); + + Assert(result.Success && result.Method.Name == cases[i].Result); + } + } + #endregion #region Param Arrays @@ -145,12 +241,12 @@ namespace IronRuby.Tests { return 2; } - public static int F(string p) { + public static int F(MutableString p) { return 3; } } - public void AmbiguousMatch() { + public void AmbiguousMatch1() { Context.SetGlobalConstant("C", Context.GetClass(typeof(AmbiguousOverloads))); AssertOutput(() => CompilerTest(@" [1, nil, 'foo'].each do |x| Merlin/Main/Languages/Ruby/IronRuby.Tests/Runtime/OverloadResolutionTests.cs @@ -23,6 +23,7 @@ using System.Text; using IronRuby.Compiler; using IronRuby.Runtime; using IronRuby.Runtime.Calls; +using IronRuby.Runtime.Conversions; using Microsoft.Scripting.Actions; using Microsoft.Scripting.Generation; using Microsoft.Scripting.Runtime; Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/ArrayOps.cs @@ -38,7 +38,7 @@ namespace IronRuby.Builtins { [RubyConstructor] public static RubyFile/*!*/ CreateFile(RubyClass/*!*/ self, - [DefaultProtocol]Union<int, MutableString> descriptorOrPath, [Optional, DefaultProtocol]MutableString mode, [Optional]int permission) { + [DefaultProtocol, NotNull]Union<int, MutableString> descriptorOrPath, [Optional, DefaultProtocol]MutableString mode, [Optional]int permission) { if (descriptorOrPath.IsFixnum()) { // TODO: descriptor @@ -51,7 +51,7 @@ namespace IronRuby.Builtins { [RubyConstructor] public static RubyFile/*!*/ CreateFile(RubyClass/*!*/ self, - [DefaultProtocol]Union<int, MutableString> descriptorOrPath, int mode, [Optional]int permission) { + [DefaultProtocol, NotNull]Union<int, MutableString> descriptorOrPath, int mode, [Optional]int permission) { if (descriptorOrPath.IsFixnum()) { // TODO: descriptor @@ -63,17 +63,17 @@ namespace IronRuby.Builtins { } [RubyConstructor] - public static RubyFile/*!*/ CreateFile(RubyClass/*!*/ self, MutableString/*!*/ path) { + public static RubyFile/*!*/ CreateFile(RubyClass/*!*/ self, [NotNull]MutableString/*!*/ path) { return new RubyFile(self.Context, path.ConvertToString(), "r"); } [RubyConstructor] - public static RubyFile/*!*/ CreateFile(RubyClass/*!*/ self, MutableString/*!*/ path, MutableString mode) { + public static RubyFile/*!*/ CreateFile(RubyClass/*!*/ self, [NotNull]MutableString/*!*/ path, MutableString mode) { return new RubyFile(self.Context, path.ConvertToString(), (mode != null) ? mode.ConvertToString() : "r"); } [RubyConstructor] - public static RubyFile/*!*/ CreateFile(RubyClass/*!*/ self, MutableString/*!*/ path, int mode) { + public static RubyFile/*!*/ CreateFile(RubyClass/*!*/ self, [NotNull]MutableString/*!*/ path, int mode) { return new RubyFile(self.Context, path.ConvertToString(), (RubyFileMode)mode); } Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/FileOps.cs @@ -24,6 +24,7 @@ using System.Threading; using IronRuby.Compiler; using IronRuby.Runtime; using IronRuby.Runtime.Calls; +using IronRuby.Runtime.Conversions; using Microsoft.Scripting; using Microsoft.Scripting.Math; using Microsoft.Scripting.Runtime; @@ -565,12 +566,13 @@ namespace IronRuby.Builtins { object self, [NotNull]params object[]/*!*/ args) { var inspect = inspectStorage.GetCallSite("inspect"); + var inspectedArgs = new object[args.Length]; for (int i = 0; i < args.Length; i++) { - args[i] = inspect.Target(inspect, args[i]); + inspectedArgs[i] = inspect.Target(inspect, args[i]); } // no dynamic dispatch to "puts": - RubyIOOps.Puts(writeStorage, tosConversion, writeStorage.Context.StandardOutput, args); + RubyIOOps.Puts(writeStorage, tosConversion, writeStorage.Context.StandardOutput, inspectedArgs); } [RubyMethod("print", RubyMethodAttributes.PrivateInstance)] Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/KernelOps.cs @@ -986,23 +986,45 @@ namespace IronRuby.Builtins { if (provided == 1 && type == typeof(Array)) { return self.Context.GetModule(Protocols.ToType(self.Context, typeArgs[0]).MakeArrayType()); - } + } - int required = type.GetGenericArguments().Length; - if (required == 0 && provided > 0) { - throw RubyExceptions.CreateArgumentError(String.Format("'{0}' is not a generic type", type.FullName)); + if (!type.IsGenericTypeDefinition) { + if (provided > 0) { + throw RubyExceptions.CreateArgumentError(String.Format("`{0}' is not a generic type definition", self.Name)); + } + return self; } + int required = type.GetGenericArguments().Length; if (required != provided) { - throw RubyExceptions.CreateArgumentError(String.Format("Type '{0}' requires {1} generic type arguments, {2} provided", type.FullName, required, provided)); + throw RubyExceptions.CreateArgumentError(String.Format("Type `{0}' requires {1} generic type arguments, {2} provided", self.Name, required, provided)); } - if (typeArgs.Length > 0) { - Type concreteType = type.MakeGenericType(Protocols.ToTypes(self.Context, typeArgs)); - return self.Context.GetModule(concreteType); - } else { + Type concreteType = type.MakeGenericType(Protocols.ToTypes(self.Context, typeArgs)); + return self.Context.GetModule(concreteType); + } + + [RubyMethod("of")] + [RubyMethod("[]")] + public static RubyModule/*!*/ Of(RubyModule/*!*/ self, int genericArity) { + if (self.TypeTracker == null) { + throw RubyExceptions.CreateArgumentError(String.Format("`{0}' is not a type", self.Name)); + } + + Type type = self.TypeTracker.Type; + + if (!type.IsGenericTypeDefinition) { + if (genericArity > 0) { + throw RubyExceptions.CreateArgumentError(String.Format("`{0}' is not a generic type definition", self.Name)); + } return self; } + + if (type.GetGenericArguments().Length != genericArity) { + throw RubyExceptions.CreateArgumentError(String.Format("`{0}' does not have generic arity {1}", self.Name, genericArity)); + } + + return self; } #endregion Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/ModuleOps.cs @@ -17,11 +17,12 @@ using System; using Microsoft.Scripting.Runtime; using Microsoft.Scripting.Actions; using Microsoft.Scripting.Generation; -using IronRuby.Runtime; using System.Runtime.InteropServices; using System.Reflection; using System.Runtime.Serialization; +using IronRuby.Runtime; using IronRuby.Runtime.Calls; +using IronRuby.Runtime.Conversions; namespace IronRuby.Builtins { Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/Numeric.cs @@ -27,6 +27,7 @@ using IronRuby.Runtime.Calls; using System.Runtime.CompilerServices; using Microsoft.Scripting.Generation; using IronRuby.Compiler.Generation; +using IronRuby.Runtime.Conversions; namespace IronRuby.Builtins { Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/StringFormatter.cs @@ -39,28 +39,21 @@ namespace IronRuby.Builtins { } [RubyMethod("new", RubyMethodAttributes.PublicSingleton)] - public static object NewAnonymousStruct(BlockParam block, RubyClass/*!*/ self, int className, + public static object NewAnonymousStruct(BlockParam block, RubyClass/*!*/ self, SymbolId firstAttibuteName, [DefaultProtocol, NotNull, NotNullItems]params string/*!*/[]/*!*/ attributeNames) { - return CreateAnonymousWithFirstAttribute(block, self, RubyOps.ConvertFixnumToSymbol(self.Context, className), attributeNames); + return CreateAnonymousWithFirstAttribute(block, self, RubyOps.ConvertSymbolIdToSymbol(firstAttibuteName), attributeNames); } [RubyMethod("new", RubyMethodAttributes.PublicSingleton)] - public static object NewAnonymousStruct(BlockParam block, RubyClass/*!*/ self, SymbolId className, + public static object NewAnonymousStruct(BlockParam block, RubyClass/*!*/ self, [NotNull]string/*!*/ firstAttibuteName, [DefaultProtocol, NotNull, NotNullItems]params string/*!*/[]/*!*/ attributeNames) { - return CreateAnonymousWithFirstAttribute(block, self, RubyOps.ConvertSymbolIdToSymbol(className), attributeNames); + return CreateAnonymousWithFirstAttribute(block, self, firstAttibuteName, attributeNames); } [RubyMethod("new", RubyMethodAttributes.PublicSingleton)] - public static object NewAnonymousStruct(BlockParam block, RubyClass/*!*/ self, [NotNull]string/*!*/ className, - [DefaultProtocol, NotNull, NotNullItems]params string/*!*/[]/*!*/ attributeNames) { - - return CreateAnonymousWithFirstAttribute(block, self, className, attributeNames); - } - - [RubyMethod("new", RubyMethodAttributes.PublicSingleton)] - public static object NewStruct(BlockParam block, RubyClass/*!*/ self, [DefaultProtocol, Optional]MutableString className, + public static object NewStruct(BlockParam block, RubyClass/*!*/ self, [DefaultProtocol]MutableString className, [DefaultProtocol, NotNull, NotNullItems]params string/*!*/[]/*!*/ attributeNames) { if (className == null) { Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/StructOps.cs @@ -63,14 +63,24 @@ namespace IronRuby.StandardLibrary.Enumerator { } [RubyConstructor] - public static Enumerator/*!*/ Create(RubyClass/*!*/ self, object targetObject, [DefaultProtocol, Optional]string targetName, + public static Enumerator/*!*/ Create(RubyClass/*!*/ self, object targetObject) { + return Reinitialize(new Enumerator(), targetObject, null, ArrayUtils.EmptyObjects); + } + + [RubyConstructor] + public static Enumerator/*!*/ Create(RubyClass/*!*/ self, object targetObject, [DefaultProtocol]string targetName, [NotNull]params object[] targetArguments) { return Reinitialize(new Enumerator(), targetObject, targetName, targetArguments); } [RubyMethod("initialize", RubyMethodAttributes.PrivateInstance)] - public static Enumerator/*!*/ Reinitialize(Enumerator/*!*/ self, object targetObject, [DefaultProtocol, Optional]string targetName, + public static Enumerator/*!*/ Reinitialize(Enumerator/*!*/ self, object targetObject) { + return Reinitialize(self, targetObject, null, ArrayUtils.EmptyObjects); + } + + [RubyMethod("initialize", RubyMethodAttributes.PrivateInstance)] + public static Enumerator/*!*/ Reinitialize(Enumerator/*!*/ self, object targetObject, [DefaultProtocol]string targetName, [NotNull]params object[] targetArguments) { self._targetObject = targetObject; Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Enumerator/Enumerator.cs @@ -84,6 +84,11 @@ namespace IronRuby.Builtins { } throw RubyExceptions.CreateRangeError(String.Format("Float {0} out of range of {1}", value, self.Name)); } + + [RubyMethod("inspect")] + public static MutableString/*!*/ Inspect(object/*!*/ self) { + return MutableString.CreateMutable().Append(self.ToString()).Append(" (Byte)"); + } } public static partial class SByteOps { @@ -118,6 +123,11 @@ namespace IronRuby.Builtins { } throw RubyExceptions.CreateRangeError(String.Format("Float {0} out of range of {1}", value, self.Name)); } + + [RubyMethod("inspect")] + public static MutableString/*!*/ Inspect(object/*!*/ self) { + return MutableString.CreateMutable().Append(self.ToString()).Append(" (SByte)"); + } } public static partial class Int16Ops { @@ -152,6 +162,11 @@ namespace IronRuby.Builtins { } throw RubyExceptions.CreateRangeError(String.Format("Float {0} out of range of {1}", value, self.Name)); } + + [RubyMethod("inspect")] + public static MutableString/*!*/ Inspect(object/*!*/ self) { + return MutableString.CreateMutable().Append(self.ToString()).Append(" (Int16)"); + } } public static partial class UInt16Ops { @@ -186,6 +201,11 @@ namespace IronRuby.Builtins { } throw RubyExceptions.CreateRangeError(String.Format("Float {0} out of range of {1}", value, self.Name)); } + + [RubyMethod("inspect")] + public static MutableString/*!*/ Inspect(object/*!*/ self) { + return MutableString.CreateMutable().Append(self.ToString()).Append(" (UInt16)"); + } } public static partial class UInt32Ops { @@ -220,6 +240,11 @@ namespace IronRuby.Builtins { } throw RubyExceptions.CreateRangeError(String.Format("Float {0} out of range of {1}", value, self.Name)); } + + [RubyMethod("inspect")] + public static MutableString/*!*/ Inspect(object/*!*/ self) { + return MutableString.CreateMutable().Append(self.ToString()).Append(" (UInt32)"); + } } public static partial class Int64Ops { @@ -254,6 +279,11 @@ namespace IronRuby.Builtins { } throw RubyExceptions.CreateRangeError(String.Format("Float {0} out of range of {1}", value, self.Name)); } + + [RubyMethod("inspect")] + public static MutableString/*!*/ Inspect(object/*!*/ self) { + return MutableString.CreateMutable().Append(self.ToString()).Append(" (Int64)"); + } } public static partial class UInt64Ops { @@ -288,6 +318,11 @@ namespace IronRuby.Builtins { } throw RubyExceptions.CreateRangeError(String.Format("Float {0} out of range of {1}", value, self.Name)); } + + [RubyMethod("inspect")] + public static MutableString/*!*/ Inspect(object/*!*/ self) { + return MutableString.CreateMutable().Append(self.ToString()).Append(" (UInt64)"); + } } // *** END GENERATED CODE *** Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Extensions/ClrInteger.Generated.cs @@ -63,4 +63,9 @@ public static partial class $SelfOps { } throw RubyExceptions.CreateRangeError(String.Format("Float {0} out of range of {1}", value, self.Name)); } + + [RubyMethod("inspect")] + public static MutableString/*!*/ Inspect(object/*!*/ self) { + return MutableString.CreateMutable().Append(self.ToString()).Append(" ($Self)"); + } } Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Extensions/ClrInteger.Generator.rb @@ -26,6 +26,7 @@ using Microsoft.Scripting.Runtime; using Microsoft.Scripting.Utils; using IronRuby.Runtime; using IronRuby.Runtime.Calls; +using IronRuby.Runtime.Conversions; using EachSite = System.Func<System.Runtime.CompilerServices.CallSite, object, IronRuby.Builtins.Proc, object>; @@ -49,6 +50,14 @@ namespace IronRuby.Builtins { return NormalizeIndex(list.Count, index); } + internal static int NormalizeIndexThrowIfNegative(IList/*!*/ list, int index) { + index = NormalizeIndex(list.Count, index); + if (index < 0) { + throw RubyExceptions.CreateIndexError(String.Format("index {0} out of array", index)); + } + return index; + } + internal static int NormalizeIndex(int count, int index) { return index < 0 ? index + count : index; } @@ -217,7 +226,9 @@ namespace IronRuby.Builtins { #region *, +, concat [RubyMethod("*")] - public static IList/*!*/ Repetition(CallSiteStorage<Func<CallSite, RubyClass, object>>/*!*/ allocateStorage, IList/*!*/ self, int repeat) { + public static IList/*!*/ Repetition(CallSiteStorage<Func<CallSite, RubyClass, object>>/*!*/ allocateStorage, + IList/*!*/ self, int repeat) { + if (repeat < 0) { throw RubyExceptions.CreateArgumentError("negative argument"); } @@ -236,12 +247,16 @@ namespace IronRuby.Builtins { } [RubyMethod("*")] - public static MutableString Repetition(ConversionStorage<MutableString>/*!*/ tosConversion, IList/*!*/ self, [NotNull]MutableString/*!*/ separator) { + public static MutableString Repetition(ConversionStorage<MutableString>/*!*/ tosConversion, + IList/*!*/ self, [NotNull]MutableString/*!*/ separator) { return Join(tosConversion, self, separator); } [RubyMethod("*")] - public static object Repetition(CallSiteStorage<Func<CallSite, RubyClass, object>>/*!*/ allocateStorage, ConversionStorage<MutableString>/*!*/ tosConversion, IList/*!*/ self, [DefaultProtocol]Union<MutableString, int> repeat) { + public static object Repetition( + CallSiteStorage<Func<CallSite, RubyClass, object>>/*!*/ allocateStorage, + ConversionStorage<MutableString>/*!*/ tosConversion, + IList/*!*/ self, [DefaultProtocol, NotNull]Union<MutableString, int> repeat) { if (repeat.IsFixnum()) { return Repetition(allocateStorage, self, repeat.Fixnum()); @@ -451,15 +466,21 @@ namespace IronRuby.Builtins { } [RubyMethod("[]=")] - public static object SetElement(IList/*!*/ self, [DefaultProtocol]int index, object value) { - index = NormalizeIndex(self, index); + public static object SetElement(RubyArray/*!*/ self, [DefaultProtocol]int index, object value) { + index = NormalizeIndexThrowIfNegative(self, index); - if (index < 0) { - throw RubyExceptions.CreateIndexError(String.Format("index {0} out of array", index)); + if (index >= self.Count) { + self.AddMultiple(index + 1 - self.Count, null); } + return self[index] = value; + } + + [RubyMethod("[]=")] + public static object SetElement(IList/*!*/ self, [DefaultProtocol]int index, object value) { + index = NormalizeIndexThrowIfNegative(self, index); + if (index < self.Count) { - // TODO: conversions self[index] = value; } else { ExpandList(self, index); @@ -475,10 +496,7 @@ namespace IronRuby.Builtins { throw RubyExceptions.CreateIndexError(String.Format("negative length ({0})", length)); } - index = NormalizeIndex(self, index); - if (index < 0) { - throw RubyExceptions.CreateIndexError(String.Format("index {0} out of array", index)); - } + index = NormalizeIndexThrowIfNegative(self, index); if (value == null) { DeleteItems(self, index, length); Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Extensions/IListOps.cs @@ -26,39 +26,6 @@ namespace IronRuby.Builtins { /// </summary> [RubyModule("MultiDimensionalArray", DefineIn = typeof(IronRubyOps.ClrOps), Extends = typeof(MultiDimensionalArray), Restrictions = ModuleRestrictions.None)] public static class MultiDimensionalArrayOps { - [RubyMethod("[]=")] - public static object SetElement(Array/*!*/ self, int index1, int index2, object value) { - self.SetValue(value, index1, index2); - return value; - } - - [RubyMethod("[]=")] - public static object SetElement(Array/*!*/ self, int index1, int index2, int index3, object value) { - self.SetValue(value, index1, index2, index3); - return value; - } - - // TODO: params array in the middle of parameters -> needs special attribute or a meta-implementation (meta-impl could call - // T[...].Get()/Set() directly). - [RubyMethod("[]=")] - public static object SetElement(Array/*!*/ self, /*params*/ int[] indices, object value) { - self.SetValue(value, indices); - return value; - } - - [RubyMethod("[]")] - public static object GetElement(Array/*!*/ self, int index1, int index2) { - return self.GetValue(index1, index2); - } - - [RubyMethod("[]")] - public static object GetElement(Array/*!*/ self, int index1, int index2, int index3) { - return self.GetValue(index1, index2, index3); - } - - [RubyMethod("[]")] - public static object GetElement(Array/*!*/ self, int[] indices) { - return self.GetValue(indices); - } + // [], []= methods are mapped to Get/Set methods } } Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Extensions/MultiDimensionalArrayOps.cs @@ -29,5 +29,10 @@ namespace IronRuby.Builtins { public static float Create(RubyClass/*!*/ self, [DefaultProtocol]double value) { return (float)value; } + + [RubyMethod("inspect")] + public static MutableString/*!*/ Inspect(object/*!*/ self) { + return MutableString.CreateMutable().Append(self.ToString()).Append(" (Single)"); + } } } Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Extensions/SingleOps.cs @@ -50,6 +50,17 @@ namespace IronRuby.Builtins { return context.GetModule(concreteType); } + [RubyMethod("of")] + [RubyMethod("[]")] + public static RubyModule/*!*/ Of(RubyContext/*!*/ context, TypeGroup/*!*/ self, int genericArity) { + TypeTracker tracker = self.GetTypeForArity(genericArity); + if (tracker == null) { + throw RubyExceptions.CreateArgumentError(String.Format("Type group `{0}' does not contain a type of generic arity {1}", self.Name, genericArity)); + } + + return context.GetModule(tracker.Type); + } + [RubyMethod("each")] public static object EachType(RubyContext/*!*/ context, BlockParam/*!*/ block, TypeGroup/*!*/ self) { if (block == null) { Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Extensions/TypeGroupOps.cs @@ -56,7 +56,7 @@ namespace IronRuby.Builtins { IronRuby.Builtins.RubyModule def20 = DefineModule("IronRuby::Clr::FlagEnumeration", typeof(IronRuby.Builtins.FlagEnumeration), 0x00000000, LoadIronRuby__Clr__FlagEnumeration_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); IronRuby.Builtins.RubyModule def4 = DefineModule("IronRuby::Clr::Float", typeof(IronRuby.Builtins.ClrFloat), 0x00000103, LoadIronRuby__Clr__Float_Instance, LoadIronRuby__Clr__Float_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); IronRuby.Builtins.RubyModule def5 = DefineModule("IronRuby::Clr::Integer", typeof(IronRuby.Builtins.ClrInteger), 0x00000103, LoadIronRuby__Clr__Integer_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); - IronRuby.Builtins.RubyModule def23 = DefineModule("IronRuby::Clr::MultiDimensionalArray", typeof(IronRuby.Builtins.MultiDimensionalArray), 0x00000000, LoadIronRuby__Clr__MultiDimensionalArray_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); + IronRuby.Builtins.RubyModule def23 = DefineModule("IronRuby::Clr::MultiDimensionalArray", typeof(IronRuby.Builtins.MultiDimensionalArray), 0x00000000, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); IronRuby.Builtins.RubyModule def6 = DefineModule("IronRuby::Clr::String", typeof(IronRuby.Builtins.ClrString), 0x00000103, LoadIronRuby__Clr__String_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); // Skipped primitive: Kernel DefineGlobalModule("Marshal", typeof(IronRuby.Builtins.RubyMarshal), 0x00000103, null, LoadMarshal_Class, LoadMarshal_Constants, IronRuby.Builtins.RubyModule.EmptyArray); @@ -2384,21 +2384,6 @@ namespace IronRuby.Builtins { } - private static void LoadIronRuby__Clr__MultiDimensionalArray_Instance(IronRuby.Builtins.RubyModule/*!*/ module) { - module.DefineLibraryMethod("[]", 0x51, - new System.Func<System.Array, System.Int32, System.Int32, System.Object>(IronRuby.Builtins.MultiDimensionalArrayOps.GetElement), - new System.Func<System.Array, System.Int32, System.Int32, System.Int32, System.Object>(IronRuby.Builtins.MultiDimensionalArrayOps.GetElement), - new System.Func<System.Array, System.Int32[], System.Object>(IronRuby.Builtins.MultiDimensionalArrayOps.GetElement) - ); - - module.DefineLibraryMethod("[]=", 0x51, - new System.Func<System.Array, System.Int32, System.Int32, System.Object, System.Object>(IronRuby.Builtins.MultiDimensionalArrayOps.SetElement), - new System.Func<System.Array, System.Int32, System.Int32, System.Int32, System.Object, System.Object>(IronRuby.Builtins.MultiDimensionalArrayOps.SetElement), - new System.Func<System.Array, System.Int32[], System.Object, System.Object>(IronRuby.Builtins.MultiDimensionalArrayOps.SetElement) - ); - - } - private static void LoadIronRuby__Clr__Name_Instance(IronRuby.Builtins.RubyModule/*!*/ module) { module.DefineLibraryMethod("<=>", 0x51, new System.Func<IronRuby.Runtime.ClrName, System.String, System.Int32>(IronRuby.Builtins.ClrNameOps.Compare), @@ -3581,7 +3566,8 @@ namespace IronRuby.Builtins { private static void LoadMicrosoft__Scripting__Actions__TypeGroup_Instance(IronRuby.Builtins.RubyModule/*!*/ module) { module.DefineLibraryMethod("[]", 0x51, - new System.Func<IronRuby.Runtime.RubyContext, Microsoft.Scripting.Actions.TypeGroup, System.Object[], IronRuby.Builtins.RubyModule>(IronRuby.Builtins.TypeGroupOps.Of) + new System.Func<IronRuby.Runtime.RubyContext, Microsoft.Scripting.Actions.TypeGroup, System.Object[], IronRuby.Builtins.RubyModule>(IronRuby.Builtins.TypeGroupOps.Of), + new System.Func<IronRuby.Runtime.RubyContext, Microsoft.Scripting.Actions.TypeGroup, System.Int32, IronRuby.Builtins.RubyModule>(IronRuby.Builtins.TypeGroupOps.Of) ); module.DefineLibraryMethod("clr_constructor", 0x51, @@ -3615,7 +3601,8 @@ namespace IronRuby.Builtins { ); module.DefineLibraryMethod("of", 0x51, - new System.Func<IronRuby.Runtime.RubyContext, Microsoft.Scripting.Actions.TypeGroup, System.Object[], IronRuby.Builtins.RubyModule>(IronRuby.Builtins.TypeGroupOps.Of) + new System.Func<IronRuby.Runtime.RubyContext, Microsoft.Scripting.Actions.TypeGroup, System.Object[], IronRuby.Builtins.RubyModule>(IronRuby.Builtins.TypeGroupOps.Of), + new System.Func<IronRuby.Runtime.RubyContext, Microsoft.Scripting.Actions.TypeGroup, System.Int32, IronRuby.Builtins.RubyModule>(IronRuby.Builtins.TypeGroupOps.Of) ); module.DefineLibraryMethod("superclass", 0x51, @@ -3641,7 +3628,8 @@ namespace IronRuby.Builtins { private static void LoadModule_Instance(IronRuby.Builtins.RubyModule/*!*/ module) { module.DefineLibraryMethod("[]", 0x51, - new System.Func<IronRuby.Builtins.RubyModule, System.Object[], IronRuby.Builtins.RubyModule>(IronRuby.Builtins.ModuleOps.Of) + new System.Func<IronRuby.Builtins.RubyModule, System.Object[], IronRuby.Builtins.RubyModule>(IronRuby.Builtins.ModuleOps.Of), + new System.Func<IronRuby.Builtins.RubyModule, System.Int32, IronRuby.Builtins.RubyModule>(IronRuby.Builtins.ModuleOps.Of) ); module.DefineLibraryMethod("<", 0x51, @@ -3844,7 +3832,8 @@ namespace IronRuby.Builtins { ); module.DefineLibraryMethod("of", 0x51, - new System.Func<IronRuby.Builtins.RubyModule, System.Object[], IronRuby.Builtins.RubyModule>(IronRuby.Builtins.ModuleOps.Of) + new System.Func<IronRuby.Builtins.RubyModule, System.Object[], IronRuby.Builtins.RubyModule>(IronRuby.Builtins.ModuleOps.Of), + new System.Func<IronRuby.Builtins.RubyModule, System.Int32, IronRuby.Builtins.RubyModule>(IronRuby.Builtins.ModuleOps.Of) ); module.DefineLibraryMethod("private", 0x52, @@ -4941,7 +4930,6 @@ namespace IronRuby.Builtins { private static void LoadStruct_Class(IronRuby.Builtins.RubyModule/*!*/ module) { module.DefineLibraryMethod("new", 0x61, - new System.Func<IronRuby.Runtime.BlockParam, IronRuby.Builtins.RubyClass, System.Int32, System.String[], System.Object>(IronRuby.Builtins.RubyStructOps.NewAnonymousStruct), new System.Func<IronRuby.Runtime.BlockParam, IronRuby.Builtins.RubyClass, Microsoft.Scripting.SymbolId, System.String[], System.Object>(IronRuby.Builtins.RubyStructOps.NewAnonymousStruct), new System.Func<IronRuby.Runtime.BlockParam, IronRuby.Builtins.RubyClass, System.String, System.String[], System.Object>(IronRuby.Builtins.RubyStructOps.NewAnonymousStruct), new System.Func<IronRuby.Runtime.BlockParam, IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString, System.String[], System.Object>(IronRuby.Builtins.RubyStructOps.NewStruct) @@ -4990,6 +4978,10 @@ namespace IronRuby.Builtins { private static void LoadSystem__Byte_Instance(IronRuby.Builtins.RubyModule/*!*/ module) { LoadIronRuby__Clr__Integer_Instance(module); + module.DefineLibraryMethod("inspect", 0x51, + new System.Func<System.Object, IronRuby.Builtins.MutableString>(IronRuby.Builtins.ByteOps.Inspect) + ); + module.DefineLibraryMethod("size", 0x51, new System.Func<System.Byte, System.Int32>(IronRuby.Builtins.ByteOps.Size) ); @@ -5213,6 +5205,7 @@ namespace IronRuby.Builtins { ); module.DefineLibraryMethod("[]=", 0x51, + new System.Func<IronRuby.Builtins.RubyArray, 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) @@ -5486,6 +5479,10 @@ namespace IronRuby.Builtins { private static void LoadSystem__Int16_Instance(IronRuby.Builtins.RubyModule/*!*/ module) { LoadIronRuby__Clr__Integer_Instance(module); + module.DefineLibraryMethod("inspect", 0x51, + new System.Func<System.Object, IronRuby.Builtins.MutableString>(IronRuby.Builtins.Int16Ops.Inspect) + ); + module.DefineLibraryMethod("size", 0x51, new System.Func<System.Int16, System.Int32>(IronRuby.Builtins.Int16Ops.Size) ); @@ -5503,6 +5500,10 @@ namespace IronRuby.Builtins { private static void LoadSystem__Int64_Instance(IronRuby.Builtins.RubyModule/*!*/ module) { LoadIronRuby__Clr__BigInteger_Instance(module); + module.DefineLibraryMethod("inspect", 0x51, + new System.Func<System.Object, IronRuby.Builtins.MutableString>(IronRuby.Builtins.Int64Ops.Inspect) + ); + module.DefineLibraryMethod("size", 0x51, new System.Func<System.Int64, System.Int32>(IronRuby.Builtins.Int64Ops.Size) ); @@ -5520,6 +5521,10 @@ namespace IronRuby.Builtins { private static void LoadSystem__SByte_Instance(IronRuby.Builtins.RubyModule/*!*/ module) { LoadIronRuby__Clr__Integer_Instance(module); + module.DefineLibraryMethod("inspect", 0x51, + new System.Func<System.Object, IronRuby.Builtins.MutableString>(IronRuby.Builtins.SByteOps.Inspect) + ); + module.DefineLibraryMethod("size", 0x51, new System.Func<System.SByte, System.Int32>(IronRuby.Builtins.SByteOps.Size) ); @@ -5537,6 +5542,10 @@ namespace IronRuby.Builtins { private static void LoadSystem__Single_Instance(IronRuby.Builtins.RubyModule/*!*/ module) { LoadIronRuby__Clr__Float_Instance(module); + module.DefineLibraryMethod("inspect", 0x51, + new System.Func<System.Object, IronRuby.Builtins.MutableString>(IronRuby.Builtins.SingleOps.Inspect) + ); + } private static void LoadSystem__Single_Class(IronRuby.Builtins.RubyModule/*!*/ module) { @@ -5556,6 +5565,10 @@ namespace IronRuby.Builtins { private static void LoadSystem__UInt16_Instance(IronRuby.Builtins.RubyModule/*!*/ module) { LoadIronRuby__Clr__Integer_Instance(module); + module.DefineLibraryMethod("inspect", 0x51, + new System.Func<System.Object, IronRuby.Builtins.MutableString>(IronRuby.Builtins.UInt16Ops.Inspect) + ); + module.DefineLibraryMethod("size", 0x51, new System.Func<System.UInt16, System.Int32>(IronRuby.Builtins.UInt16Ops.Size) ); @@ -5573,6 +5586,10 @@ namespace IronRuby.Builtins { private static void LoadSystem__UInt32_Instance(IronRuby.Builtins.RubyModule/*!*/ module) { LoadIronRuby__Clr__BigInteger_Instance(module); + module.DefineLibraryMethod("inspect", 0x51, + new System.Func<System.Object, IronRuby.Builtins.MutableString>(IronRuby.Builtins.UInt32Ops.Inspect) + ); + module.DefineLibraryMethod("size", 0x51, new System.Func<System.UInt32, System.Int32>(IronRuby.Builtins.UInt32Ops.Size) ); @@ -5590,6 +5607,10 @@ namespace IronRuby.Builtins { private static void LoadSystem__UInt64_Instance(IronRuby.Builtins.RubyModule/*!*/ module) { LoadIronRuby__Clr__BigInteger_Instance(module); + module.DefineLibraryMethod("inspect", 0x51, + new System.Func<System.Object, IronRuby.Builtins.MutableString>(IronRuby.Builtins.UInt64Ops.Inspect) + ); + module.DefineLibraryMethod("size", 0x51, new System.Func<System.UInt64, System.Int32>(IronRuby.Builtins.UInt64Ops.Size) ); @@ -7636,6 +7657,7 @@ namespace IronRuby.StandardLibrary.Enumerator { IronRuby.Builtins.RubyModule def1 = DefineGlobalModule("Enumerable", typeof(IronRuby.Builtins.Enumerable), 0x00000003, LoadEnumerable_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); ExtendModule(typeof(IronRuby.Builtins.Kernel), LoadIronRuby__Builtins__Kernel_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); IronRuby.Builtins.RubyClass def2 = DefineClass("Enumerable::Enumerator", typeof(IronRuby.StandardLibrary.Enumerator.Enumerable.Enumerator), 0x00000103, classRef0, LoadEnumerable__Enumerator_Instance, null, null, new IronRuby.Builtins.RubyModule[] {def1}, + new System.Func<IronRuby.Builtins.RubyClass, System.Object, IronRuby.StandardLibrary.Enumerator.Enumerable.Enumerator>(IronRuby.StandardLibrary.Enumerator.Enumerable.Enumerator.Create), new System.Func<IronRuby.Builtins.RubyClass, System.Object, System.String, System.Object[], IronRuby.StandardLibrary.Enumerator.Enumerable.Enumerator>(IronRuby.StandardLibrary.Enumerator.Enumerable.Enumerator.Create) ); def1.SetConstant("Enumerator", def2); @@ -7670,6 +7692,7 @@ namespace IronRuby.StandardLibrary.Enumerator { ); module.DefineLibraryMethod("initialize", 0x12, + new System.Func<IronRuby.StandardLibrary.Enumerator.Enumerable.Enumerator, System.Object, IronRuby.StandardLibrary.Enumerator.Enumerable.Enumerator>(IronRuby.StandardLibrary.Enumerator.Enumerable.Enumerator.Reinitialize), new System.Func<IronRuby.StandardLibrary.Enumerator.Enumerable.Enumerator, System.Object, System.String, System.Object[], IronRuby.StandardLibrary.Enumerator.Enumerable.Enumerator>(IronRuby.StandardLibrary.Enumerator.Enumerable.Enumerator.Reinitialize) ); Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Initializers.Generated.cs @@ -1,8 +1,9 @@ -<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="3.5"> +<?xml version="1.0" encoding="utf-8"?> +<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0"> <PropertyGroup> <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> - <ProductVersion>9.0.30729</ProductVersion> + <ProductVersion>10.0.20624</ProductVersion> <SchemaVersion>2.0</SchemaVersion> <ProjectGuid>{77323B06-15A2-4CF4-8A7A-86EAA2B66498}</ProjectGuid> <OutputType>Library</OutputType> @@ -22,6 +23,7 @@ <DelaySign>true</DelaySign> <BaseAddress>891289600</BaseAddress> <SilverlightPath Condition="$(SilverlightPath) == ''">..\..\..\Utilities\Silverlight\x86ret\</SilverlightPath> + <TargetFrameworkVersion>v2.0</TargetFrameworkVersion> </PropertyGroup> <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> <DebugSymbols>true</DebugSymbols> @@ -195,4 +197,4 @@ </Target> <Target Name="AfterBuild"> </Target> -</Project> \ No newline at end of file +</Project> Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/IronRuby.Libraries.csproj @@ -623,17 +623,24 @@ namespace IronRuby.Builtins { } // used by auto-conversions - [Obsolete("Do not use in code")] - public static implicit operator string(MutableString/*!*/ self) { + public static explicit operator string(MutableString/*!*/ self) { return self._content.ConvertToString(); } // used by auto-conversions - [Obsolete("Do not use in code")] - public static implicit operator byte[](MutableString/*!*/ self) { + public static explicit operator byte[](MutableString/*!*/ self) { return self._content.ConvertToBytes(); } + // used by auto-conversions + public static explicit operator char(MutableString/*!*/ self) { + try { + return self.GetChar(0); + } catch (IndexOutOfRangeException) { + throw RubyExceptions.CreateTypeConversionError("String", "System::Char"); + } + } + #endregion #region Comparisons (read-only) (TODO: Encodings) Merlin/Main/Languages/Ruby/Ruby/Builtins/MutableString.cs @@ -33,7 +33,7 @@ namespace IronRuby.Builtins { return new Meta(parameter, BindingRestrictions.Empty, this); } - internal sealed class Meta : RubyMetaObject<Proc> { + internal sealed class Meta : RubyMetaObject<Proc>, IConvertibleMetaObject { public override RubyContext/*!*/ Context { get { return Value.LocalScope.RubyContext; } } @@ -47,6 +47,10 @@ namespace IronRuby.Builtins { } // Conversion to a delegate. + public bool CanConvertTo(Type/*!*/ type, bool @explicit) { + return typeof(Delegate).IsAssignableFrom(type); + } + public override DynamicMetaObject/*!*/ BindConvert(ConvertBinder/*!*/ binder) { return InteropBinder.TryBindCovertToDelegate(this, binder, Methods.CreateDelegateFromProc) ?? base.BindConvert(binder); Merlin/Main/Languages/Ruby/Ruby/Builtins/Proc.Meta.cs @@ -21,6 +21,7 @@ using IronRuby.Runtime; using Microsoft.Scripting; using Microsoft.Scripting.Utils; using IronRuby.Runtime.Calls; +using IronRuby.Runtime.Conversions; namespace IronRuby.Builtins { Merlin/Main/Languages/Ruby/Ruby/Builtins/RubyArray.cs @@ -32,6 +32,7 @@ using Microsoft.Scripting.Utils; using Ast = System.Linq.Expressions.Expression; using AstUtils = Microsoft.Scripting.Ast.Utils; using Microsoft.Scripting.Generation; +using IronRuby.Runtime.Conversions; namespace IronRuby.Builtins { public sealed partial class RubyClass : RubyModule, IDuplicable { @@ -250,7 +251,7 @@ namespace IronRuby.Builtins { Interlocked.Exchange(ref _underlyingSystemType, RubyTypeDispenser.GetOrCreateType( _superClass.GetUnderlyingSystemType(), - GetClrInterfaces(), + GetImplementedInterfaces(), _superClass != null && (_superClass.Restrictions & ModuleRestrictions.NoOverrides) != 0 ) ); @@ -747,12 +748,19 @@ namespace IronRuby.Builtins { return true; } } else if (name == "[]" || name == "[]=") { - object[] attrs = type.GetCustomAttributes(typeof(DefaultMemberAttribute), false); - if (attrs.Length == 1) { - // default indexer accessor: + if (type.IsArray && !_isSingletonClass) { bool isSetter = name.Length == 3; - if (TryGetClrProperty(type, bindingFlags, isSetter, name, ((DefaultMemberAttribute)attrs[0]).MemberName, null, out method)) { - return true; + TryGetClrMethod(type, bindingFlags, false, name, null, isSetter ? "Set" : "Get", null, out method); + Debug.Assert(method != null); + return true; + } else { + object[] attrs = type.GetCustomAttributes(typeof(DefaultMemberAttribute), false); + if (attrs.Length == 1) { + // default indexer accessor: + bool isSetter = name.Length == 3; + if (TryGetClrProperty(type, bindingFlags, isSetter, name, ((DefaultMemberAttribute)attrs[0]).MemberName, null, out method)) { + return true; + } } } } else if (name.LastCharacter() == '=') { @@ -1249,7 +1257,7 @@ namespace IronRuby.Builtins { BuildDelegateConstructorCall(metaBuilder, args, type); return; } else if (type.IsArray && type.GetArrayRank() == 1) { - constructionOverloads = ClrVectorFactories; + constructionOverloads = GetClrVectorFactories(); } else if (_structInfo != null) { constructionOverloads = new MethodBase[] { Methods.CreateStructInstance }; } else if (_factories.Length != 0) { @@ -1386,16 +1394,19 @@ namespace IronRuby.Builtins { } } - private MethodBase/*!*/[]/*!*/ ClrVectorFactories { - get { - if (_clrVectorFactories == null) { - _clrVectorFactories = new[] { Methods.CreateVector, Methods.CreateVectorWithValues }; - } - return _clrVectorFactories; + private MethodBase/*!*/[]/*!*/ GetClrVectorFactories() { + if (_clrVectorFactories == null) { + Type elementType = GetUnderlyingSystemType().GetElementType(); + _clrVectorFactories = new[] { + Methods.CreateVector.MakeGenericMethod(elementType), + Methods.CreateVectorWithValues.MakeGenericMethod(elementType) + }; } + return _clrVectorFactories; } - private static MethodBase[] _clrVectorFactories; + // thread-safe (the latest write wins): + private MethodBase[] _clrVectorFactories; #endregion } Merlin/Main/Languages/Ruby/Ruby/Builtins/RubyClass.cs @@ -1669,8 +1669,8 @@ namespace IronRuby.Builtins { private bool TryGetClrMember(string/*!*/ name, bool virtualLookup, out RubyMemberInfo method) { // Skip hidden CLR overloads. - // Skip lookup on types that are not visible or interfaces. - if (_typeTracker != null && !_typeTracker.Type.IsInterface) { + // Skip lookup on types that are not visible, that are interfaces or generic type definitions. + if (_typeTracker != null && !_typeTracker.Type.IsInterface && !_typeTracker.Type.IsGenericTypeDefinition) { // Note: Do not allow mangling for CLR virtual lookups - we want to match the overridden name exactly as is, // so that it corresponds to the base method call the override stub performs. bool tryUnmangle = !virtualLookup && (_restrictions & ModuleRestrictions.NoNameMangling) == 0; @@ -1904,14 +1904,6 @@ namespace IronRuby.Builtins { foreach (RubyModule module in expanded) { if (module.IsInterface) { - // Can't include generic interfaces - if (module.TypeTracker.Type.ContainsGenericParameters) { - throw RubyExceptions.CreateTypeError(String.Format( - "{0}: cannot extend with open generic instantiation {1}. Only closed instantiations are supported.", - Name, module.Name - )); - } - if (!CanIncludeClrInterface) { bool alreadyIncluded = false; foreach (RubyModule includedModule in _mixins) { @@ -2006,11 +1998,11 @@ namespace IronRuby.Builtins { get { return true; } } - internal List<Type> GetClrInterfaces() { + internal List<Type> GetImplementedInterfaces() { List<Type> interfaces = new List<Type>(); using (Context.ClassHierarchyLocker()) { foreach (RubyModule m in _mixins) { - if (m.IsInterface && !interfaces.Contains(m.TypeTracker.Type)) { + if (m.IsInterface && !m.TypeTracker.Type.IsGenericTypeDefinition && !interfaces.Contains(m.TypeTracker.Type)) { interfaces.Add(m.TypeTracker.Type); } } Merlin/Main/Languages/Ruby/Ruby/Builtins/RubyModule.cs @@ -17,6 +17,7 @@ using Microsoft.Scripting; using Microsoft.Scripting.Utils; using IronRuby.Builtins; using IronRuby.Runtime.Calls; +using IronRuby.Runtime.Conversions; using MSA = System.Linq.Expressions; namespace IronRuby.Compiler.Ast { Merlin/Main/Languages/Ruby/Ruby/Compiler/Ast/BlockReference.cs @@ -13,7 +13,9 @@ * * ***************************************************************************/ -using System.Collections.Generic; +using System.Diagnostics; +using IronRuby.Runtime; +using IronRuby.Runtime.Conversions; using Microsoft.Scripting; using Microsoft.Scripting.Ast; using Microsoft.Scripting.Utils; @@ -22,10 +24,6 @@ using MSA = System.Linq.Expressions; namespace IronRuby.Compiler.Ast { using Ast = System.Linq.Expressions.Expression; - using System.Diagnostics; - using IronRuby.Runtime.Calls; - using System.Collections; - using IronRuby.Runtime; // rescue type // statements Merlin/Main/Languages/Ruby/Ruby/Compiler/Ast/Clauses/RescueClause.cs @@ -20,12 +20,13 @@ using Microsoft.Scripting.Actions; using Microsoft.Scripting.Utils; using IronRuby.Builtins; using IronRuby.Runtime; +using IronRuby.Runtime.Calls; +using IronRuby.Runtime.Conversions; using AstUtils = Microsoft.Scripting.Ast.Utils; using MSA = System.Linq.Expressions; namespace IronRuby.Compiler.Ast { using Ast = System.Linq.Expressions.Expression; - using IronRuby.Runtime.Calls; public partial class MatchExpression : Expression { private readonly RegularExpression/*!*/ _regex; Merlin/Main/Languages/Ruby/Ruby/Compiler/Ast/Expressions/MatchExpression.cs @@ -22,12 +22,13 @@ using IronRuby.Runtime; using IronRuby.Runtime.Calls; using Microsoft.Scripting; using Microsoft.Scripting.Utils; +using System.Diagnostics; +using IronRuby.Runtime.Conversions; using AstUtils = Microsoft.Scripting.Ast.Utils; namespace IronRuby.Compiler.Ast { using Ast = System.Linq.Expressions.Expression; using MSA = System.Linq.Expressions; - using System.Diagnostics; public enum StringKind { Mutable, Merlin/Main/Languages/Ruby/Ruby/Compiler/Ast/Expressions/StringConstructor.cs @@ -25,6 +25,7 @@ using Microsoft.Scripting.Utils; using IronRuby.Builtins; using IronRuby.Runtime; using IronRuby.Runtime.Calls; +using IronRuby.Runtime.Conversions; using MSA = System.Linq.Expressions; using AstUtils = Microsoft.Scripting.Ast.Utils; Merlin/Main/Languages/Ruby/Ruby/Compiler/Ast/SourceUnitTree.cs @@ -416,7 +416,7 @@ namespace IronRuby.Compiler.Generation { } private void DefineDynamicObjectImplementation() { - _tb.AddInterfaceImplementation(typeof(IDynamicMetaObjectProvider)); + _tb.AddInterfaceImplementation(typeof(IRubyDynamicMetaObjectProvider)); // MetaObject! IDynamicMetaObjectProvider.GetMetaObject(Expression! parameter) { // return RubyOps.GetMetaObject(this, parameter); Merlin/Main/Languages/Ruby/Ruby/Compiler/Generation/RubyTypeBuilder.cs @@ -24,6 +24,7 @@ using IronRuby.Builtins; using IronRuby.Runtime; using IronRuby.Runtime.Calls; using System.Linq.Expressions; +using IronRuby.Runtime.Conversions; namespace IronRuby.Compiler.Generation { public class RubyTypeEmitter : ClsTypeEmitter { Merlin/Main/Languages/Ruby/Ruby/Compiler/Generation/RubyTypeEmitter.cs Merlin/Main/Languages/Ruby/Ruby/Ruby.Build.csproj @@ -1,8 +1,9 @@ -<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="3.5"> +<?xml version="1.0" encoding="utf-8"?> +<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0"> <PropertyGroup> <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> - <ProductVersion>9.0.30729</ProductVersion> + <ProductVersion>10.0.20624</ProductVersion> <SchemaVersion>2.0</SchemaVersion> <ProjectGuid>{7F6984B4-EE6D-4E6F-ABB1-E210D7DC4FDD}</ProjectGuid> <OutputType>Library</OutputType> @@ -22,6 +23,7 @@ <DelaySign>true</DelaySign> <BaseAddress>887095296</BaseAddress> <SilverlightPath Condition="$(SilverlightPath) == ''">..\..\..\Utilities\Silverlight\x86ret\</SilverlightPath> + <TargetFrameworkVersion>v2.0</TargetFrameworkVersion> </PropertyGroup> <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'FxCop|AnyCPU' "> <DebugType>pdbonly</DebugType> @@ -32,7 +34,8 @@ <WarningLevel>4</WarningLevel> <TreatWarningsAsErrors>true</TreatWarningsAsErrors> <RunCodeAnalysis>true</RunCodeAnalysis> - <CodeAnalysisRules>-Microsoft.Usage#CA2209;-!Microsoft.Design#CA1012;-!Microsoft.Design#CA2210;-!Microsoft.Design#CA1040;-!Microsoft.Design#CA1005;-!Microsoft.Design#CA1020;-!Microsoft.Design#CA1021;-!Microsoft.Design#CA1010;-!Microsoft.Design#CA1011;-!Microsoft.Design#CA1009;-!Microsoft.Design#CA1050;-!Microsoft.Design#CA1026;-!Microsoft.Design#CA1019;-!Microsoft.Design#CA1031;-!Microsoft.Design#CA1047;-!Microsoft.Design#CA1000;-!Microsoft.Design#CA1048;-!Microsoft.Design#CA1051;-!Microsoft.Design#CA1002;-!Microsoft.Design#CA1061;-!Microsoft.Design#CA1006;-!Microsoft.Design#CA1046;-!Microsoft.Design#CA1045;-!Microsoft.Design#CA1065;-!Microsoft.Design#CA1038;-!Microsoft.Design#CA1008;-!Microsoft.Design#CA1028;-!Microsoft.Design#CA1064;-!Microsoft.Design#CA1004;-!Microsoft.Design#CA1035;-!Microsoft.Design#CA1063;-!Microsoft.Design#CA1032;-!Microsoft.Design#CA1023;-!Microsoft.Design#CA1033;-!Microsoft.Design#CA1039;-!Microsoft.Design#CA1016;-!Microsoft.Design#CA1014;-!Microsoft.Design#CA1017;-!Microsoft.Design#CA1018;-!Microsoft.Design#CA1027;-!Microsoft.Design#CA1059;-!Microsoft.Design#CA1060;-!Microsoft.Design#CA1034;-!Microsoft.Design#CA1013;-!Microsoft.Design#CA1036;-!Microsoft.Design#CA1044;-!Microsoft.Design#CA1041;-!Microsoft.Design#CA1025;-!Microsoft.Design#CA1052;-!Microsoft.Design#CA1053;-!Microsoft.Design#CA1057;-!Microsoft.Design#CA1058;-!Microsoft.Design#CA1001;-!Microsoft.Design#CA1049;-!Microsoft.Design#CA1054;-!Microsoft.Design#CA1056;-!Microsoft.Design#CA1055;-!Microsoft.Design#CA1030;-!Microsoft.Design#CA1003;-!Microsoft.Design#CA1007;-!Microsoft.Design#CA1043;-!Microsoft.Design#CA1024;-!Microsoft.Globalization#CA1301;-!Microsoft.Globalization#CA1302;-!Microsoft.Globalization#CA1308;-!Microsoft.Globalization#CA1306;-!Microsoft.Globalization#CA1304;-!Microsoft.Globalization#CA1305;-!Microsoft.Globalization#CA2101;-!Microsoft.Globalization#CA1300;-!Microsoft.Globalization#CA1307;-!Microsoft.Globalization#CA1309;-!Microsoft.Interoperability#CA1403;-!Microsoft.Interoperability#CA1406;-!Microsoft.Interoperability#CA1413;-!Microsoft.Interoperability#CA1402;-!Microsoft.Interoperability#CA1407;-!Microsoft.Interoperability#CA1404;-!Microsoft.Interoperability#CA1410;-!Microsoft.Interoperability#CA1411;-!Microsoft.Interoperability#CA1405;-!Microsoft.Interoperability#CA1409;-!Microsoft.Interoperability#CA1415;-!Microsoft.Interoperability#CA1408;-!Microsoft.Interoperability#CA1414;-!Microsoft.Interoperability#CA1412;-!Microsoft.Interoperability#CA1400;-!Microsoft.Interoperability#CA1401;-!Microsoft.Maintainability#CA1506;-!Microsoft.Maintainability#CA1502;-!Microsoft.Maintainability#CA1501;-!Microsoft.Maintainability#CA1505;-!Microsoft.Maintainability#CA1504;-!Microsoft.Maintainability#CA1500;-!Microsoft.Mobility#CA1600;-!Microsoft.Mobility#CA1601;-!Microsoft.Naming#CA1702;-!Microsoft.Naming#CA1700;-!Microsoft.Naming#CA1712;-!Microsoft.Naming#CA1713;-!Microsoft.Naming#CA1714;-!Microsoft.Naming#CA1709;-!Microsoft.Naming#CA1704;-!Microsoft.Naming#CA1708;-!Microsoft.Naming#CA1715;-!Microsoft.Naming#CA1710;-!Microsoft.Naming#CA1720;-!Microsoft.Naming#CA1707;-!Microsoft.Naming#CA1722;-!Microsoft.Naming#CA1711;-!Microsoft.Naming#CA1716;-!Microsoft.Naming#CA1717;-!Microsoft.Naming#CA1725;-!Microsoft.Naming#CA1719;-!Microsoft.Naming#CA1721;-!Microsoft.Naming#CA1701;-!Microsoft.Naming#CA1703;-!Microsoft.Naming#CA1724;-!Microsoft.Naming#CA1726;-!Microsoft.Performance#CA1809;-!Microsoft.Performance#CA1811;-!Microsoft.Performance#CA1812;-!Microsoft.Performance#CA1813;+!Microsoft.Performance#CA1823;-!Microsoft.Performance#CA1800;-!Microsoft.Performance#CA1805;-!Microsoft.Performance#CA1810;+!Microsoft.Performance#CA1824;-!Microsoft.Performance#CA1822;-!Microsoft.Performance#CA1815;-!Microsoft.Performance#CA1814;-!Microsoft.Performance#CA1819;-!Microsoft.Performance#CA1821;-!Microsoft.Performance#CA1804;-!Microsoft.Performance#CA1820;-!Microsoft.Performance#CA1802;+!Microsoft.Portability#CA1903;+!Microsoft.Portability#CA1901;+!Microsoft.Portability#CA1900;+!Microsoft.Reliability#CA2001;+!Microsoft.Reliability#CA2002;+!Microsoft.Reliability#CA2003;+!Microsoft.Reliability#CA2004;+!Microsoft.Reliability#CA2006;+!Microsoft.Security#CA2116;+!Microsoft.Security#CA2117;+!Microsoft.Security#CA2105;+!Microsoft.Security#CA2115;+!Microsoft.Security#CA2102;-!Microsoft.Security#CA2104;+!Microsoft.Security#CA2122;+!Microsoft.Security#CA2114;+!Microsoft.Security#CA2123;+!Microsoft.Security#CA2111;+!Microsoft.Security#CA2108;+!Microsoft.Security#CA2107;+!Microsoft.Security#CA2103;+!Microsoft.Security#CA2118;+!Microsoft.Security#CA2109;+!Microsoft.Security#CA2119;+!Microsoft.Security#CA2106;+!Microsoft.Security#CA2112;+!Microsoft.Security#CA2120;+!Microsoft.Security#CA2121;+!Microsoft.Security#CA2126;+!Microsoft.Security#CA2124;+!Microsoft.Security#CA2127;+!Microsoft.Security#CA2128;+!Microsoft.Security#CA2129;-!Microsoft.Usage#CA2243;-!Microsoft.Usage#CA2236;-!Microsoft.Usage#CA1816;-!Microsoft.Usage#CA2227;-!Microsoft.Usage#CA2213;-!Microsoft.Usage#CA2216;-!Microsoft.Usage#CA2214;-!Microsoft.Usage#CA2222;-!Microsoft.Usage#CA1806;-!Microsoft.Usage#CA2217;-!Microsoft.Usage#CA2212;-!Microsoft.Usage#CA2219;-!Microsoft.Usage#CA2201;-!Microsoft.Usage#CA2228;-!Microsoft.Usage#CA2221;-!Microsoft.Usage#CA2220;-!Microsoft.Usage#CA2240;-!Microsoft.Usage#CA2229;-!Microsoft.Usage#CA2238;-!Microsoft.Usage#CA2207;-!Microsoft.Usage#CA2208;-!Microsoft.Usage#CA2235;-!Microsoft.Usage#CA2237;-!Microsoft.Usage#CA2232;-!Microsoft.Usage#CA2223;-!Microsoft.Usage#CA2211;-!Microsoft.Usage#CA2233;-!Microsoft.Usage#CA2225;-!Microsoft.Usage#CA2226;-!Microsoft.Usage#CA2231;-!Microsoft.Usage#CA2224;-!Microsoft.Usage#CA2218;-!Microsoft.Usage#CA2234;-!Microsoft.Usage#CA2239;-!Microsoft.Usage#CA2200;-!Microsoft.Usage#CA1801;-!Microsoft.Usage#CA2242;-!Microsoft.Usage#CA2205;-!Microsoft.Usage#CA2230</CodeAnalysisRules> + <CodeAnalysisRules>-Microsoft.Usage#CA2209;-!Microsoft.Design#CA1012;-!Microsoft.Design#CA2210;-!Microsoft.Design#CA1040;-!Microsoft.Design#CA1005;-!Microsoft.Design#CA1020;-!Microsoft.Design#CA1021;-!Microsoft.Design#CA1010;-!Microsoft.Design#CA1011;-!Microsoft.Design#CA1009;-!Microsoft.Design#CA1050;-!Microsoft.Design#CA1026;-!Microsoft.Design#CA1019;-!Microsoft.Design#CA1031;-!Microsoft.Design#CA1047;-!Microsoft.Design#CA1000;-!Microsoft.Design#CA1048;-!Microsoft.Design#CA1051;-!Microsoft.Design#CA1002;-!Microsoft.Design#CA1061;-!Microsoft.Design#CA1006;-!Microsoft.Design#CA1046;-!Microsoft.Design#CA1045;-!Microsoft.Design#CA1065;-!Microsoft.Design#CA1038;-!Microsoft.Design#CA1008;-!Microsoft.Design#CA1028;-!Microsoft.Design#CA1064;-!Microsoft.Design#CA1004;-!Microsoft.Design#CA1035;-!Microsoft.Design#CA1063;-!Microsoft.Design#CA1032;-!Microsoft.Design#CA1023;-!Microsoft.Design#CA1033;-!Microsoft.Design#CA1039;-!Microsoft.Design#CA1016;-!Microsoft.Design#CA1014;-!Microsoft.Design#CA1017;-!Microsoft.Design#CA1018;-!Microsoft.Design#CA1027;-!Microsoft.Design#CA1059;-!Microsoft.Design#CA1060;-!Microsoft.Design#CA1034;-!Microsoft.Design#CA1013;-!Microsoft.Design#CA1036;-!Microsoft.Design#CA1044;-!Microsoft.Design#CA1041;-!Microsoft.Design#CA1025;-!Microsoft.Design#CA1052;-!Microsoft.Design#CA1053;-!Microsoft.Design#CA1057;-!Microsoft.Design#CA1058;-!Microsoft.Design#CA1001;-!Microsoft.Design#CA1049;-!Microsoft.Design#CA1054;-!Microsoft.Design#CA1056;-!Microsoft.Design#CA1055;-!Microsoft.Design#CA1030;-!Microsoft.Design#CA1003;-!Microsoft.Design#CA1007;-!Microsoft.Design#CA1043;-!Microsoft.Design#CA1024;-!Microsoft.Globalization#CA1301;-!Microsoft.Globalization#CA1302;-!Microsoft.Globalization#CA1308;-!Microsoft.Globalization#CA1306;-!Microsoft.Globalization#CA1304;-!Microsoft.Globalization#CA1305;-!Microsoft.Globalization#CA2101;-!Microsoft.Globalization#CA1300;-!Microsoft.Globalization#CA1307;-!Microsoft.Globalization#CA1309;-!Microsoft.Interoperability#CA1403;-!Microsoft.Interoperability#CA1406;-!Microsoft.Interoperability#CA1413;-!Microsoft.Interoperability#CA1402;-!Microsoft.Interoperability#CA1407;-!Microsoft.Interoperability#CA1404;-!Microsoft.Interoperability#CA1410;-!Microsoft.Interoperability#CA1411;-!Microsoft.Interoperability#CA1405;-!Microsoft.Interoperability#CA1409;-!Microsoft.Interoperability#CA1415;-!Microsoft.Interoperability#CA1408;-!Microsoft.Interoperability#CA1414;-!Microsoft.Interoperability#CA1412;-!Microsoft.Interoperability#CA1400;-!Microsoft.Interoperability#CA1401;-!Microsoft.Maintainability#CA1506;-!Microsoft.Maintainability#CA1502;-!Microsoft.Maintainability#CA1501;-!Microsoft.Maintainability#CA1505;-!Microsoft.Maintainability#CA1504;-!Microsoft.Maintainability#CA1500;-!Microsoft.Mobility#CA1600;-!Microsoft.Mobility#CA1601;-!Microsoft.Naming#CA1702;-!Microsoft.Naming#CA1700;-!Microsoft.Naming#CA1712;-!Microsoft.Naming#CA1713;-!Microsoft.Naming#CA1714;-!Microsoft.Naming#CA1709;-!Microsoft.Naming#CA1704;-!Microsoft.Naming#CA1708;-!Microsoft.Naming#CA1715;-!Microsoft.Naming#CA1710;-!Microsoft.Naming#CA1720;-!Microsoft.Naming#CA1707;-!Microsoft.Naming#CA1722;-!Microsoft.Naming#CA1711;-!Microsoft.Naming#CA1716;-!Microsoft.Naming#CA1717;-!Microsoft.Naming#CA1725;-!Microsoft.Naming#CA1719;-!Microsoft.Naming#CA1721;-!Microsoft.Naming#CA1701;-!Microsoft.Naming#CA1703;-!Microsoft.Naming#CA1724;-!Microsoft.Naming#CA1726;-!Microsoft.Performance#CA1809;-!Microsoft.Performance#CA1811;-!Microsoft.Performance#CA1812;-!Microsoft.Performance#CA1813;+!Microsoft.Performance#CA1823;-!Microsoft.Performance#CA1800;-!Microsoft.Performance#CA1805;-!Microsoft.Performance#CA1810;+!Microsoft.Performance#CA1824;-!Microsoft.Performance#CA1822;-!Microsoft.Performance#CA1815;-!Microsoft.Performance#CA1814;-!Microsoft.Performance#CA1819;-!Microsoft.Performance#CA1821;-!Microsoft.Performance#CA1804;-!Microsoft.Performance#CA1820;-!Microsoft.Performance#CA1802;+!Microsoft.Portability#CA1903;+!Microsoft.Portability#CA1901;+!Microsoft.Portability#CA1900;+!Microsoft.Reliability#CA2001;+!Microsoft.Reliability#CA2002;+!Microsoft +.Reliability#CA2003;+!Microsoft.Reliability#CA2004;+!Microsoft.Reliability#CA2006;+!Microsoft.Security#CA2116;+!Microsoft.Security#CA2117;+!Microsoft.Security#CA2105;+!Microsoft.Security#CA2115;+!Microsoft.Security#CA2102;-!Microsoft.Security#CA2104;+!Microsoft.Security#CA2122;+!Microsoft.Security#CA2114;+!Microsoft.Security#CA2123;+!Microsoft.Security#CA2111;+!Microsoft.Security#CA2108;+!Microsoft.Security#CA2107;+!Microsoft.Security#CA2103;+!Microsoft.Security#CA2118;+!Microsoft.Security#CA2109;+!Microsoft.Security#CA2119;+!Microsoft.Security#CA2106;+!Microsoft.Security#CA2112;+!Microsoft.Security#CA2120;+!Microsoft.Security#CA2121;+!Microsoft.Security#CA2126;+!Microsoft.Security#CA2124;+!Microsoft.Security#CA2127;+!Microsoft.Security#CA2128;+!Microsoft.Security#CA2129;-!Microsoft.Usage#CA2243;-!Microsoft.Usage#CA2236;-!Microsoft.Usage#CA1816;-!Microsoft.Usage#CA2227;-!Microsoft.Usage#CA2213;-!Microsoft.Usage#CA2216;-!Microsoft.Usage#CA2214;-!Microsoft.Usage#CA2222;-!Microsoft.Usage#CA1806;-!Microsoft.Usage#CA2217;-!Microsoft.Usage#CA2212;-!Microsoft.Usage#CA2219;-!Microsoft.Usage#CA2201;-!Microsoft.Usage#CA2228;-!Microsoft.Usage#CA2221;-!Microsoft.Usage#CA2220;-!Microsoft.Usage#CA2240;-!Microsoft.Usage#CA2229;-!Microsoft.Usage#CA2238;-!Microsoft.Usage#CA2207;-!Microsoft.Usage#CA2208;-!Microsoft.Usage#CA2235;-!Microsoft.Usage#CA2237;-!Microsoft.Usage#CA2232;-!Microsoft.Usage#CA2223;-!Microsoft.Usage#CA2211;-!Microsoft.Usage#CA2233;-!Microsoft.Usage#CA2225;-!Microsoft.Usage#CA2226;-!Microsoft.Usage#CA2231;-!Microsoft.Usage#CA2224;-!Microsoft.Usage#CA2218;-!Microsoft.Usage#CA2234;-!Microsoft.Usage#CA2239;-!Microsoft.Usage#CA2200;-!Microsoft.Usage#CA1801;-!Microsoft.Usage#CA2242;-!Microsoft.Usage#CA2205;-!Microsoft.Usage#CA2230</CodeAnalysisRules> </PropertyGroup> <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> <DebugSymbols>true</DebugSymbols> @@ -176,10 +179,10 @@ <Compile Include="Compiler\Parser\ParserStack.cs" /> <Compile Include="Runtime\BinaryContentProvider.cs" /> <Compile Include="Runtime\CallSiteStorages.cs" /> - <Compile Include="Runtime\Calls\GenericConversionAction.cs" /> + <Compile Include="Runtime\Conversions\GenericConversionAction.cs" /> <Compile Include="Runtime\Calls\MethodDispatcher.Generated.cs" /> - <Compile Include="Runtime\Calls\CompositeConversionAction.cs" /> - <Compile Include="Runtime\Calls\ConvertToSAction.cs" /> + <Compile Include="Runtime\Conversions\CompositeConversionAction.cs" /> + <Compile Include="Runtime\Conversions\ConvertToSAction.cs" /> <Compile Include="Runtime\Calls\InteropBinder.cs" /> <Compile Include="Runtime\Calls\MethodDispatcher.cs" /> <Compile Include="Runtime\Calls\MethodResolutionResult.cs" /> @@ -219,7 +222,7 @@ <Compile Include="Runtime\Calls\BlockDispatcherUnsplatN.cs" /> <Compile Include="Runtime\Calls\CallSiteTracer.cs" /> <Compile Include="Runtime\Calls\MetaObjectBuilder.cs" /> - <Compile Include="Runtime\Calls\ProtocolConversionAction.cs" /> + <Compile Include="Runtime\Conversions\ProtocolConversionAction.cs" /> <Compile Include="Runtime\Calls\RubyCallAction.cs" /> <Compile Include="Runtime\Calls\RubyCallSignature.cs" /> <Compile Include="Runtime\Calls\SuperCallAction.cs" /> @@ -251,8 +254,8 @@ <Compile Include="Runtime\Protocols.cs" /> <Compile Include="Runtime\ReferenceEqualityComparer.cs" /> <Compile Include="Compiler\Ast\Expressions\RangeExpression.cs" /> - <Compile Include="Runtime\Converter.cs" /> - <Compile Include="Runtime\Converter.Generated.cs" /> + <Compile Include="Runtime\Conversions\Converter.cs" /> + <Compile Include="Runtime\Conversions\Converter.Generated.cs" /> <Compile Include="Builtins\Initializer.cs" /> <Compile Include="Compiler\AstGenerator.cs" /> <Compile Include="Compiler\Ast\Arguments.cs" /> @@ -339,7 +342,6 @@ <Compile Include="Runtime\Calls\RubyBinder.cs" /> <Compile Include="Builtins\RubyArray.cs" /> <Compile Include="Builtins\RubyClass.cs" /> - <Compile Include="Runtime\RubyCallTargets.cs" /> <Compile Include="Runtime\Loader.cs" /> <Compile Include="Runtime\Calls\RubyEventInfo.cs" /> <Compile Include="Runtime\RubyExceptionData.cs" /> @@ -359,7 +361,7 @@ <Compile Include="Runtime\RubyScope.cs" /> <Compile Include="Runtime\RubyScriptCode.cs" /> <Compile Include="Runtime\RubyUtils.cs" /> - <Compile Include="Runtime\RuntimeFlowControl.cs" /> + <Compile Include="Runtime\RubyOps.FlowControl.cs" /> <Compile Include="Runtime\RuntimeErrorSink.cs" /> <Compile Include="Runtime\StackUnwinder.cs" /> <Compile Include="Runtime\Key.cs" /> @@ -377,8 +379,9 @@ <Compile Include="RubyCompatibility.cs" /> <Compile Include="Runtime\IOWrapper.cs" /> <None Include="Compiler\Parser\Parser.y" /> + <None Include="Migrated rules for Ruby.ruleset" /> <None Include="Runtime\Calls\MethodDispatcher.Generator.rb" /> - <None Include="Runtime\Converter.Generator.rb" /> + <None Include="Runtime\Conversions\Converter.Generator.rb" /> </ItemGroup> <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" Condition=" $(SilverlightTreeBuild) != 'true' " /> <Target Name="BeforeBuild"> Merlin/Main/Languages/Ruby/Ruby/Ruby.csproj @@ -307,6 +307,23 @@ namespace IronRuby.Runtime { } } + [AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = true)] + public sealed class AliasMethodAttribute : Attribute { + private readonly string/*!*/ _oldName, _newName; + private bool _isStatic; + + public string/*!*/ NewName { get { return _newName; } } + public string/*!*/ OldName { get { return _oldName; } } + public bool IsStatic { get { return _isStatic; } set { _isStatic = value; } } + + public AliasMethodAttribute(string/*!*/ newName, string/*!*/ oldName) { + ContractUtils.RequiresNotNull(newName, "newName"); + ContractUtils.RequiresNotNull(oldName, "oldName"); + _newName = newName; + _oldName = oldName; + } + } + [AttributeUsage(AttributeTargets.Method, AllowMultiple = false)] public sealed class RubyStackTraceHiddenAttribute : Attribute { } Merlin/Main/Languages/Ruby/Ruby/Runtime/Attributes.cs @@ -1,9 +1,21 @@ -using System; -using System.Collections.Generic; -using System.Text; +/* **************************************************************************** + * + * Copyright (c) Microsoft Corporation. + * + * This source code is subject to terms and conditions of the Microsoft Public License. A + * copy of the license can be found in the License.html file at the root of this distribution. If + * you cannot locate the Microsoft Public License, please send an email to + * ironruby@microsoft.com. By using this source code in any fashion, you are agreeing to be bound + * by the terms of the Microsoft Public License. + * + * You must not remove this notice, or any other, from this software. + * + * + * ***************************************************************************/ + +using System.IO; using Microsoft.Scripting; using Microsoft.Scripting.Utils; -using System.IO; namespace IronRuby.Runtime { internal sealed class BinaryContentProvider : StreamContentProvider { Merlin/Main/Languages/Ruby/Ruby/Runtime/BinaryContentProvider.cs @@ -14,25 +14,12 @@ * ***************************************************************************/ using System; -using System.Collections.Generic; -using System.Diagnostics; -using System.Linq.Expressions; -using System.Reflection; -using System.Runtime.Serialization; -using System.Text; -using System.Threading; -using Microsoft.Scripting; -using Microsoft.Scripting.Actions; -using Microsoft.Scripting.Runtime; -using Microsoft.Scripting.Utils; -using IronRuby.Builtins; -using IronRuby.Compiler; -using IronRuby.Runtime.Calls; -using System.Dynamic; -using Microsoft.Scripting.Math; using System.Runtime.CompilerServices; -using Microsoft.Scripting.Generation; using IronRuby.Compiler.Generation; +using IronRuby.Runtime.Calls; +using IronRuby.Runtime.Conversions; +using Microsoft.Scripting; +using Microsoft.Scripting.Utils; namespace IronRuby.Runtime { @@ -98,5 +85,10 @@ namespace IronRuby.Runtime { public CallSite<Func<CallSite, object, TResult>>/*!*/ GetSite(RubyConversionAction/*!*/ conversion) { return RubyUtils.GetCallSite(ref Site, conversion); } + + internal CallSite<Func<CallSite, object, TResult>>/*!*/ GetDefaultConversionSite() { + return RubyUtils.GetCallSite(ref Site, ProtocolConversionAction.GetConversionAction(Context, typeof(TResult), true)); + + } } } Merlin/Main/Languages/Ruby/Ruby/Runtime/CallSiteStorages.cs @@ -596,6 +596,16 @@ namespace IronRuby.Runtime.Calls { ); } + public static DynamicMetaObject/*!*/ Bind(DynamicMetaObject/*!*/ context, ConvertBinder/*!*/ binder, + DynamicMetaObject/*!*/ target, Func<DynamicMetaObject, DynamicMetaObject, DynamicMetaObject>/*!*/ fallback) { + + // TODO: + return null; + //return InvokeMember.Bind(context, RubyUtils.MapOperator(binder.Operation), _CallInfo, binder, target, new[] { arg }, + // (trgt, args) => fallback(trgt, args[0]) + //); + } + public override string/*!*/ ToString() { return String.Format("Interop.Convert({0}, {1}){2}", Type.Name, Merlin/Main/Languages/Ruby/Ruby/Runtime/Calls/InteropBinder.cs @@ -21,6 +21,7 @@ using Microsoft.Scripting.Actions.Calls; using Microsoft.Scripting.Utils; using System.Threading; using System.Diagnostics; +using IronRuby.Runtime.Conversions; namespace IronRuby.Runtime.Calls { public sealed class RubyBinder : DefaultBinder { @@ -46,7 +47,7 @@ namespace IronRuby.Runtime.Calls { } public override bool CanConvertFrom(Type/*!*/ fromType, Type/*!*/ toType, bool toNotNullable, NarrowingLevel level) { - return Converter.CanConvertFrom(fromType, toType, level, true); + return Converter.CanConvertFrom(null, fromType, toType, toNotNullable, level, false, false); } public override Candidate PreferConvert(Type t1, Type t2) { Merlin/Main/Languages/Ruby/Ruby/Runtime/Calls/RubyBinder.cs @@ -22,6 +22,7 @@ using Microsoft.Scripting.Utils; using IronRuby.Builtins; using IronRuby.Compiler; using AstUtils = Microsoft.Scripting.Ast.Utils; +using IronRuby.Runtime.Conversions; namespace IronRuby.Runtime.Calls { using Ast = System.Linq.Expressions.Expression; Merlin/Main/Languages/Ruby/Ruby/Runtime/Calls/RubyFieldInfo.cs @@ -4,6 +4,7 @@ using System.Text; using Microsoft.Scripting.Utils; using System.Threading; using System.Dynamic; +using IronRuby.Runtime.Conversions; namespace IronRuby.Runtime.Calls { internal sealed class RubyMetaBinderFactory { Merlin/Main/Languages/Ruby/Ruby/Runtime/Calls/RubyMetaBinderFactory.cs @@ -29,7 +29,7 @@ using AstUtils = Microsoft.Scripting.Ast.Utils; namespace IronRuby.Runtime.Calls { using Ast = System.Linq.Expressions.Expression; - interface IRubyDynamicMetaObjectProvider : IDynamicMetaObjectProvider { + public interface IRubyDynamicMetaObjectProvider : IDynamicMetaObjectProvider { } public abstract class RubyMetaObject : DynamicMetaObject { @@ -72,6 +72,11 @@ namespace IronRuby.Runtime.Calls { public override DynamicMetaObject/*!*/ BindBinaryOperation(BinaryOperationBinder/*!*/ binder, DynamicMetaObject/*!*/ arg) { return InteropBinder.BinaryOperation.Bind(CreateMetaContext(), binder, this, arg, binder.FallbackBinaryOperation); } + + // TODO: + //public override DynamicMetaObject/*!*/ BindConvert(ConvertBinder/*!*/ binder) { + // return InteropBinder.Convert.Bind(CreateMetaContext(), binder, this, binder.FallbackConvert); + //} } public abstract class RubyMetaObject<T> : RubyMetaObject { Merlin/Main/Languages/Ruby/Ruby/Runtime/Calls/RubyMetaObject.cs @@ -23,6 +23,7 @@ using System.Reflection; using System.Text; using IronRuby.Builtins; using IronRuby.Compiler; +using IronRuby.Runtime.Conversions; using Microsoft.Scripting.Actions.Calls; using Microsoft.Scripting.Generation; using Microsoft.Scripting.Runtime; @@ -38,14 +39,11 @@ namespace IronRuby.Runtime.Calls { // // We want to perform Ruby protocol conversions when binding to CLR methods. - // However, Ruby some libraries don't allow protocol conversions on their parameters. + // However, some Ruby libraries don't allow protocol conversions on their parameters. // Hence in libraries protocol conversions should only be performed when DefaultProtocol attribute is present. // This flag is set if protocol conversions should be applied on all parameters regardless of DefaultProtocol attribute. - // - // Note that using DefaultProtocol explicitly is not the same as performing implicit protocol conversions. - // A parameter marked with DP is treated as accepting any type of object for overload resolution purposes. - // On the other hand, implicit protocol conversions are only applied on narrowing level 2. Hence the overload resolution - // uses the real parameter types in first 2 steps and only then falls back to dynamic conversions. + // This also implies a different narrowing level of the protocol conversions for library methods and other CLR methods + // (see Converter.CanConvertFrom). // private readonly bool _implicitProtocolConversions; @@ -416,85 +414,70 @@ namespace IronRuby.Runtime.Calls { #region Step 4: Argument Building, Conversions - public override bool CanConvertFrom(Type/*!*/ fromType, ParameterWrapper/*!*/ toParameter, NarrowingLevel level) { - Type toType = toParameter.Type; - - if (toType == fromType) { - return true; - } - - if (fromType == typeof(DynamicNull)) { - if (toParameter.ProhibitNull) { - return false; - } - - if (toType.IsGenericType && toType.GetGenericTypeDefinition() == typeof(Nullable<>)) { - return true; - } - - if (!toType.IsValueType) { - return true; - } - } - - // blocks: - if (fromType == typeof(MissingBlockParam)) { - return toType == typeof(BlockParam) && !toParameter.ProhibitNull; - } - - if (fromType == typeof(BlockParam) && toType == typeof(MissingBlockParam)) { - return true; - } - - // protocol conversions: - if (toParameter.ParameterInfo != null && toParameter.ParameterInfo.IsDefined(typeof(DefaultProtocolAttribute), false) && - // default protocol doesn't apply on param-array/dict itself, only on the expanded parameters: - !toParameter.IsParamsArray) { - - // any type is potentially convertible, except for nil if [NotNull] is used or the target type is a value type: - return fromType != typeof(DynamicNull) || !(toParameter.ProhibitNull || toType.IsValueType); - } + /// <summary> + /// Returns true if fromArg of type fromType can be assigned to toParameter with a conversion on given narrowing level. + /// </summary> + public override bool CanConvertFrom(Type/*!*/ fromType, DynamicMetaObject fromArg, ParameterWrapper/*!*/ toParameter, NarrowingLevel level) { + return Converter.CanConvertFrom(fromArg, fromType, toParameter.Type, toParameter.ProhibitNull, level, + HasExplicitProtocolConversion(toParameter), _implicitProtocolConversions + ); + } - if (Converter.CanConvertFrom(fromType, toType, level, _implicitProtocolConversions)) { - return true; - } + public override bool CanConvertFrom(ParameterWrapper/*!*/ fromParameter, ParameterWrapper/*!*/ toParameter) { + return Converter.CanConvertFrom(null, fromParameter.Type, toParameter.Type, toParameter.ProhibitNull, NarrowingLevel.None, false, false); + } - return false; + private bool HasExplicitProtocolConversion(ParameterWrapper/*!*/ parameter) { + return + parameter.ParameterInfo != null && + parameter.ParameterInfo.IsDefined(typeof(DefaultProtocolAttribute), false) && + !parameter.IsParamsArray; // default protocol doesn't apply on param-array/dict itself, only on the expanded parameters } - public override Candidate SelectBestConversionFor(Type/*!*/ actualType, ParameterWrapper/*!*/ candidateOne, ParameterWrapper/*!*/ candidateTwo, NarrowingLevel level) { + public override Candidate SelectBestConversionFor(DynamicMetaObject/*!*/ arg, ParameterWrapper/*!*/ candidateOne, + ParameterWrapper/*!*/ candidateTwo, NarrowingLevel level) { + Type typeOne = candidateOne.Type; Type typeTwo = candidateTwo.Type; + Type actualType = arg.GetLimitType(); + // if nil is passed as a block argument prefer BlockParam over missing block: if (actualType == typeof(DynamicNull)) { - // if nil is passed as a block argument prefer BlockParam over missing block; if (typeOne == typeof(BlockParam) && typeTwo == typeof(MissingBlockParam)) { + Debug.Assert(!candidateOne.ProhibitNull); return Candidate.One; } if (typeOne == typeof(MissingBlockParam) && typeTwo == typeof(BlockParam)) { + Debug.Assert(!candidateTwo.ProhibitNull); return Candidate.Two; } - } else { - if (actualType == typeOne && candidateOne.ProhibitNull) { + } else if (actualType == typeof(MissingBlockParam)) { + if (typeOne == typeof(BlockParam) && typeTwo == typeof(MissingBlockParam)) { + return Candidate.Two; + } + + if (typeOne == typeof(MissingBlockParam) && typeTwo == typeof(BlockParam)) { + return Candidate.One; + } + } else if (actualType == typeof(BlockParam)) { + if (typeOne == typeof(BlockParam) && typeTwo == typeof(MissingBlockParam)) { return Candidate.One; } - if (actualType == typeTwo && candidateTwo.ProhibitNull) { + if (typeOne == typeof(MissingBlockParam) && typeTwo == typeof(BlockParam)) { return Candidate.Two; } - } - if (actualType == typeOne) { - return Candidate.One; - } - - if (actualType == typeTwo) { - return Candidate.Two; + if (typeOne == typeof(BlockParam) && typeTwo == typeof(BlockParam)) { + if (candidateOne.ProhibitNull) { + return Candidate.One; + } else if (candidateTwo.ProhibitNull) { + return Candidate.Two; + } + } } - - - return Candidate.Equivalent; + return base.SelectBestConversionFor(arg, candidateOne, candidateTwo, level); } public override Expression/*!*/ Convert(DynamicMetaObject/*!*/ metaObject, Type restrictedType, ParameterInfo info, Type/*!*/ toType) { @@ -519,7 +502,8 @@ namespace IronRuby.Runtime.Calls { return Ast.Dynamic(action, toType, expr); } - throw new InvalidOperationException(String.Format("No default protocol conversion for type {0}.", toType)); + // Do not throw an exception here to allow generic type parameters to be used with D.P. attribute. + // The semantics should be to use DP if available for the current instantiation and ignore it otherwise. } if (restrictedType != null) { @@ -538,7 +522,7 @@ namespace IronRuby.Runtime.Calls { // if there is a simple conversion from restricted type, convert the expression to the restricted type and use that conversion: Type visibleRestrictedType = CompilerHelpers.GetVisibleType(restrictedType); - if (Converter.CanConvertFrom(visibleRestrictedType, toType, NarrowingLevel.One, false)) { + if (Converter.CanConvertFrom(metaObject, visibleRestrictedType, toType, false, NarrowingLevel.None, false, false)) { expr = AstUtils.Convert(expr, visibleRestrictedType); } } @@ -765,9 +749,18 @@ namespace IronRuby.Runtime.Calls { return Methods.CreateArgumentsErrorForMissingBlock.OpCall(); } + string toType; + if (cr.To.IsGenericType && cr.To.GetGenericTypeDefinition() == typeof(Union<,>)) { + var g = cr.To.GetGenericArguments(); + toType = Binder.GetTypeName(g[0]) + " or " + Binder.GetTypeName(g[1]); + } else { + toType = Binder.GetTypeName(cr.To); + } + return Methods.CreateTypeConversionError.OpCall( - AstUtils.Constant(cr.GetArgumentTypeName(Binder)), - AstUtils.Constant(Binder.GetTypeName(cr.To))); + AstUtils.Constant(cr.GetArgumentTypeName(Binder)), + AstUtils.Constant(toType) + ); } } break; Merlin/Main/Languages/Ruby/Ruby/Runtime/Calls/RubyOverloadResolver.cs @@ -28,6 +28,7 @@ using IronRuby.Runtime.Calls; using Microsoft.Scripting; using Microsoft.Scripting.Runtime; using Microsoft.Scripting.Utils; +using IronRuby.Runtime.Conversions; namespace IronRuby.Runtime { [Flags] Merlin/Main/Languages/Ruby/Ruby/Runtime/Loader.cs @@ -26,6 +26,7 @@ using Microsoft.Scripting.Generation; using IronRuby.Builtins; using IronRuby.Runtime.Calls; using IronRuby.Compiler; +using IronRuby.Runtime.Conversions; namespace IronRuby.Runtime { /// <summary> Merlin/Main/Languages/Ruby/Ruby/Runtime/Protocols.cs @@ -16,22 +16,22 @@ using System; using System.Collections.Generic; using System.Diagnostics; +using System.Dynamic; using System.IO; using System.Runtime.CompilerServices; -using System.Dynamic; using System.Security; using System.Text; using System.Threading; using IronRuby.Builtins; using IronRuby.Compiler; +using IronRuby.Compiler.Ast; using IronRuby.Compiler.Generation; using IronRuby.Runtime.Calls; +using IronRuby.Runtime.Conversions; using Microsoft.Scripting; using Microsoft.Scripting.Actions; -using Microsoft.Scripting.Generation; using Microsoft.Scripting.Runtime; using Microsoft.Scripting.Utils; -using IronRuby.Compiler.Ast; using MSA = System.Linq.Expressions; namespace IronRuby.Runtime { @@ -718,7 +718,16 @@ namespace IronRuby.Runtime { } TypeTracker tracker = (TypeTracker)TypeTracker.FromMemberInfo(interfaceType); - result = CreateModule(GetQualifiedNameNoLock(interfaceType), null, null, null, null, null, tracker, ModuleRestrictions.None); + + RubyModule[] mixins; + if (interfaceType.IsGenericType && !interfaceType.IsGenericTypeDefinition) { + // I<T0..Tn> mixes in its generic definition I<,..,> + mixins = new[] { GetOrCreateModuleNoLock(interfaceType.GetGenericTypeDefinition()) }; + } else { + mixins = null; + } + + result = CreateModule(GetQualifiedNameNoLock(interfaceType), null, null, null, mixins, null, tracker, ModuleRestrictions.None); _moduleCache[interfaceType] = result; return result; } @@ -731,7 +740,15 @@ namespace IronRuby.Runtime { return result; } - RubyClass baseClass = GetOrCreateClassNoLock(type.BaseType); + RubyClass baseClass; + + if (type.IsGenericType && !type.IsGenericTypeDefinition) { + // C<T0..Tn>'s super class is its generic definition C<,..,> + baseClass = GetOrCreateClassNoLock(type.GetGenericTypeDefinition()); + } else { + baseClass = GetOrCreateClassNoLock(type.BaseType); + } + TypeTracker tracker = (TypeTracker)TypeTracker.FromMemberInfo(type); RubyModule[] interfaceMixins = GetDeclaredInterfaceModulesNoLock(type); RubyModule[] expandedMixins; Merlin/Main/Languages/Ruby/Ruby/Runtime/RubyContext.cs @@ -34,6 +34,7 @@ using Microsoft.Scripting.Runtime; using Microsoft.Scripting.Utils; using IronRuby.Compiler.Ast; using MSA = System.Linq.Expressions; +using IronRuby.Runtime.Conversions; namespace IronRuby.Runtime { [ReflectionCached, CLSCompliant(false)] @@ -849,70 +850,70 @@ namespace IronRuby.Runtime { #region CLR Vectors (factories mimic Ruby Array factories) [Emitted, RubyConstructor] - public static object/*!*/ CreateVector(ConversionStorage<Union<IList, int>>/*!*/ toAryToInt, BlockParam block, RubyClass/*!*/ self, - [NotNull]object/*!*/ arrayOrSize) { + public static object/*!*/ CreateVector<TElement>( + ConversionStorage<TElement>/*!*/ elementConversion, + ConversionStorage<Union<IList, int>>/*!*/ toAryToInt, + BlockParam block, RubyClass/*!*/ self, [NotNull]object/*!*/ arrayOrSize) { - var elementType = self.GetUnderlyingSystemType().GetElementType(); - Debug.Assert(elementType != null); + Debug.Assert(typeof(TElement) == self.GetUnderlyingSystemType().GetElementType()); var site = toAryToInt.GetSite(CompositeConversionAction.Make(self.Context, CompositeConversion.ToAryToInt)); var union = site.Target(site, arrayOrSize); if (union.First != null) { // block ignored - return CreateVectorInternal(self.Context, elementType, union.First); + return CreateVectorInternal(elementConversion, union.First); } else if (block != null) { - return PopulateVector(self.Context, CreateVectorInternal(elementType, union.Second), block); + return PopulateVector(elementConversion, CreateVectorInternal<TElement>(union.Second), block); } else { - return CreateVectorInternal(elementType, union.Second); + return CreateVectorInternal<TElement>(union.Second); } } [Emitted, RubyConstructor] - public static Array/*!*/ CreateVectorWithValues(RubyClass/*!*/ self, [DefaultProtocol]int size, object value) { - var elementType = self.GetUnderlyingSystemType().GetElementType(); - Debug.Assert(elementType != null); + public static Array/*!*/ CreateVectorWithValues<TElement>(ConversionStorage<TElement>/*!*/ elementConversion, + RubyClass/*!*/ self, [DefaultProtocol]int size, [DefaultProtocol]TElement value) { + Debug.Assert(typeof(TElement) == self.GetUnderlyingSystemType().GetElementType()); - var result = CreateVectorInternal(elementType, size); - for (int i = 0; i < size; i++) { - SetVectorItem(self.Context, result, i, value); + TElement[] result = CreateVectorInternal<TElement>(size); + for (int i = 0; i < result.Length; i++) { + result[i] = value; } return result; } - public static Array/*!*/ CreateVectorInternal(Type/*!*/ elementType, int size) { + private static TElement[]/*!*/ CreateVectorInternal<TElement>(int size) { if (size < 0) { throw RubyExceptions.CreateArgumentError("negative array size"); } - return Array.CreateInstance(elementType, size); + return new TElement[size]; } - private static Array/*!*/ CreateVectorInternal(RubyContext/*!*/ context, Type/*!*/ elementType, IList/*!*/ list) { - var result = Array.CreateInstance(elementType, list.Count); + private static Array/*!*/ CreateVectorInternal<TElement>(ConversionStorage<TElement>/*!*/ elementConversion, IList/*!*/ list) { + var site = elementConversion.GetDefaultConversionSite(); + + var result = new TElement[list.Count]; for (int i = 0; i < result.Length; i++) { - SetVectorItem(context, result, i, list[i]); + result[i] = site.Target(site, list[i]); } return result; } - private static object PopulateVector(RubyContext/*!*/ context, Array/*!*/ array, BlockParam/*!*/ block) { + private static object PopulateVector<TElement>(ConversionStorage<TElement>/*!*/ elementConversion, TElement[]/*!*/ array, BlockParam/*!*/ block) { + var site = elementConversion.GetDefaultConversionSite(); + for (int i = 0; i < array.Length; i++) { object item; if (block.Yield(i, out item)) { return item; } - SetVectorItem(context, array, i, item); + array[i] = site.Target(site, item); } return array; } - private static void SetVectorItem(RubyContext/*!*/ context, Array/*!*/ array, int index, object value) { - // TODO: convert to the element type: - array.SetValue(value, index); - } - #endregion #region Global Variables Merlin/Main/Languages/Ruby/Ruby/Runtime/RubyOps.cs @@ -30,6 +30,7 @@ using Microsoft.Scripting; using Microsoft.Scripting.Math; using Microsoft.Scripting.Runtime; using Microsoft.Scripting.Utils; +using IronRuby.Runtime.Conversions; namespace IronRuby.Runtime { using EvalEntryPointDelegate = Func<RubyScope, object, RubyModule, Proc, object>; Merlin/Main/Languages/Ruby/Ruby/Runtime/RubyUtils.cs @@ -42,10 +42,29 @@ if exist "%PROGRAM_FILES_32%\Microsoft.NET\SDK\v2.0\Bin\sdkvars.bat" ( set PATH=%PATH%;%MERLIN_ROOT%\Languages\Ruby\Scripts;%MERLIN_ROOT%\Languages\Ruby\Scripts\bin;%RUBY18_BIN%;%MERLIN_ROOT%\..\External.LCA_RESTRICTED\Languages\IronRuby\mspec\mspec\bin +if not DEFINED HOME_FOR_MSPECRC ( + if DEFINED HOME ( + set HOME_FOR_MSPECRC=%HOME% + goto SetRubyEnv + ) + + if DEFINED HOMEDRIVE ( + if DEFINED HOMEPATH ( + set HOME_FOR_MSPECRC=%HOMEDRIVE%%HOMEPATH% + goto SetRubyEnv + ) + ) + if not DEFINED USERPROFILE ( + echo Error: One of HOME, HOMEDRIVE,HOMEPATH, or USERPROFILE needs to be set + goto END + ) + set HOME_FOR_MSPECRC=%USERPROFILE% +) + :SetRubyEnv -if NOT exist "%HOME%\.mspecrc" ( - copy "%MERLIN_ROOT%\Languages\Ruby\default.mspec" "%HOME%\.mspecrc" +if NOT EXIST "%HOME_FOR_MSPECRC%\.mspecrc" ( + copy "%MERLIN_ROOT%\Languages\Ruby\default.mspec" "%HOME_FOR_MSPECRC%\.mspecrc" ) call doskey /macrofile=%MERLIN_ROOT%\Scripts\Bat\%Alias.txt Merlin/Main/Languages/Ruby/Scripts/Dev.bat Merlin/Main/Languages/Ruby/Tests/Interop/net/A/a.generated.dll Merlin/Main/Languages/Ruby/Tests/Interop/net/B/b.generated.dll @@ -6,6 +6,6 @@ describe "Modifying .NET arrays" do end it "doesn't dynamicly resize" do - lambda {@array[10] = 1}.should raise_error(System::NotSupportedException) + lambda {@array[10] = 1}.should raise_error(IndexError) end end Merlin/Main/Languages/Ruby/Tests/Interop/net/bcl/array/modification_spec.rb @@ -23,6 +23,7 @@ describe "System::String.new" do System::String.new(System::Char.new("a")).should == Klass.new.a System::String.new(System::Char.new("a"), 2).should == Klass.new.Aa System::String.new(System::Array.of(System::Char).new(2, System::Char.new("a"))).should == Klass.new.Aa + System::String.new(System::Array.of(System::Char).new(1),0,0).should == System::String.empty end end Merlin/Main/Languages/Ruby/Tests/Interop/net/bcl/string/construction_spec.rb @@ -26,4 +26,28 @@ describe "Inheriting from classes with" do end + + describe "method attributes that are abstract" do + #TODO: the marshal attribute shouldn't be needed. this was due to a super + #bug not a marshal bug. + csc <<-EOL + public abstract class Unsafe { + [return: MarshalAs(UnmanagedType.U1)] + public virtual bool Foo() { return true;} + } + EOL + + before(:all) do + class SubUnsafe < Unsafe + end + end + + it "can call super" do + lambda {class SubUnsafe < Unsafe + def foo + super + end + end}.should_not raise_error + end + end end Merlin/Main/Languages/Ruby/Tests/Interop/net/class/derivation/attribute_spec.rb @@ -123,6 +123,11 @@ public class ClassWithOptionalConstructor { Arg = arg; } } +#line 31 "./class/derivation/attribute_spec.rb" +public abstract class Unsafe { + [return: MarshalAs(UnmanagedType.U1)] + public virtual bool Foo() { return true;} + } #line 14 "./class/instantiation/abstract_spec.rb" public partial class DerivedFromAbstract : AbstractClass { public override int m() {return 1;} @@ -746,6 +751,10 @@ public partial class ClassWithIndexer { set { Values[i,j] = value; } } } +#line 5 "./method/invocation/internal_spec.rb" +internal partial class PartialClassWithMethods { + internal int Foo(){ return 1; } + } #line 4 "./method/invocation/overload_spec.rb" public partial class ClassWithOverloads { public string PublicProtectedOverload(){ @@ -821,8 +830,16 @@ public class PublicNameHolder { public string Mixed_Snake_case() {return "Mixed_Snake_case";} public string CAPITAL() { return "CAPITAL";} public string PartialCapitalID() { return "PartialCapitalID";} + public string PartialCapitalId() { return "PartialCapitalId";} public string __LeadingCamelCase() { return "__LeadingCamelCase";} public string __leading_snake_case() { return "__leading_snake_case";} + public string foNBar() { return "foNBar"; } + public string fNNBar() { return "fNNBar"; } + public string NNNBar() { return "NNNBar"; } + public string MyUIApp() { return "MyUIApp"; } + public string MyIdYA() { return "MyIdYA"; } + public string NaN() { return "NaN"; } + public string NaNa() { return "NaNa"; } } public class SubPublicNameHolder : PublicNameHolder { Merlin/Main/Languages/Ruby/Tests/Interop/net/fixtures.generated.cs Merlin/Main/Languages/Ruby/Tests/Interop/net/fixtures.generated.dll @@ -11,19 +11,29 @@ describe "Name mangling on public types" do public string Mixed_Snake_case() {return "Mixed_Snake_case";} public string CAPITAL() { return "CAPITAL";} public string PartialCapitalID() { return "PartialCapitalID";} + public string PartialCapitalId() { return "PartialCapitalId";} public string __LeadingCamelCase() { return "__LeadingCamelCase";} public string __leading_snake_case() { return "__leading_snake_case";} + public string foNBar() { return "foNBar"; } + public string fNNBar() { return "fNNBar"; } + public string NNNBar() { return "NNNBar"; } + public string MyUIApp() { return "MyUIApp"; } + public string MyIdYA() { return "MyIdYA"; } + public string NaN() { return "NaN"; } + public string NaNa() { return "NaNa"; } } public class SubPublicNameHolder : PublicNameHolder { } EOL + @methods = %w{Unique snake_case CamelCase PartialCapitalId __LeadingCamelCase __leading_snake_case fNNBar MyUIApp MyIdYA NaNa Mixed_Snake_case} before(:each) do @objs = [PublicNameHolder.new, SubPublicNameHolder.new, Class.new(PublicNameHolder).new, Class.new(SubPublicNameHolder).new] @a_methods = %w{a A} - @methods = %w{Unique snake_case CamelCase Mixed_Snake_case CAPITAL PartialCapitalID __LeadingCamelCase __leading_snake_case} - @all_methods = @methods + @a_methods + @methods << "foNBar" + @non_mangle_methods = %w{NNNBar NaN CAPITAL PartialCapitalID } + @all_methods = @methods + @a_methods + @non_mangle_methods end it "works with correct .NET names" do @@ -34,8 +44,8 @@ describe "Name mangling on public types" do end end - it "works with mangled name if not conflicting" do - @methods.each do |meth| + @methods.each do |meth| + it "works with mangled name (#{meth}) if not conflicting" do @objs.each do |obj| obj.send(meth.to_snake_case).should equal_clr_string(meth) end Merlin/Main/Languages/Ruby/Tests/Interop/net/ruby/name_mangling/public_spec.rb @@ -1 +1,4 @@ -fails:Name mangling on public types works with mangled name if not conflicting +fails:Name mangling on public types works with mangled name (__LeadingCamelCase) if not conflicting +fails:Name mangling on public types works with mangled name (fNNBar) if not conflicting +fails:Name mangling on public types works with mangled name (NaNa) if not conflicting +fails:Name mangling on public types works with mangled name (Mixed_Snake_case) if not conflicting Merlin/Main/Languages/Ruby/Tests/Interop/tags/net/ruby/name_mangling/public_tags.txt @@ -1,16 +1,16 @@ <?xml version="1.0" encoding="utf-8"?> -<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> +<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> <PropertyGroup> <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> - <ProductVersion>9.0.30729</ProductVersion> + <ProductVersion>10.0.20624</ProductVersion> <SchemaVersion>2.0</SchemaVersion> <ProjectGuid>{534A82C6-3EB0-4888-ABD2-A15284683E8D}</ProjectGuid> <OutputType>Exe</OutputType> <AppDesignerFolder>Properties</AppDesignerFolder> <RootNamespace>RubySpec</RootNamespace> <AssemblyName>RubySpec</AssemblyName> - <TargetFrameworkVersion>v3.5</TargetFrameworkVersion> + <TargetFrameworkVersion>v2.0</TargetFrameworkVersion> <FileAlignment>512</FileAlignment> <SccProjectName>SAK</SccProjectName> <SccLocalPath>SAK</SccLocalPath> Merlin/Main/Languages/Ruby/Tests/RubySpec/RubySpec.csproj @@ -363,7 +363,7 @@ namespace Microsoft.Scripting.Actions.Calls { return MakeSuccessfulBindingTarget(applicable[0], potential, level, targetSet); } - var bestCandidate = SelectBestCandidate(applicable); + var bestCandidate = SelectBestCandidate(applicable, level); if (bestCandidate != null) { return MakeSuccessfulBindingTarget(bestCandidate, potential, level, targetSet); } else { @@ -472,7 +472,7 @@ namespace Microsoft.Scripting.Actions.Calls { bool success = true; for (int i = 0; i < _actualArguments.Count; i++) { - success &= (hasConversion[i] = CanConvertFrom(_actualArguments[i].GetLimitType(), candidate.GetParameter(i, namesBinding), narrowingLevel)); + success &= (hasConversion[i] = CanConvertFrom(_actualArguments[i].GetLimitType(), _actualArguments[i], candidate.GetParameter(i, namesBinding), narrowingLevel)); } if (!success) { @@ -499,7 +499,7 @@ namespace Microsoft.Scripting.Actions.Calls { object value = GetCollapsedArgumentValue(i); Type argType = CompilerHelpers.GetType(value); - if (!CanConvertFrom(argType, parameter, narrowingLevel)) { + if (!CanConvertFrom(argType, null, parameter, narrowingLevel)) { failure = new CallFailure(candidate, new[] { new ConversionResult(value, argType, parameter.Type, false) }); return false; } @@ -598,21 +598,21 @@ namespace Microsoft.Scripting.Actions.Calls { return false; } - private bool IsBest(ApplicableCandidate candidate, List<ApplicableCandidate> candidates) { + private bool IsBest(ApplicableCandidate candidate, List<ApplicableCandidate> candidates, NarrowingLevel level) { foreach (ApplicableCandidate other in candidates) { if (candidate == other) { continue; } - if (GetPreferredCandidate(candidate, other) != Candidate.One) { + if (GetPreferredCandidate(candidate, other, level) != Candidate.One) { return false; } } return true; } - internal Candidate GetPreferredCandidate(ApplicableCandidate one, ApplicableCandidate two) { - Candidate cmpParams = GetPreferredParameters(one, two); + internal Candidate GetPreferredCandidate(ApplicableCandidate one, ApplicableCandidate two, NarrowingLevel level) { + Candidate cmpParams = GetPreferredParameters(one, two, level); if (cmpParams.Chosen()) { return cmpParams; } @@ -692,13 +692,13 @@ namespace Microsoft.Scripting.Actions.Calls { return max; } - internal Candidate GetPreferredParameters(ApplicableCandidate one, ApplicableCandidate two) { + private Candidate GetPreferredParameters(ApplicableCandidate one, ApplicableCandidate two, NarrowingLevel level) { Debug.Assert(one.Method.ParameterCount == two.Method.ParameterCount); var args = GetActualArguments(); Candidate result = Candidate.Equivalent; for (int i = 0; i < args.Count; i++) { - Candidate preferred = GetPreferredParameter(one.GetParameter(i), two.GetParameter(i), args[i].GetLimitType()); + Candidate preferred = GetPreferredParameter(one.GetParameter(i), two.GetParameter(i), args[i], level); switch (result) { case Candidate.Equivalent: @@ -729,46 +729,32 @@ namespace Microsoft.Scripting.Actions.Calls { return result; } - internal Candidate GetPreferredParameter(ParameterWrapper candidateOne, ParameterWrapper candidateTwo, Type argType) { - Assert.NotNull(candidateOne, candidateTwo, argType); - - if (ParametersEquivalent(candidateOne, candidateTwo)) { - return Candidate.Equivalent; - } - - for (NarrowingLevel curLevel = NarrowingLevel.None; curLevel <= NarrowingLevel.All; curLevel++) { - Candidate candidate = SelectBestConversionFor(argType, candidateOne, candidateTwo, curLevel); - if (candidate.Chosen()) { - return candidate; - } - } - - return GetPreferredParameter(candidateOne, candidateTwo); - } - - internal Candidate GetPreferredParameter(ParameterWrapper candidateOne, ParameterWrapper candidateTwo) { + private Candidate GetPreferredParameter(ParameterWrapper candidateOne, ParameterWrapper candidateTwo, DynamicMetaObject arg, NarrowingLevel level) { Assert.NotNull(candidateOne, candidateTwo); if (ParametersEquivalent(candidateOne, candidateTwo)) { return Candidate.Equivalent; } - Type t1 = candidateOne.Type; - Type t2 = candidateTwo.Type; + Candidate candidate = SelectBestConversionFor(arg, candidateOne, candidateTwo, level); + if (candidate.Chosen()) { + return candidate; + } - if (CanConvertFrom(t2, candidateOne, NarrowingLevel.None)) { - if (CanConvertFrom(t1, candidateTwo, NarrowingLevel.None)) { + if (CanConvertFrom(candidateTwo, candidateOne)) { + if (CanConvertFrom(candidateOne, candidateTwo)) { return Candidate.Ambiguous; } else { return Candidate.Two; } - } - - if (CanConvertFrom(t1, candidateTwo, NarrowingLevel.None)) { + } else if (CanConvertFrom(candidateOne, candidateTwo)) { return Candidate.One; } // Special additional rules to order numeric value types + Type t1 = candidateOne.Type; + Type t2 = candidateTwo.Type; + Candidate preferred = PreferConvert(t1, t2); if (preferred.Chosen()) { return preferred; @@ -779,12 +765,38 @@ namespace Microsoft.Scripting.Actions.Calls { return preferred; } - return Candidate.Ambiguous; + // consider the actual argument type: + Type argType = arg.GetLimitType(); + NarrowingLevel levelOne = NarrowingLevel.None; + while (levelOne < level && !CanConvertFrom(argType, arg, candidateOne, levelOne)) { + if (levelOne == NarrowingLevel.All) { + Debug.Assert(false, "Each argument should be convertible to the corresponding parameter"); + break; + } + levelOne++; + } + + NarrowingLevel levelTwo = NarrowingLevel.None; + while (levelTwo < level && !CanConvertFrom(argType, arg, candidateTwo, levelTwo)) { + if (levelTwo == NarrowingLevel.All) { + Debug.Assert(false, "Each argument should be convertible to the corresponding parameter"); + break; + } + levelTwo++; + } + + if (levelOne < levelTwo) { + return Candidate.One; + } else if (levelOne > levelTwo) { + return Candidate.Two; + } else { + return Candidate.Ambiguous; + } } - private ApplicableCandidate SelectBestCandidate(List<ApplicableCandidate> candidates) { + private ApplicableCandidate SelectBestCandidate(List<ApplicableCandidate> candidates, NarrowingLevel level) { foreach (var candidate in candidates) { - if (IsBest(candidate, candidates)) { + if (IsBest(candidate, candidates, level)) { return candidate; } } @@ -824,7 +836,11 @@ namespace Microsoft.Scripting.Actions.Calls { return parameter1.Type == parameter2.Type && parameter1.ProhibitNull == parameter2.ProhibitNull; } - public virtual bool CanConvertFrom(Type fromType, ParameterWrapper toParameter, NarrowingLevel level) { + public virtual bool CanConvertFrom(ParameterWrapper parameter1, ParameterWrapper parameter2) { + return CanConvertFrom(parameter1.Type, null, parameter2, NarrowingLevel.None); + } + + public virtual bool CanConvertFrom(Type fromType, DynamicMetaObject fromArgument, ParameterWrapper toParameter, NarrowingLevel level) { Assert.NotNull(fromType, toParameter); Type toType = toParameter.Type; @@ -853,7 +869,7 @@ namespace Microsoft.Scripting.Actions.Calls { /// <summary> /// Selects the best (of two) candidates for conversion from actualType /// </summary> - public virtual Candidate SelectBestConversionFor(Type actualType, ParameterWrapper candidateOne, ParameterWrapper candidateTwo, NarrowingLevel level) { + public virtual Candidate SelectBestConversionFor(DynamicMetaObject arg, ParameterWrapper candidateOne, ParameterWrapper candidateTwo, NarrowingLevel level) { return Candidate.Equivalent; } Merlin/Main/Runtime/Microsoft.Scripting/Actions/Calls/OverloadResolver.cs @@ -25,6 +25,10 @@ using ComTypes = System.Runtime.InteropServices.ComTypes; namespace Microsoft.Scripting.ComInterop { + /// <summary> + /// Cached information from a TLB. Only information that is required is saved. CoClasses are used + /// for event hookup. Enums are stored for accessing symbolic names from scripts. + /// </summary> public sealed class ComTypeLibDesc : IDynamicMetaObjectProvider { // typically typelibs contain very small number of coclasses @@ -120,14 +124,31 @@ namespace Microsoft.Scripting.ComInterop { typeLib.GetTypeInfoType(i, out typeKind); ComTypes.ITypeInfo typeInfo; + typeLib.GetTypeInfo(i, out typeInfo); if (typeKind == ComTypes.TYPEKIND.TKIND_COCLASS) { - typeLib.GetTypeInfo(i, out typeInfo); ComTypeClassDesc classDesc = new ComTypeClassDesc(typeInfo, typeLibDesc); typeLibDesc._classes.AddLast(classDesc); } else if (typeKind == ComTypes.TYPEKIND.TKIND_ENUM) { - typeLib.GetTypeInfo(i, out typeInfo); ComTypeEnumDesc enumDesc = new ComTypeEnumDesc(typeInfo, typeLibDesc); typeLibDesc._enums.Add(enumDesc.TypeName, enumDesc); + } + else if (typeKind == ComTypes.TYPEKIND.TKIND_ALIAS) { + ComTypes.TYPEATTR typeAttr = ComRuntimeHelpers.GetTypeAttrForTypeInfo(typeInfo); + if (typeAttr.tdescAlias.vt == (short)VarEnum.VT_USERDEFINED) { + string aliasName, documentation; + ComRuntimeHelpers.GetInfoFromType(typeInfo, out aliasName, out documentation); + + ComTypes.ITypeInfo referencedTypeInfo; + typeInfo.GetRefTypeInfo(typeAttr.tdescAlias.lpValue.ToInt32(), out referencedTypeInfo); + + ComTypes.TYPEATTR referencedTypeAttr = ComRuntimeHelpers.GetTypeAttrForTypeInfo(referencedTypeInfo); + ComTypes.TYPEKIND referencedTypeKind = referencedTypeAttr.typekind; + + if (referencedTypeKind == ComTypes.TYPEKIND.TKIND_ENUM) { + ComTypeEnumDesc enumDesc = new ComTypeEnumDesc(referencedTypeInfo, typeLibDesc); + typeLibDesc._enums.Add(aliasName, enumDesc); + } + } } } @@ -157,7 +178,6 @@ namespace Microsoft.Scripting.ComInterop { public string[] GetMemberNames() { string[] retval = new string[_enums.Count + _classes.Count]; int i = 0; - foreach (ComTypeClassDesc coclass in _classes) { retval[i++] = coclass.TypeName; } Merlin/Main/Runtime/Microsoft.Scripting/ComInterop/ComTypeLibDesc.cs @@ -18,6 +18,7 @@ using System.Collections.Generic; using System.Diagnostics; using System.IO; using System.Reflection; +using System.Reflection.Emit; using System.Runtime.CompilerServices; using System.Text; using System.Threading; @@ -163,7 +164,12 @@ namespace Microsoft.Scripting.Hosting.Shell { /// </summary> [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes")] public virtual int Run(string[] args) { - +#if !SILVERLIGHT + if (typeof(DynamicMethod).GetConstructor(new Type[] { typeof(string), typeof(Type), typeof(Type[]), typeof(bool) }) == null) { + Console.WriteLine("IronPython requires .NET 2.0 SP1 or later to run."); + Environment.Exit(1); + } +#endif var runtimeSetup = CreateRuntimeSetup(); var options = new ConsoleHostOptions(); _optionsParser = new ConsoleHostOptionsParser(options, runtimeSetup); Merlin/Main/Runtime/Microsoft.Scripting/Hosting/Shell/ConsoleHost.cs Merlin/Main/Runtime/Microsoft.Scripting/Microsoft.Scripting.Build.csproj @@ -1,8 +1,9 @@ -<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="3.5"> +<?xml version="1.0" encoding="utf-8"?> +<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0"> <PropertyGroup> <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> - <ProductVersion>9.0.30729</ProductVersion> + <ProductVersion>10.0.20624</ProductVersion> <SchemaVersion>2.0</SchemaVersion> <ProjectGuid>{EB66B766-6354-4208-A3D4-AACBDCB5C3B3}</ProjectGuid> <OutputType>Library</OutputType> @@ -16,13 +17,13 @@ <DocumentationFile>..\..\Bin\Release\Microsoft.Scripting.XML</DocumentationFile> <WarningsNotAsErrors>1685</WarningsNotAsErrors> <NoWarn>1591</NoWarn> - <OldToolsVersion>2.0</OldToolsVersion> <AssemblyOriginatorKeyFile>..\..\Support\MSSharedLibKey.snk</AssemblyOriginatorKeyFile> <SignAssembly Condition="'$(SignAssembly)' == '' And Exists('$(AssemblyOriginatorKeyFile)')">true</SignAssembly> <SignedSym Condition="'$(SignAssembly)' == 'true'">SIGNED</SignedSym> <DelaySign>true</DelaySign> <BaseAddress>857735168</BaseAddress> <SilverlightPath Condition="'$(SilverlightPath)' == ''">..\..\Utilities\Silverlight\x86ret\</SilverlightPath> + <TargetFrameworkVersion>v2.0</TargetFrameworkVersion> </PropertyGroup> <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'FxCop|AnyCPU' "> <DebugType>pdbonly</DebugType> @@ -241,6 +242,7 @@ <Compile Include="PerfTrack.cs" /> <Compile Include="Runtime\CompilerContext.cs" /> <Compile Include="Runtime\DynamicLanguageProviderAttribute.cs" /> + <Compile Include="Runtime\IConvertibleMetaObject.cs" /> <Compile Include="Runtime\ICustomScriptCodeData.cs" /> <Compile Include="Runtime\IRestrictedMetaObject.cs" /> <Compile Include="Runtime\LegacyScriptCode.cs" /> Merlin/Main/Runtime/Microsoft.Scripting/Microsoft.Scripting.csproj @@ -95,7 +95,15 @@ namespace Microsoft.Scripting.Utils { string genericName = type.GetGenericTypeDefinition().FullName.Replace('+', '.'); int tickIndex = genericName.IndexOf('`'); result.Append(tickIndex != -1 ? genericName.Substring(0, tickIndex) : genericName); - FormatTypeArgs(result, type.GetGenericArguments()); + + Type[] typeArgs = type.GetGenericArguments(); + if (type.IsGenericTypeDefinition) { + result.Append('<'); + result.Append(',', typeArgs.Length - 1); + result.Append('>'); + } else { + FormatTypeArgs(result, typeArgs); + } } else if (type.IsGenericParameter) { result.Append(type.Name); } else { Merlin/Main/Runtime/Microsoft.Scripting/Utils/ReflectionUtils.cs @@ -1,8 +1,9 @@ -<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="3.5"> +<?xml version="1.0" encoding="utf-8"?> +<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0"> <PropertyGroup> <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> - <ProductVersion>9.0.21022</ProductVersion> + <ProductVersion>10.0.20624</ProductVersion> <SchemaVersion>2.0</SchemaVersion> <ProjectGuid>{2AE75F5A-CD1F-4925-9647-AF4D1C282FB4}</ProjectGuid> <OutputType>Library</OutputType> @@ -16,13 +17,13 @@ <SccProvider>SAK</SccProvider> <DocumentationFile>..\..\..\..\..\..\Merlin\Main\Bin\Release\Microsoft.Scripting.Core.XML</DocumentationFile> <NoWarn>1591</NoWarn> - <OldToolsVersion>2.0</OldToolsVersion> <AssemblyOriginatorKeyFile>..\..\..\..\..\..\Merlin\Main\Support\MSSharedLibKey.snk</AssemblyOriginatorKeyFile> <SignAssembly Condition="'$(SignAssembly)' == '' And Exists('$(AssemblyOriginatorKeyFile)')">true</SignAssembly> <SignedSym Condition="'$(SignAssembly)' == 'true'">SIGNED</SignedSym> <DelaySign>true</DelaySign> <SilverlightPath Condition="'$(SilverlightPath)' == ''">..\..\..\..\..\..\Merlin\Main\Utilities\Silverlight\x86ret\</SilverlightPath> <BaseAddress>855638016</BaseAddress> + <TargetFrameworkVersion>v2.0</TargetFrameworkVersion> </PropertyGroup> <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'FxCop|AnyCPU' "> <DebugType>pdbonly</DebugType> @@ -248,4 +249,4 @@ <Output TaskParameter="Include" ItemName="CompileItems" /> </CreateItem> </Target> -</Project> +</Project> \ No newline at end of file ndp/fx/src/Core/Microsoft/Scripting/Microsoft.Scripting.Core.csproj @@ -1,8 +1,8 @@ -<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="3.5"> +<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0"> <PropertyGroup> <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> - <ProductVersion>9.0.21022</ProductVersion> + <ProductVersion>10.0.20624</ProductVersion> <SchemaVersion>2.0</SchemaVersion> <ProjectGuid>{8B0F1074-750E-4D64-BF23-A1E0F54261E5}</ProjectGuid> <OutputType>Library</OutputType> @@ -13,13 +13,13 @@ <SccLocalPath>SAK</SccLocalPath> <SccAuxPath>SAK</SccAuxPath> <SccProvider>SAK</SccProvider> - <OldToolsVersion>2.0</OldToolsVersion> <AssemblyOriginatorKeyFile>..\..\..\..\..\..\Merlin\Main\Support\MSSharedLibKey.snk</AssemblyOriginatorKeyFile> <SignAssembly Condition="'$(SignAssembly)' == '' And Exists('$(AssemblyOriginatorKeyFile)')">true</SignAssembly> <SignedSym Condition="'$(SignAssembly)' == 'true'">SIGNED</SignedSym> <DelaySign>true</DelaySign> <BaseAddress>866123776</BaseAddress> <SilverlightPath Condition="'$(SilverlightPath)' == ''">..\..\..\..\..\..\Merlin\Main\Utilities\Silverlight\x86ret\</SilverlightPath> + <TargetFrameworkVersion>v2.0</TargetFrameworkVersion> </PropertyGroup> <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'FxCop|AnyCPU' "> <DebugType>pdbonly</DebugType> ndp/fx/src/Core/Microsoft/Scripting/Microsoft.Scripting.ExtensionAttribute.csproj @@ -1,8 +1,8 @@ -<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> +<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> <PropertyGroup> <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> - <ProductVersion>9.0.21022</ProductVersion> + <ProductVersion>10.0.20624</ProductVersion> <SchemaVersion>2.0</SchemaVersion> <ProjectGuid>{D4AE44AD-07B9-41DC-BB3B-1FDCDE3C987D}</ProjectGuid> <OutputType>Library</OutputType> @@ -20,6 +20,7 @@ <SignAssembly Condition="'$(SignAssembly)' == '' And Exists('$(AssemblyOriginatorKeyFile)')">true</SignAssembly> <SignedSym Condition="'$(SignAssembly)' == 'true'">SIGNED</SignedSym> <DelaySign>true</DelaySign> + <TargetFrameworkVersion>v2.0</TargetFrameworkVersion> </PropertyGroup> <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'FxCop|AnyCPU' "> <DebugType>pdbonly</DebugType> ndp/fx/src/Dynamic/System/Dynamic/Microsoft.Dynamic.csproj Merlin/Main/Languages/Ruby/Licenses/CPL.txt Merlin/Main/Languages/Ruby/Licenses/MSPL.html Merlin/Main/Languages/Ruby/Licenses/RubyLicense.txt Merlin/Main/Languages/Ruby/Ruby/Runtime/Calls/CompositeConversionAction.cs Merlin/Main/Languages/Ruby/Ruby/Runtime/Calls/ConvertToSAction.cs Merlin/Main/Languages/Ruby/Ruby/Runtime/Calls/GenericConversionAction.cs Merlin/Main/Languages/Ruby/Ruby/Runtime/Calls/ProtocolConversionAction.cs Merlin/Main/Languages/Ruby/Ruby/Runtime/Converter.Generated.cs Merlin/Main/Languages/Ruby/Ruby/Runtime/Converter.Generator.rb Merlin/Main/Languages/Ruby/Ruby/Runtime/Converter.cs Merlin/Main/Languages/Ruby/Ruby/Runtime/RubyCallTargets.cs Merlin/Main/Languages/Ruby/Ruby/Runtime/RuntimeFlowControl.cs 5784717bec398d1320b164e2360af5d31f86515e b54621090baeead1e9a9f4eb6afa02cfa77f0a4b Jim Deville jdeville@microsoft.com http://github.com/shri/ironruby/commit/8cec1ec5bd19d1059cb8493270e595ede36db1ee 8cec1ec5bd19d1059cb8493270e595ede36db1ee 2009-07-30T15:55:04-07:00 2009-07-30T15:55:04-07:00 Merge branch 'master' of git@github.com:ironruby/ironruby * 'master' of git@github.com:ironruby/ironruby: syncing to head of tfs Syncing to head of tfs for 0.9 release af1f4c6d84ff330bcbc61029de5de4e9b33c9620 Jim Deville jdeville@microsoft.com