Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags/core/env/element_reference_tags.txt Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/rubyspec/core/env/fixtures/classes.rb Merlin/Main/Languages/IronPython/IronPython/Runtime/CodeContext.cs Merlin/Main/Languages/IronPython/IronPython/Runtime/PythonDynamicStackFrame.cs Merlin/Main/Languages/IronPython/IronPython/Runtime/UnboundNameException.cs Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Extensions/ScopeOps.cs Merlin/Main/Languages/Ruby/Ruby/Builtins/RubyObjectDebugView.cs Merlin/Main/Languages/Ruby/Ruby/Runtime/Calls/VisibilityContext.cs Merlin/Main/Languages/Ruby/Scripts/ircoverage.bat @@ -43,7 +43,7 @@ namespace IronRuby.StandardLibrary.Yaml { public RubyRepresenter(RubyContext/*!*/ context, Serializer/*!*/ serializer, YamlOptions/*!*/ opts) : base(serializer, opts) { _context = context; - _objectToYamlMethod = context.GetClass(typeof(object)).ResolveMethod("to_yaml", RubyClass.IgnoreVisibility).Info; + _objectToYamlMethod = context.GetClass(typeof(object)).ResolveMethod("to_yaml", VisibilityContext.AllVisible).Info; _TagUri = CallSite<Func<CallSite, object, object>>.Create( @@ -88,7 +88,7 @@ namespace IronRuby.StandardLibrary.Yaml { #endregion protected override Node CreateNode(object data) { - RubyMemberInfo method = _context.GetImmediateClassOf(data).ResolveMethodForSite("to_yaml", RubyClass.IgnoreVisibility).Info; + RubyMemberInfo method = _context.GetImmediateClassOf(data).ResolveMethodForSite("to_yaml", VisibilityContext.AllVisible).Info; if (method == _objectToYamlMethod) { return (Node)_ToYamlNode.Target(_ToYamlNode, data, this); Merlin/External.LCA_RESTRICTED/Languages/IronRuby/Yaml/IronRuby.Libraries.Yaml/RubyRepresenter.cs @@ -1,2 +1 @@ fails:Array#== returns true if corresponding elements are #== -fails:Array#== does not call #to_ary on its argument Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags/core/array/equal_value_tags.txt @@ -1,14 +1,9 @@ fails:String#unpack returns an array by decoding self according to the format string -fails:String#unpack with 'Z' directive returns an array by decoding self according to the format string fails:String#unpack with 'N' and 'n' directives returns an array by decoding self according to the format string -fails:String#unpack with 'Q' and 'q' directives returns an array in little-endian (native format) order by decoding self according to the format string -fails:String#unpack with 'Q' and 'q' directives returns Bignums for big numeric values on little-endian platforms -fails:String#unpack with 'Q' and 'q' directives returns Fixnums for small numeric values fails:String#unpack with 'a', 'X' and 'x' directives returns an array by decoding self according to the format string fails:String#unpack with 'DdEeFfGg' directives returns an array by decoding self according to the format string fails:String#unpack with 'DdEeFfGg' directives returns an array by decoding self in little-endian order according to the format string fails:String#unpack with 'U' directive returns an array by decoding self according to the format string -fails:String#unpack with '@' directive returns an array by decoding self according to the format string fails:String#unpack with 'M' directive returns an array by decoding self according to the format string fails:String#unpack with 'm' directive returns an array by decoding self according to the format string fails:String#unpack with 'w' directive produces a BER-compressed integer Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags/core/string/unpack_tags.txt @@ -44,20 +44,6 @@ core\thread\critical_tags.txt:0:critical:Thread.critical= can be mismatched core\thread\raise_tags.txt:0:critical:Thread#raise on another thread re-raises active exception core\thread\critical_tags.txt:0:unstable:Thread.critical= does not change status of other existing threads language\method_tags.txt:0:critical:Calling a method fails with both lambda and block argument -library\net\ftp\get_tags.txt:0:critical:Net::FTP#get (binary mode) -library\net\ftp\getbinaryfile_tags.txt:0:critical:Net::FTP#getbinaryfile -library\net\ftp\retrbinary_tags.txt:0:critical:Net::FTP#retrbinary -library\net\http\http\get_print_tags.txt:0:critical:Net::HTTP.get_print when passed URI it prints the body of the specified uri to $stdout -library\net\http\http\get_print_tags.txt:0:critical:Net::HTTP.get_print when passed host, path, port it prints the body of the specified uri to $stdout -library\net\http\http\lock_tags.txt:0:critical:Net::HTTP#lock sends a LOCK request to the passed path and returns the response -library\net\http\http\post_form_tags.txt:0:critical:Net::HTTP.post_form when passed URI POSTs the passed form data to the given uri -library\net\http\http\post_tags.txt:0:critical:Net::HTTP#post -library\net\http\http\propfind_tags.txt:0:critical:Net::HTTP#propfind -library\net\http\http\proppatch_tags.txt:0:critical:Net::HTTP#proppatch -library\net\http\http\put_tags.txt:0:critical:Net::HTTP#put -library\net\http\http\request_tags.txt:0:critical:Net::HTTP#request -library\net\http\http\send_request_tags.txt:0:critical:Net::HTTP#send_request -library\net\http\http\unlock_tags.txt:0:critical:Net::HTTP#unlock library\resolv\get_address_tags.txt:0:critical:Resolv#getaddress library\resolv\get_addresses_tags.txt:0:critical:Resolv#getaddresses library\resolv\get_name_tags.txt:0:critical:Resolv#getname Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags/critical_tags.txt @@ -1,4 +1,4 @@ -critical:Net::FTP#get (binary mode) +fails:Net::FTP#get (binary mode) fails:Net::FTP#get (text mode) sends the RETR command to the server fails:Net::FTP#get (text mode) returns nil fails:Net::FTP#get (text mode) saves the contents of the passed remote file to the passed local file Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags/library/net/ftp/get_tags.txt @@ -1 +1 @@ -critical:Net::FTP#getbinaryfile +fails:Net::FTP#getbinaryfile Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags/library/net/ftp/getbinaryfile_tags.txt @@ -1 +1 @@ -critical:Net::FTP#retrbinary +fails:Net::FTP#retrbinary Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags/library/net/ftp/retrbinary_tags.txt @@ -1,4 +1,5 @@ require File.dirname(__FILE__) + '/../../spec_helper' +require File.dirname(__FILE__) + '/fixtures/classes' describe "ENV.[]" do before :each do @@ -15,4 +16,69 @@ describe "ENV.[]" do it "returns nil if the variable isn't found" do ENV["this_var_is_never_set"].should == nil end + + platform_is :windows do + it "does not expand %HOME% if it is already set" do + EnvSpecs.with_temp_ENV do + ENV['HOME'] = 'x:\Dummy\..\User\Jane Doe' + ruby_exe("puts ENV['HOME']").chomp.should == 'x:\Dummy\..\User\Jane Doe' + end + end + + it "sets HOME to %HOMEDRIVE%/%HOMEPATH% if %HOME% is not set" do + EnvSpecs.with_temp_ENV do + ENV['HOMEDRIVE'] = 'x:' + ENV['HOMEPATH'] = '\User\Jane Doe' + ENV['USERPROFILE'] = 'y:\User\John Doe' + ruby_exe("puts ENV['HOME']").chomp.should == 'x:/User/Jane Doe' + end + end + + it "sets HOME to %HOMEDRIVE% if %HOME% is not set" do + EnvSpecs.with_temp_ENV do + ENV['HOMEDRIVE'] = 'x:' + ENV['USERPROFILE'] = 'y:\User\John Doe' + ruby_exe("puts ENV['HOME']").chomp.should == "x:/" + end + end + + it "sets HOME to %HOMEPATH% if %HOME% is not set" do + EnvSpecs.with_temp_ENV do + ENV['HOMEPATH'] = '\User\Jane Doe' + ENV['USERPROFILE'] = 'y:\User\John Doe' + ruby_exe("puts ENV['HOME']").chomp.should == "/User/Jane Doe" + end + end + + it "sets HOME to %USERPROFILE% if %HOMEDRIVE% or %HOMEPATH% are not set" do + EnvSpecs.with_temp_ENV do + ENV['USERPROFILE'] = 'y:\User\John Doe' + ruby_exe("puts ENV['HOME']").chomp.should == "y:/User/John Doe" + end + end + + ruby_version_is "" ... "1.9" do + it "does not set HOME if none of %HOMEDRIVE%, %HOMEPATH% or %USERPROFILE% are set" do + EnvSpecs.with_temp_ENV do + ENV['HOME'] = nil + ENV['HOMEDRIVE'] = nil + ENV['HOMEPATH'] = nil + ENV['USERPROFILE'] = nil + ruby_exe("puts puts ENV['HOME'], ENV['HOME'].nil?").chomp.should =~ /^true$/ + end + end + end + + ruby_version_is "1.9" do + it "does set HOME if none of %HOMEDRIVE%, %HOMEPATH% or %USERPROFILE% are set" do + EnvSpecs.with_temp_ENV do + ENV['HOME'] = nil + ENV['HOMEDRIVE'] = nil + ENV['HOMEPATH'] = nil + ENV['USERPROFILE'] = nil + ruby_exe("puts puts ENV['HOME'], ENV['HOME'].nil?").chomp.should =~ /^false$/ + end + end + end + end end Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/rubyspec/core/env/element_reference_spec.rb @@ -7,7 +7,7 @@ <microsoft.scripting> <languages> <language names="IronPython;Python;py" extensions=".py" displayName="IronPython 2.6 Alpha" type="IronPython.Runtime.PythonContext, IronPython, Version=2.6.0.20, Culture=neutral, PublicKeyToken=31bf3856ad364e35" /> - <language names="IronRuby;Ruby;rb" extensions=".rb" displayName="IronRuby" type="IronRuby.Runtime.RubyContext, IronRuby, Version=0.6.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" /> + <language names="IronRuby;Ruby;rb" extensions=".rb" displayName="IronRuby" type="IronRuby.Runtime.RubyContext, IronRuby, Version=0.9.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" /> </languages> <options> Merlin/Main/Config/Signed/App.config @@ -7,7 +7,7 @@ <microsoft.scripting> <languages> <language names="IronPython;Python;py" extensions=".py" displayName="IronPython 2.6 Alpha" type="IronPython.Runtime.PythonContext, IronPython, Version=2.6.0.20, Culture=neutral, PublicKeyToken=null" /> - <language names="IronRuby;Ruby;rb" extensions=".rb" displayName="IronRuby" type="IronRuby.Runtime.RubyContext, IronRuby, Version=0.6.0.0, Culture=neutral, PublicKeyToken=null" /> + <language names="IronRuby;Ruby;rb" extensions=".rb" displayName="IronRuby" type="IronRuby.Runtime.RubyContext, IronRuby, Version=0.9.0.0, Culture=neutral, PublicKeyToken=null" /> </languages> <options> Merlin/Main/Config/Unsigned/App.config @@ -12,7 +12,7 @@ namespace IronRuby.Rack { private readonly object _app; private readonly string _appRoot; - private readonly string _rackVersion; + private readonly string _rackVersion; private readonly string _gemPath; public object App { @@ -20,12 +20,12 @@ namespace IronRuby.Rack { } private const string AppRootOptionName = "AppRoot"; - private const string RackVersionOptionName = "RackVersion"; + private const string RackVersionOptionName = "RackVersion"; private const string GemPathOptionName = "GemPath"; public Application(HttpContext context) { _appRoot = GetRoot(context); - _rackVersion = GetRackVersion(); + _rackVersion = GetRackVersion(); _gemPath = GetGemPath(); InitRack(); @@ -41,7 +41,7 @@ namespace IronRuby.Rack { return RubyEngine.ExecuteMethod<RubyArray>(_app, "call", envHash); } - private void InitRack() { + private void InitRack() { Environment.SetEnvironmentVariable("GEM_PATH", _gemPath); Utils.Log("=> Loading RubyGems"); @@ -83,10 +83,10 @@ namespace IronRuby.Rack { } } return root; - } - - private static string GetGemPath() { - return ConfigurationManager.AppSettings[GemPathOptionName] ?? ""; + } + + private static string GetGemPath() { + return ConfigurationManager.AppSettings[GemPathOptionName] ?? ""; } } } Merlin/Main/Hosts/IronRuby.Rack/Application.cs @@ -41,16 +41,16 @@ namespace IronRuby.Rack { public static object Execute(string code, ScriptScope aScope) { return Engine.CreateScriptSourceFromString(code).Execute(aScope); - } - - public static T Execute<T>(string code) - { - return Execute<T>(code, scope); - } - - public static T Execute<T>(string code, ScriptScope aScope) - { - return (T)Engine.CreateScriptSourceFromString(code).Execute(aScope); + } + + public static T Execute<T>(string code) + { + return Execute<T>(code, scope); + } + + public static T Execute<T>(string code, ScriptScope aScope) + { + return (T)Engine.CreateScriptSourceFromString(code).Execute(aScope); } public static T ExecuteMethod<T>(object instance, string methodName, params object[] args) Merlin/Main/Hosts/IronRuby.Rack/RubyEngine.cs @@ -45,13 +45,13 @@ namespace IronRuby.Rack { foreach (var path in RubyEngine.Engine.GetSearchPaths()) { context.Response.Write(HttpUtility.HtmlEncode(path)); context.Response.Write("\r\n"); - } - context.Response.Write("</pre>\r\n"); - context.Response.Write("<h4>Gem paths</h4>\r\n"); - context.Response.Write("<pre>\r\n"); - foreach (var gempath in RubyEngine.Execute<RubyArray>("require 'rubygems'; Gem.path")) { - context.Response.Write(HttpUtility.HtmlEncode(((MutableString)gempath).ToString())); - context.Response.Write("\r\n"); + } + context.Response.Write("</pre>\r\n"); + context.Response.Write("<h4>Gem paths</h4>\r\n"); + context.Response.Write("<pre>\r\n"); + foreach (var gempath in RubyEngine.Execute<RubyArray>("require 'rubygems'; Gem.path")) { + context.Response.Write(HttpUtility.HtmlEncode(((MutableString)gempath).ToString())); + context.Response.Write("\r\n"); } context.Response.Write("</pre>\r\n"); context.Response.Write("</html>\r\n"); Merlin/Main/Hosts/IronRuby.Rack/Utils.cs @@ -32,7 +32,7 @@ namespace Microsoft.Scripting.Silverlight { public ScriptScope EntryPointScope { get; private set; } public void Start() { - InitializeRuntime(Settings.Debug); + InitializeRuntime(Settings.Debug); Run(Settings.GetEntryPoint(), Settings.ConsoleEnabled); } @@ -68,8 +68,8 @@ namespace Microsoft.Scripting.Silverlight { private void Run(string entryPoint, bool consoleEnabled) { string code = GetEntryPointContents(); Engine = Runtime.GetEngineByFileExtension(Path.GetExtension(entryPoint)); - EntryPointScope = Engine.CreateScope(); - + EntryPointScope = Engine.CreateScope(); + if (consoleEnabled) Repl.Show(); ScriptSource sourceCode = Engine.CreateScriptSourceFromString(code, entryPoint, SourceCodeKind.File); Merlin/Main/Hosts/SilverLight/Microsoft.Scripting.SilverLight/DynamicEngine.cs @@ -19,7 +19,7 @@ <SignAssembly Condition="'$(SignAssembly)' == '' And Exists('$(AssemblyOriginatorKeyFile)')">true</SignAssembly> <SignedSym Condition="'$(SignAssembly)' == 'true'">SIGNED</SignedSym> <DelaySign>true</DelaySign> - <SilverlightPath Condition="$(SilverlightPath) == ''">..\..\..\Utilities\Silverlight\x86ret\</SilverlightPath> + <SilverlightPath Condition="'$(SilverlightPath)' == ''">..\..\..\Utilities\Silverlight\x86ret\</SilverlightPath> <BaseAddress>885063680</BaseAddress> </PropertyGroup> <PropertyGroup Condition=" '$(Configuration)' == 'Debug' "> @@ -80,8 +80,8 @@ <HintPath>$(SilverlightPath)\System.Core.dll</HintPath> <Aliases>systemcore</Aliases> </Reference> - <Reference Include="System.Data" Condition=" $(SilverlightBuild) != 'true' " /> - <Reference Include="System.Xml" Condition=" $(SilverlightBuild) != 'true' " /> + <Reference Include="System.Data" Condition=" '$(SilverlightBuild)' != 'true' " /> + <Reference Include="System.Xml" Condition=" '$(SilverlightBuild)' != 'true' " /> </ItemGroup> <ItemGroup> <Compile Include="..\..\..\Hosts\Silverlight\SilverlightVersion.cs" Condition=" '$(SilverlightBuild)' == 'true' "> Merlin/Main/Languages/IronPython/IronPython.Modules/IronPython.Modules.csproj @@ -251,7 +251,7 @@ namespace IronPython.Modules { } [PythonType, DynamicBaseTypeAttribute, PythonHidden] - public sealed partial class weakproxy : IPythonObject, ICodeFormattable, IProxyObject, IValueEquality, IMembersList { + public sealed partial class weakproxy : IPythonObject, ICodeFormattable, IProxyObject, IValueEquality, IPythonMembersList { private readonly WeakHandle _target; private readonly CodeContext/*!*/ _context; @@ -406,7 +406,11 @@ namespace IronPython.Modules { PythonOps.DeleteAttr(context, o, SymbolTable.StringToId(name)); } - IList<object> IMembersList.GetMemberNames(CodeContext/*!*/ context) { + IList<string> IMembersList.GetMemberNames() { + return PythonOps.GetStringMemberList(this); + } + + IList<object> IPythonMembersList.GetMemberNames(CodeContext/*!*/ context) { object o; if (!TryGetObject(out o)) { // if we've been disconnected return an empty list @@ -456,7 +460,7 @@ namespace IronPython.Modules { ICodeFormattable, IProxyObject, IValueEquality, - IMembersList { + IPythonMembersList { private WeakHandle _target; private readonly CodeContext/*!*/ _context; @@ -625,7 +629,11 @@ namespace IronPython.Modules { PythonOps.DeleteAttr(context, o, SymbolTable.StringToId(name)); } - IList<object> IMembersList.GetMemberNames(CodeContext/*!*/ context) { + IList<string> IMembersList.GetMemberNames() { + return PythonOps.GetStringMemberList(this); + } + + IList<object> IPythonMembersList.GetMemberNames(CodeContext/*!*/ context) { object o; if (!TryGetObject(out o)) { // if we've been disconnected return an empty list Merlin/Main/Languages/IronPython/IronPython.Modules/_weakref.cs @@ -510,7 +510,7 @@ namespace IronPython.Modules { public static PythonTuple _pickle(CodeContext/*!*/ context, RE_Pattern pattern) { object scope = Importer.ImportModule(context, new PythonDictionary(), "re", false, 0); object compile; - if (scope is Scope && ((Scope)scope).TryGetName(SymbolTable.StringToId("compile"), out compile)) { + if (scope is Scope && ((Scope)scope).TryGetVariable(SymbolTable.StringToId("compile"), out compile)) { return PythonTuple.MakeTuple(compile, PythonTuple.MakeTuple(pattern.pattern, pattern.flags)); } throw new InvalidOperationException("couldn't find compile method"); Merlin/Main/Languages/IronPython/IronPython.Modules/re.cs @@ -42,7 +42,7 @@ namespace IronPython.Compiler.Ast { private readonly GlobalArrayConstant _array; internal static readonly MSAst.ParameterExpression/*!*/ _globalContext = Ast.Parameter(typeof(CodeContext), "$globalContext"); - public ArrayGlobalAllocator(LanguageContext/*!*/ context) { + public ArrayGlobalAllocator(PythonContext/*!*/ context) { _globalArray = Ast.Parameter(typeof(PythonGlobal[]), "$globalArray"); _scope = new Scope(new PythonDictionary(new GlobalDictionaryStorage(_globalVals))); _context = new CodeContext(_scope, context); Merlin/Main/Languages/IronPython/IronPython/Compiler/ArrayGlobalAllocator.cs @@ -71,7 +71,7 @@ namespace IronPython.Compiler.Ast { private Dictionary<int, bool> _handlerLocations; // list of all exception handlers and finallys. - used for debugging/tracing support to disallow jumping into handlers. Value is true if handler is finally private static readonly Dictionary<string, MethodInfo> _HelperMethods = new Dictionary<string, MethodInfo>(); // cache of helper methods - private static readonly MethodInfo _UpdateStackTrace = typeof(ExceptionHelpers).GetMethod("UpdateStackTrace"); + private static readonly MethodInfo _UpdateStackTrace = typeof(PythonOps).GetMethod("UpdateStackTrace"); private static readonly MSAst.Expression _GetCurrentMethod = Ast.Call(typeof(MethodBase).GetMethod("GetCurrentMethod")); internal static readonly MSAst.Expression[] EmptyExpression = new MSAst.Expression[0]; internal static readonly MSAst.BlockExpression EmptyBlock = Ast.Block(AstUtils.Empty()); @@ -115,16 +115,15 @@ namespace IronPython.Compiler.Ast { _context = context; _pythonContext = (PythonContext)context.SourceUnit.LanguageContext; _document = _context.SourceUnit.Document ?? Ast.SymbolDocument(name, PyContext.LanguageGuid, PyContext.VendorGuid); - - LanguageContext pc = context.SourceUnit.LanguageContext; + switch (mode) { - case CompilationMode.Collectable: _globals = new ArrayGlobalAllocator(pc); break; + case CompilationMode.Collectable: _globals = new ArrayGlobalAllocator(_pythonContext); break; case CompilationMode.Lookup: _globals = new DictionaryGlobalAllocator(); break; - case CompilationMode.ToDisk: _globals = new SavableGlobalAllocator(pc); break; - case CompilationMode.Uncollectable: _globals = new StaticGlobalAllocator(pc, name); break; + case CompilationMode.ToDisk: _globals = new SavableGlobalAllocator(_pythonContext); break; + case CompilationMode.Uncollectable: _globals = new StaticGlobalAllocator(_pythonContext, name); break; } - PythonOptions po = (pc.Options as PythonOptions); + PythonOptions po = (_pythonContext.Options as PythonOptions); Assert.NotNull(po); if (po.EnableProfiler && mode != CompilationMode.ToDisk) { _profiler = Profiler.GetProfiler(PyContext); @@ -638,7 +637,7 @@ namespace IronPython.Compiler.Ast { LineNumberUpdated ), Ast.Call( - typeof(ExceptionHelpers).GetMethod("UpdateStackTrace"), + _UpdateStackTrace, LocalContext, _GetCurrentMethod, AstUtils.Constant(Name), Merlin/Main/Languages/IronPython/IronPython/Compiler/Ast/AstGenerator.cs @@ -81,7 +81,7 @@ namespace IronPython.Compiler.Ast { } protected override MSAst.Expression/*!*/ GetGlobal(string/*!*/ name, AstGenerator/*!*/ ag, bool isLocal) { - return new LookupGlobalVariable(Ast.Property(ag.LocalContext, "Scope"), name, isLocal); + return new LookupGlobalVariable(ag.LocalContext, name, isLocal); } } } Merlin/Main/Languages/IronPython/IronPython/Compiler/DictionaryGlobalAllocator.cs @@ -68,7 +68,7 @@ namespace IronPython.Compiler { PythonGlobal[] globalArray = new PythonGlobal[optimizedCode.Names.Length]; Scope scope = new Scope(new PythonDictionary(new GlobalDictionaryStorage(globals, globalArray))); - CodeContext res = new CodeContext(scope, SourceUnit.LanguageContext); + CodeContext res = new CodeContext(scope, (PythonContext)SourceUnit.LanguageContext); for (int i = 0; i < optimizedCode.Names.Length; i++) { SymbolId name = SymbolTable.StringToId(optimizedCode.Names[i]); Merlin/Main/Languages/IronPython/IronPython/Compiler/OnDiskScriptCode.cs @@ -83,7 +83,7 @@ namespace IronPython.Compiler { } else { object value; - if (_context.LanguageContext.TryLookupGlobal(_context.Scope, _name, out value)) { + if (_context.TryLookupGlobal(_name, out value)) { return value; } } Merlin/Main/Languages/IronPython/IronPython/Compiler/PythonGlobal.cs @@ -14,6 +14,7 @@ * ***************************************************************************/ using System; +using System.Diagnostics; using System.Linq.Expressions; using Microsoft.Scripting; @@ -22,6 +23,7 @@ using Microsoft.Scripting.Interpreter; using Microsoft.Scripting.Runtime; using Microsoft.Scripting.Utils; +using IronPython.Runtime; using IronPython.Runtime.Operations; namespace IronPython.Compiler { @@ -211,14 +213,15 @@ namespace IronPython.Compiler { class LookupGlobalVariable : Expression, IInstructionProvider, IPythonGlobalExpression { private readonly string/*!*/ _name; private readonly bool/*!*/ _isLocal; - private readonly Expression/*!*/ _scope; + private readonly Expression/*!*/ _codeContextExpr; - public LookupGlobalVariable(Expression/*!*/ scopeExpr, string/*!*/ name, bool isLocal) { + public LookupGlobalVariable(Expression/*!*/ codeContextExpr, string/*!*/ name, bool isLocal) { + Debug.Assert(codeContextExpr.Type == typeof(CodeContext)); Assert.NotNull(name); _name = name; _isLocal = isLocal; - _scope = scopeExpr; + _codeContextExpr = codeContextExpr; } public sealed override ExpressionType NodeType { @@ -238,7 +241,7 @@ namespace IronPython.Compiler { public Expression/*!*/ RawValue() { return Expression.Call( typeof(PythonOps).GetMethod(_isLocal ? "RawGetLocal" : "RawGetGlobal"), - _scope, + _codeContextExpr, Utils.Constant(SymbolTable.StringToId(_name)) ); } @@ -246,7 +249,7 @@ namespace IronPython.Compiler { public override Expression/*!*/ Reduce() { return Expression.Call( typeof(PythonOps).GetMethod(_isLocal ? "GetLocal" : "GetGlobal"), - _scope, + _codeContextExpr, Utils.Constant(SymbolTable.StringToId(_name)) ); } @@ -254,7 +257,7 @@ namespace IronPython.Compiler { public Expression/*!*/ Assign(Expression/*!*/ value) { return Expression.Call( typeof(PythonOps).GetMethod(_isLocal ? "SetLocal" : "SetGlobal"), - _scope, + _codeContextExpr, Utils.Constant(SymbolTable.StringToId(_name)), value ); @@ -263,7 +266,7 @@ namespace IronPython.Compiler { public Expression/*!*/ Delete() { return Expression.Call( typeof(PythonOps).GetMethod(_isLocal ? "DeleteLocal" : "DeleteGlobal"), - _scope, + _codeContextExpr, Utils.Constant(SymbolTable.StringToId(_name)) ); } @@ -271,7 +274,7 @@ namespace IronPython.Compiler { #region IInstructionProvider Members void IInstructionProvider.AddInstructions(LightCompiler compiler) { - compiler.Compile(_scope); + compiler.Compile(_codeContextExpr); compiler.AddInstruction(new LookupGlobalInstruction(_name, _isLocal)); } @@ -289,9 +292,9 @@ namespace IronPython.Compiler { public override int ProducedStack { get { return 1; } } public override int Run(InterpretedFrame frame) { if (_isLocal) { - frame.Push(PythonOps.GetLocal((Scope)frame.Pop(), _name)); + frame.Push(PythonOps.GetLocal((CodeContext)frame.Pop(), _name)); } else { - frame.Push(PythonOps.GetGlobal((Scope)frame.Pop(), _name)); + frame.Push(PythonOps.GetGlobal((CodeContext)frame.Pop(), _name)); } return +1; } Merlin/Main/Languages/IronPython/IronPython/Compiler/PythonGlobalVariableExpression.cs @@ -20,6 +20,7 @@ using Microsoft.Scripting; using Microsoft.Scripting.Ast; using Microsoft.Scripting.Runtime; +using IronPython.Runtime; using IronPython.Runtime.Operations; using MSAst = System.Linq.Expressions; @@ -30,7 +31,7 @@ namespace IronPython.Compiler.Ast { class SavableGlobalAllocator : ArrayGlobalAllocator { private readonly List<MSAst.Expression/*!*/>/*!*/ _constants; - public SavableGlobalAllocator(LanguageContext/*!*/ context) + public SavableGlobalAllocator(PythonContext/*!*/ context) : base(context) { _constants = new List<MSAst.Expression>(); } Merlin/Main/Languages/IronPython/IronPython/Compiler/SavableGlobalAllocator.cs @@ -56,7 +56,7 @@ namespace IronPython.Compiler.Ast { private StrongBox<Type> _finalType = new StrongBox<Type>(); #endif - public StaticGlobalAllocator(LanguageContext/*!*/ context, string name) { + public StaticGlobalAllocator(PythonContext/*!*/ context, string name) { _typeGen = Snippets.Shared.DefineType(name, typeof(object), false, false); _codeContextField = _typeGen.AddStaticField(typeof(CodeContext), "__global_context"); Merlin/Main/Languages/IronPython/IronPython/Compiler/StaticGlobalAllocator.cs @@ -194,8 +194,8 @@ namespace IronPython.Hosting { ModuleOptions trueDiv = (PythonContext.PythonOptions.DivisionOptions == PythonDivisionOptions.New) ? ModuleOptions.TrueDivision : ModuleOptions.None; PythonModule module = PythonContext.CreateModule(trueDiv | ModuleOptions.ModuleBuiltins); PythonContext.PublishModule("__main__", module); - module.Scope.SetName(Symbols.Doc, null); - module.Scope.SetName(Symbols.Name, "__main__"); + module.Scope.SetVariable(Symbols.Doc, null); + module.Scope.SetVariable(Symbols.Name, "__main__"); return module.Scope; } @@ -510,6 +510,13 @@ namespace IronPython.Hosting { protected override void UnhandledException(Exception e) { PythonOps.PrintException(new CodeContext(Scope, Language), e, Console); } + + private new PythonContext Language { + get { + return (PythonContext)base.Language; + } + } + } #endif } Merlin/Main/Languages/IronPython/IronPython/Hosting/PythonCommandLine.cs Merlin/Main/Languages/IronPython/IronPython/IronPython.Build.csproj @@ -80,7 +80,7 @@ <NoWarn>1591</NoWarn> </PropertyGroup> <ItemGroup> - <Reference Include="System" Condition=" $(SilverlightBuild) != 'true' " /> + <Reference Include="System" Condition=" '$(SilverlightBuild)' != 'true' " /> <Reference Include="mscorlib, Version=2.0.5.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e" Condition=" '$(SilverlightBuild)' == 'true' "> <SpecificVersion>False</SpecificVersion> <HintPath>$(SilverlightPath)\mscorlib.dll</HintPath> @@ -90,7 +90,7 @@ <HintPath>$(SilverlightPath)\System.dll</HintPath> </Reference> <Reference Include="System.Data" /> - <Reference Include="System.Xml" Condition=" $(SilverlightBuild) != 'true' " /> + <Reference Include="System.Xml" Condition=" '$(SilverlightBuild)' != 'true' " /> </ItemGroup> <ItemGroup> <Compile Include="..\..\..\Hosts\SilverLight\SilverlightVersion.cs" Condition=" '$(SilverlightBuild)' == 'true' "> @@ -103,6 +103,7 @@ <Compile Include="Compiler\Ast\AssignmentStatement.cs" /> <Compile Include="Compiler\Ast\AstGenerator.cs" /> <Compile Include="Modules\imp.cs" /> + <Compile Include="Runtime\CodeContext.cs" /> <Compile Include="Runtime\DontMapIEnumerableToIterAttribute.cs" /> <Compile Include="Runtime\Binding\ContextArgBuilder.cs" /> <Compile Include="Runtime\Binding\IFastSettable.cs" /> @@ -247,6 +248,7 @@ <Compile Include="Runtime\Operations\IListOfByteOps.cs" /> <Compile Include="Runtime\BytesConversionAttribute.cs" /> <Compile Include="Runtime\Python3Warning.cs" /> + <Compile Include="Runtime\PythonDynamicStackFrame.cs" /> <Compile Include="Runtime\PythonFunction.Generated.cs" /> <Compile Include="Runtime\PythonOptions.cs" /> <Compile Include="Runtime\CompiledLoader.cs" /> @@ -450,6 +452,7 @@ <Compile Include="Runtime\Types\IPythonObject.cs" /> <Compile Include="Runtime\Types\PythonTypeSlot.cs" /> <Compile Include="Runtime\Types\DynamicHelpers.cs" /> + <Compile Include="Runtime\UnboundNameException.cs" /> <Compile Include="Runtime\WarningInfo.cs" /> <Compile Include="Runtime\WeakRef.cs" /> <Compile Include="Runtime\WrapperDescriptorAttribute.cs" /> Merlin/Main/Languages/IronPython/IronPython/IronPython.csproj @@ -13,6 +13,10 @@ # ##################################################################################### +all_feature_names = ['nested_scopes', 'generators', 'division', + 'absolute_import', 'with_statement', 'print_function', + 'unicode_literals'] + division=1 with_statement=1 generators=1 Merlin/Main/Languages/IronPython/IronPython/Lib/__future__.py @@ -835,7 +835,7 @@ namespace IronPython.Modules { if (name == Symbols.Class || name == Symbols.Builtins) continue; object value; - if (scope.TryGetName(name, out value)) { + if (scope.TryGetVariable(name, out value)) { help(context, doced, doc, indent + 1, value); } } @@ -853,7 +853,7 @@ namespace IronPython.Modules { doc.AppendLine(); } - IList<object> names = ((IMembersList)oldClass).GetMemberNames(context); + IList<object> names = ((IPythonMembersList)oldClass).GetMemberNames(context); List sortNames = new List(names); sortNames.sort(context); names = sortNames; Merlin/Main/Languages/IronPython/IronPython/Modules/Builtin.cs @@ -109,9 +109,9 @@ namespace IronPython.Modules { if (name == null) throw PythonOps.TypeError("new_module() argument 1 must be string, not None"); Scope res = PythonContext.GetContext(context).CreateModule().Scope; - res.SetName(Symbols.Name, name); - res.SetName(Symbols.Doc, null); - res.SetName(Symbols.Package, null); + res.SetVariable(Symbols.Name, name); + res.SetVariable(Symbols.Doc, null); + res.SetVariable(Symbols.Package, null); return res; } @@ -209,8 +209,8 @@ namespace IronPython.Modules { PythonModule mod = pc.CreateModule(); Scope scope = mod.Scope; - scope.SetName(Symbols.Name, name); - scope.SetName(Symbols.Path, pathname); + scope.SetVariable(Symbols.Name, name); + scope.SetVariable(Symbols.Path, pathname); pc.SystemStateModules[name] = scope; Merlin/Main/Languages/IronPython/IronPython/Modules/imp.cs @@ -296,7 +296,7 @@ namespace IronPython.Runtime.Binding { return new ValidationInfo(typeTest); } - private static MethodCallExpression/*!*/ CheckTypeVersion(Expression/*!*/ tested, int version) { + internal static MethodCallExpression/*!*/ CheckTypeVersion(Expression/*!*/ tested, int version) { FieldInfo fi = tested.Type.GetField(NewTypeMaker.ClassFieldName); if (fi == null) { return Ast.Call( Merlin/Main/Languages/IronPython/IronPython/Runtime/Binding/BindingHelpers.cs @@ -214,7 +214,7 @@ namespace IronPython.Runtime.Binding { ); } - return res ?? EnsureReturnType(Context.Binder.ConvertTo(Type, ResultKind, self)); + return res ?? EnsureReturnType(Context.Binder.ConvertTo(Type, ResultKind, self, _context.SharedOverloadResolverFactory)); } private DynamicMetaObject EnsureReturnType(DynamicMetaObject dynamicMetaObject) { Merlin/Main/Languages/IronPython/IronPython/Runtime/Binding/ConversionBinder.cs @@ -98,7 +98,7 @@ namespace IronPython.Runtime.Binding { } public override System.Collections.Generic.IEnumerable<string> GetDynamicMemberNames() { - foreach (object o in ((IMembersList)Value).GetMemberNames(DefaultContext.Default)) { + foreach (object o in ((IPythonMembersList)Value).GetMemberNames(DefaultContext.Default)) { if (o is string) { yield return (string)o; } Merlin/Main/Languages/IronPython/IronPython/Runtime/Binding/MetaOldClass.cs @@ -153,7 +153,7 @@ namespace IronPython.Runtime.Binding { } public override System.Collections.Generic.IEnumerable<string> GetDynamicMemberNames() { - foreach (object o in ((IMembersList)Value).GetMemberNames(DefaultContext.Default)) { + foreach (object o in ((IPythonMembersList)Value).GetMemberNames(DefaultContext.Default)) { if (o is string) { yield return (string)o; } Merlin/Main/Languages/IronPython/IronPython/Runtime/Binding/MetaOldInstance.cs @@ -134,7 +134,8 @@ namespace IronPython.Runtime.Binding { BindingRestrictionsHelpers.GetRuntimeTypeRestriction(Expression, LimitType), Value ); - ArgumentValues ai = new ArgumentValues(BindingHelpers.GetCallSignature(call), self, args); + CallSignature sig = BindingHelpers.GetCallSignature(call); + ArgumentValues ai = new ArgumentValues(sig, self, args); NewAdapter newAdapter; InitAdapter initAdapter; @@ -163,76 +164,89 @@ namespace IronPython.Runtime.Binding { ); } - // then get the statement for calling __init__ - ParameterExpression allocatedInst = Ast.Variable(createExpr.GetLimitType(), "newInst"); - Expression tmpRead = allocatedInst; - DynamicMetaObject initCall = initAdapter.MakeInitCall( - state.Binder, - new RestrictedMetaObject( - AstUtils.Convert(allocatedInst, Value.UnderlyingSystemType), - createExpr.Restrictions - ) - ); - - List<Expression> body = new List<Expression>(); - // then get the call to __del__ if we need one - if (HasFinalizer(call)) { - body.Add( - Ast.Assign(allocatedInst, createExpr.Expression) + Expression res; + BindingRestrictions additionalRestrictions = BindingRestrictions.Empty; + if (!Value.IsSystemType && (!(newAdapter is DefaultNewAdapter) || HasFinalizer(call))) { + // we need to dynamically check the return value to see if it's a subtype of + // the type that we are calling. If it is then we need to call __init__/__del__ + // for the actual returned type. + res = Expression.Dynamic( + Value.GetLateBoundInitBinder(sig), + typeof(object), + ArrayUtils.Insert( + codeContext, + Expression.Convert(createExpr.Expression, typeof(object)), + DynamicUtils.GetExpressions(args) + ) ); - body.Add( - GetFinalizerInitialization(call, allocatedInst) + additionalRestrictions = createExpr.Restrictions; + } else { + // just call the __init__ method, built-in types currently have + // no wacky return values which don't return the derived type. + + // then get the statement for calling __init__ + ParameterExpression allocatedInst = Ast.Variable(createExpr.GetLimitType(), "newInst"); + Expression tmpRead = allocatedInst; + DynamicMetaObject initCall = initAdapter.MakeInitCall( + state.Binder, + new RestrictedMetaObject( + AstUtils.Convert(allocatedInst, Value.UnderlyingSystemType), + createExpr.Restrictions + ) ); - } - - // add the call to init if we need to - if (initCall.Expression != tmpRead) { - // init can fail but if __new__ returns a different type - // no exception is raised. - DynamicMetaObject initStmt = initCall; - if (body.Count == 0) { - body.Add( - Ast.Assign(allocatedInst, createExpr.Expression) - ); + List<Expression> body = new List<Expression>(); + Debug.Assert(!HasFinalizer(call)); + + // add the call to init if we need to + if (initCall.Expression != tmpRead) { + // init can fail but if __new__ returns a different type + // no exception is raised. + DynamicMetaObject initStmt = initCall; + + if (body.Count == 0) { + body.Add( + Ast.Assign(allocatedInst, createExpr.Expression) + ); + } + + if (!Value.UnderlyingSystemType.IsAssignableFrom(createExpr.Expression.Type)) { + // return type of object, we need to check the return type before calling __init__. + body.Add( + AstUtils.IfThen( + Ast.TypeIs(allocatedInst, Value.UnderlyingSystemType), + initStmt.Expression + ) + ); + } else { + // just call the __init__ method, no type check necessary (TODO: need null check?) + body.Add(initStmt.Expression); + } } - if (!Value.UnderlyingSystemType.IsAssignableFrom(createExpr.Expression.Type)) { - // return type of object, we need to check the return type before calling __init__. - body.Add( - AstUtils.IfThen( - Ast.TypeIs(allocatedInst, Value.UnderlyingSystemType), - initStmt.Expression - ) - ); + // and build the target from everything we have + if (body.Count == 0) { + res = createExpr.Expression; } else { - // just call the __init__ method, no type check necessary (TODO: need null check?) - body.Add(initStmt.Expression); + body.Add(allocatedInst); + res = Ast.Block(body); } - } + res = Ast.Block(new ParameterExpression[] { allocatedInst }, res); - Expression res; - // and build the target from everything we have - if (body.Count == 0) { - res = createExpr.Expression; - } else { - body.Add(allocatedInst); - res = Ast.Block(body); + additionalRestrictions = initCall.Restrictions; } - res = Ast.Block(new ParameterExpression[] { allocatedInst }, res); return BindingHelpers.AddDynamicTestAndDefer( call, new DynamicMetaObject( res, - self.Restrictions.Merge(initCall.Restrictions) + self.Restrictions.Merge(additionalRestrictions) ), ArrayUtils.Insert(this, args), valInfo ); } - - + #endregion #region Adapter support @@ -502,21 +516,19 @@ namespace IronPython.Runtime.Binding { protected DynamicMetaObject/*!*/ MakeDefaultInit(PythonBinder/*!*/ binder, DynamicMetaObject/*!*/ createExpr, Expression/*!*/ init) { List<Expression> args = new List<Expression>(); args.Add(CodeContext); - args.Add(init); + args.Add(Expression.Convert(createExpr.Expression, typeof(object))); foreach (DynamicMetaObject mo in Arguments.Arguments) { args.Add(mo.Expression); } return new DynamicMetaObject( - Ast.Dynamic( - PythonContext.Invoke( - Arguments.Signature - ), + Expression.Dynamic( + ((PythonType)Arguments.Self.Value).GetLateBoundInitBinder(Arguments.Signature), typeof(object), - args + args.ToArray() ), Arguments.Self.Restrictions.Merge(createExpr.Restrictions) - ); + ); } } Merlin/Main/Languages/IronPython/IronPython/Runtime/Binding/MetaPythonType.Calls.cs @@ -86,7 +86,7 @@ namespace IronPython.Runtime.Binding { tt ), value, - AstUtils.Constant(state.SharedContext) + new PythonOverloadResolverFactory(state.Binder, AstUtils.Constant(state.SharedContext)) ).Expression, Restrictions.Merge(value.Restrictions).Merge(BindingRestrictions.GetInstanceRestriction(Expression, Value)) ); @@ -112,7 +112,8 @@ namespace IronPython.Runtime.Binding { AstUtils.Constant(tt), BindingRestrictions.Empty, tt - ) + ), + state.SharedOverloadResolverFactory ).Expression, BindingRestrictions.GetInstanceRestriction(Expression, Value).Merge(Restrictions) ); @@ -331,8 +332,12 @@ namespace IronPython.Runtime.Binding { pts.MakeGetExpression( _state.Binder, _codeContext, - null, - AstUtils.Convert(AstUtils.WeakConstant(Value), typeof(PythonType)), + null, + new DynamicMetaObject( + AstUtils.Convert(AstUtils.WeakConstant(Value), typeof(PythonType)), + BindingRestrictions.Empty, + Value + ), _cb ); @@ -386,10 +391,15 @@ namespace IronPython.Runtime.Binding { protected override void AddMetaSlotAccess(PythonType metaType, PythonTypeSlot pts) { ParameterExpression tmp = Ast.Variable(typeof(object), "slotRes"); - pts.MakeGetExpression(_state.Binder, + pts.MakeGetExpression( + _state.Binder, _codeContext, - Expression, - AstUtils.Constant(metaType), + _type, + new DynamicMetaObject( + AstUtils.Constant(metaType), + BindingRestrictions.Empty, + metaType + ), _cb ); Merlin/Main/Languages/IronPython/IronPython/Runtime/Binding/MetaPythonType.Members.cs @@ -313,7 +313,7 @@ namespace IronPython.Runtime.Binding { private Expression ConversionFallback(DynamicMetaObjectBinder/*!*/ convertToAction) { PythonConversionBinder cb = convertToAction as PythonConversionBinder; if (cb != null) { - return GetConversionFailedReturnValue(cb, this); + return GetConversionFailedReturnValue(cb, this).Expression; } return convertToAction.GetUpdateExpression(typeof(object)); @@ -342,11 +342,11 @@ namespace IronPython.Runtime.Binding { /// <summary> /// Various helpers related to calling Python __*__ conversion methods /// </summary> - private Expression/*!*/ GetConversionFailedReturnValue(PythonConversionBinder/*!*/ convertToAction, DynamicMetaObject/*!*/ self) { + private DynamicMetaObject/*!*/ GetConversionFailedReturnValue(PythonConversionBinder/*!*/ convertToAction, DynamicMetaObject/*!*/ self) { switch (convertToAction.ResultKind) { case ConversionResultKind.ImplicitTry: case ConversionResultKind.ExplicitTry: - return DefaultBinder.GetTryConvertReturnValue(convertToAction.Type); + return new DynamicMetaObject(DefaultBinder.GetTryConvertReturnValue(convertToAction.Type), BindingRestrictions.Empty); case ConversionResultKind.ExplicitCast: case ConversionResultKind.ImplicitCast: DefaultBinder db = PythonContext.GetPythonContext(convertToAction).Binder; Merlin/Main/Languages/IronPython/IronPython/Runtime/Binding/MetaUserObject.cs @@ -60,7 +60,7 @@ namespace IronPython.Runtime.Binding { } } - public override Expression/*!*/ ConvertExpression(Expression/*!*/ expr, Type/*!*/ toType, ConversionResultKind kind, Expression context) { + public override Expression/*!*/ ConvertExpression(Expression/*!*/ expr, Type/*!*/ toType, ConversionResultKind kind, OverloadResolverFactory factory) { ContractUtils.RequiresNotNull(expr, "expr"); ContractUtils.RequiresNotNull(toType, "toType"); @@ -85,7 +85,7 @@ namespace IronPython.Runtime.Binding { } return Binders.Convert( - context, + ((PythonOverloadResolverFactory)factory)._codeContext, _context, visType, visType == typeof(char) ? ConversionResultKind.ImplicitCast : kind, @@ -182,9 +182,9 @@ namespace IronPython.Runtime.Binding { ); } - public override ErrorInfo/*!*/ MakeNonPublicMemberGetError(Expression codeContext, MemberTracker member, Type type, Expression instance) { + public override ErrorInfo/*!*/ MakeNonPublicMemberGetError(OverloadResolverFactory resolverFactory, MemberTracker member, Type type, DynamicMetaObject instance) { if (PrivateBinding) { - return base.MakeNonPublicMemberGetError(codeContext, member, type, instance); + return base.MakeNonPublicMemberGetError(resolverFactory, member, type, instance); } return ErrorInfo.FromValue( @@ -192,11 +192,11 @@ namespace IronPython.Runtime.Binding { ); } - public override ErrorInfo/*!*/ MakeStaticAssignFromDerivedTypeError(Type accessingType, DynamicMetaObject instance, MemberTracker info, Expression assignedValue, Expression context) { + public override ErrorInfo/*!*/ MakeStaticAssignFromDerivedTypeError(Type accessingType, DynamicMetaObject instance, MemberTracker info, DynamicMetaObject assignedValue, OverloadResolverFactory factory) { return MakeMissingMemberError(accessingType, instance, info.Name); } - public override ErrorInfo/*!*/ MakeStaticPropertyInstanceAccessError(PropertyTracker/*!*/ tracker, bool isAssignment, IList<Expression>/*!*/ parameters) { + public override ErrorInfo/*!*/ MakeStaticPropertyInstanceAccessError(PropertyTracker/*!*/ tracker, bool isAssignment, IList<DynamicMetaObject>/*!*/ parameters) { ContractUtils.RequiresNotNull(tracker, "tracker"); ContractUtils.RequiresNotNull(parameters, "parameters"); @@ -240,36 +240,18 @@ namespace IronPython.Runtime.Binding { } - public override ErrorInfo/*!*/ MakeEventValidation(MemberGroup/*!*/ members, Expression eventObject, Expression/*!*/ value, Expression/*!*/ codeContext) { + public override ErrorInfo/*!*/ MakeEventValidation(MemberGroup/*!*/ members, DynamicMetaObject eventObject, DynamicMetaObject/*!*/ value, OverloadResolverFactory/*!*/ factory) { EventTracker ev = (EventTracker)members[0]; return ErrorInfo.FromValueNoError( Ast.Block( Ast.Call( typeof(PythonOps).GetMethod("SlotTrySetValue"), - codeContext, + ((PythonOverloadResolverFactory)factory)._codeContext, AstUtils.Constant(PythonTypeOps.GetReflectedEvent(ev)), - eventObject != null ? AstUtils.Convert(eventObject, typeof(object)) : AstUtils.Constant(null), + eventObject != null ? AstUtils.Convert(eventObject.Expression, typeof(object)) : AstUtils.Constant(null), AstUtils.Constant(null, typeof(PythonType)), - AstUtils.Convert(value, typeof(object)) - ), - Ast.Constant(null) - ) - ); - } - - public override ErrorInfo MakeEventValidation(RuleBuilder rule, MemberGroup members) { - EventTracker ev = (EventTracker)members[0]; - - return ErrorInfo.FromValueNoError( - Ast.Block( - Ast.Call( - typeof(PythonOps).GetMethod("SlotTrySetValue"), - rule.Context, - AstUtils.Constant(PythonTypeOps.GetReflectedEvent(ev)), - AstUtils.Convert(rule.Parameters[0], typeof(object)), - AstUtils.Constant(null, typeof(PythonType)), - AstUtils.Convert(rule.Parameters[1], typeof(object)) + AstUtils.Convert(value.Expression, typeof(object)) ), Ast.Constant(null) ) @@ -408,33 +390,33 @@ namespace IronPython.Runtime.Binding { return _dlrExtensionTypes.ContainsKey(t); } - public override Expression ReturnMemberTracker(Type type, MemberTracker memberTracker) { - Expression res = ReturnMemberTracker(type, memberTracker, PrivateBinding); + public override DynamicMetaObject ReturnMemberTracker(Type type, MemberTracker memberTracker) { + var res = ReturnMemberTracker(type, memberTracker, PrivateBinding); return res ?? base.ReturnMemberTracker(type, memberTracker); } - private static Expression ReturnMemberTracker(Type type, MemberTracker memberTracker, bool privateBinding) { + private static DynamicMetaObject ReturnMemberTracker(Type type, MemberTracker memberTracker, bool privateBinding) { switch (memberTracker.MemberType) { case TrackerTypes.TypeGroup: - return AstUtils.Constant(memberTracker); + return new DynamicMetaObject(AstUtils.Constant(memberTracker), BindingRestrictions.Empty, memberTracker); case TrackerTypes.Type: return ReturnTypeTracker((TypeTracker)memberTracker); case TrackerTypes.Bound: - return ReturnBoundTracker((BoundMemberTracker)memberTracker, privateBinding); + return new DynamicMetaObject(ReturnBoundTracker((BoundMemberTracker)memberTracker, privateBinding), BindingRestrictions.Empty); case TrackerTypes.Property: - return ReturnPropertyTracker((PropertyTracker)memberTracker, privateBinding); + return new DynamicMetaObject(ReturnPropertyTracker((PropertyTracker)memberTracker, privateBinding), BindingRestrictions.Empty);; case TrackerTypes.Event: - return Ast.Call( + return new DynamicMetaObject(Ast.Call( typeof(PythonOps).GetMethod("MakeBoundEvent"), AstUtils.Constant(PythonTypeOps.GetReflectedEvent((EventTracker)memberTracker)), AstUtils.Constant(null), AstUtils.Constant(type) - ); + ), BindingRestrictions.Empty);; case TrackerTypes.Field: - return ReturnFieldTracker((FieldTracker)memberTracker); + return new DynamicMetaObject(ReturnFieldTracker((FieldTracker)memberTracker), BindingRestrictions.Empty);; case TrackerTypes.MethodGroup: - return ReturnMethodGroup((MethodGroup)memberTracker); + return new DynamicMetaObject(ReturnMethodGroup((MethodGroup)memberTracker), BindingRestrictions.Empty); ; case TrackerTypes.Constructor: MethodBase[] ctors = CompilerHelpers.GetConstructors(type, privateBinding, true); object val; @@ -448,9 +430,13 @@ namespace IronPython.Runtime.Binding { val = PythonTypeOps.GetConstructor(type, InstanceOps.NonDefaultNewInst, ctors); } - return AstUtils.Constant(val); + return new DynamicMetaObject(AstUtils.Constant(val), BindingRestrictions.Empty, val); case TrackerTypes.Custom: - return AstUtils.Constant(((PythonCustomTracker)memberTracker).GetSlot(), typeof(PythonTypeSlot)); + return new DynamicMetaObject( + AstUtils.Constant(((PythonCustomTracker)memberTracker).GetSlot(), typeof(PythonTypeSlot)), + BindingRestrictions.Empty, + ((PythonCustomTracker)memberTracker).GetSlot() + ); } return null; } @@ -621,13 +607,13 @@ namespace IronPython.Runtime.Binding { return Ast.New( typeof(ReflectedIndexer).GetConstructor(new Type[] { typeof(ReflectedIndexer), typeof(object) }), AstUtils.Constant(new ReflectedIndexer(((ReflectedPropertyTracker)pt).Property, NameType.Property, privateBinding)), - boundMemberTracker.Instance + boundMemberTracker.Instance.Expression ); case TrackerTypes.Event: return Ast.Call( typeof(PythonOps).GetMethod("MakeBoundEvent"), AstUtils.Constant(PythonTypeOps.GetReflectedEvent((EventTracker)boundMemberTracker.BoundTo)), - boundMemberTracker.Instance, + boundMemberTracker.Instance.Expression, AstUtils.Constant(boundMemberTracker.DeclaringType) ); case TrackerTypes.MethodGroup: @@ -635,7 +621,7 @@ namespace IronPython.Runtime.Binding { typeof(PythonOps).GetMethod("MakeBoundBuiltinFunction"), AstUtils.Constant(GetBuiltinFunction((MethodGroup)boundTo)), AstUtils.Convert( - boundMemberTracker.Instance, + boundMemberTracker.Instance.Expression, typeof(object) ) ); @@ -662,9 +648,10 @@ namespace IronPython.Runtime.Binding { return AstUtils.Constant(PythonTypeOps.GetReflectedProperty(propertyTracker, null, privateBinding)); } - private static Expression ReturnTypeTracker(TypeTracker memberTracker) { + private static DynamicMetaObject ReturnTypeTracker(TypeTracker memberTracker) { // all non-group types get exposed as PythonType's - return AstUtils.Constant(DynamicHelpers.GetPythonTypeFromType(memberTracker.Type)); + object value = DynamicHelpers.GetPythonTypeFromType(memberTracker.Type); + return new DynamicMetaObject(Ast.Constant(value), BindingRestrictions.Empty, value); } internal ScriptDomainManager/*!*/ DomainManager { Merlin/Main/Languages/IronPython/IronPython/Runtime/Binding/PythonBinder.cs @@ -45,7 +45,7 @@ namespace IronPython.Runtime.Binding { return Defer(self); } - return Context.Binder.DeleteMember(Name, self, AstUtils.Constant(Context.SharedContext)); + return Context.Binder.DeleteMember(Name, self, new PythonOverloadResolverFactory(_context.Binder, AstUtils.Constant(Context.SharedContext))); } public PythonContext/*!*/ Context { Merlin/Main/Languages/IronPython/IronPython/Runtime/Binding/PythonDeleteMemberBinder.cs @@ -520,13 +520,14 @@ namespace IronPython.Runtime.Binding { public DynamicMetaObject/*!*/ Fallback(DynamicMetaObject/*!*/ self, DynamicMetaObject/*!*/ codeContext) { // Python always provides an extra arg to GetMember to flow the context. - return FallbackWorker(self, codeContext, Name, _options, this, null); + return FallbackWorker(_context, self, codeContext, Name, _options, this, null); } - internal static DynamicMetaObject FallbackWorker(DynamicMetaObject/*!*/ self, DynamicMetaObject/*!*/ codeContext, string name, GetMemberOptions options, DynamicMetaObjectBinder action, DynamicMetaObject errorSuggestion) { + internal static DynamicMetaObject FallbackWorker(PythonContext context, DynamicMetaObject/*!*/ self, DynamicMetaObject/*!*/ codeContext, string name, GetMemberOptions options, DynamicMetaObjectBinder action, DynamicMetaObject errorSuggestion) { if (self.NeedsDeferral()) { return action.Defer(self); } + PythonOverloadResolverFactory resolverFactory = new PythonOverloadResolverFactory(context.Binder, codeContext.Expression); PerfTrack.NoteEvent(PerfTrack.Categories.BindingTarget, "FallbackGet"); @@ -544,7 +545,7 @@ namespace IronPython.Runtime.Binding { DynamicMetaObject baseRes = PythonContext.GetPythonContext(action).Binder.GetMember( name, self, - codeContext.Expression, + resolverFactory, isNoThrow, errorSuggestion ); @@ -581,11 +582,11 @@ namespace IronPython.Runtime.Binding { } } - var res = PythonContext.GetPythonContext(action).Binder.GetMember(name, self, codeContext.Expression, isNoThrow, errorSuggestion); + var res = PythonContext.GetPythonContext(action).Binder.GetMember(name, self, resolverFactory, isNoThrow, errorSuggestion); // Default binder can return something typed to boolean or int. // If that happens, we need to apply Python's boxing rules. - if (res.Expression.Type == typeof(bool) || res.Expression.Type == typeof(int)) { + if (res.Expression.Type.IsValueType) { res = new DynamicMetaObject( AstUtils.Convert(res.Expression, typeof(object)), res.Restrictions @@ -605,7 +606,7 @@ namespace IronPython.Runtime.Binding { name ), typeof(object) - ); + ).Expression; } public string Name { @@ -660,16 +661,16 @@ namespace IronPython.Runtime.Binding { } class CompatibilityGetMember : GetMemberBinder, IPythonSite { - private readonly PythonContext/*!*/ _state; + private readonly PythonContext/*!*/ _context; - public CompatibilityGetMember(PythonContext/*!*/ binder, string/*!*/ name) + public CompatibilityGetMember(PythonContext/*!*/ context, string/*!*/ name) : base(name, false) { - _state = binder; + _context = context; } - public CompatibilityGetMember(PythonContext/*!*/ binder, string/*!*/ name, bool ignoreCase) + public CompatibilityGetMember(PythonContext/*!*/ context, string/*!*/ name, bool ignoreCase) : base(name, ignoreCase) { - _state = binder; + _context = context; } public override DynamicMetaObject FallbackGetMember(DynamicMetaObject self, DynamicMetaObject errorSuggestion) { @@ -679,19 +680,19 @@ namespace IronPython.Runtime.Binding { return com; } #endif - return PythonGetMemberBinder.FallbackWorker(self, PythonContext.GetCodeContextMOCls(this), Name, GetMemberOptions.None, this, errorSuggestion); + return PythonGetMemberBinder.FallbackWorker(_context, self, PythonContext.GetCodeContextMOCls(this), Name, GetMemberOptions.None, this, errorSuggestion); } #region IPythonSite Members public PythonContext Context { - get { return _state; } + get { return _context; } } #endregion public override int GetHashCode() { - return base.GetHashCode() ^ _state.Binder.GetHashCode(); + return base.GetHashCode() ^ _context.Binder.GetHashCode(); } public override bool Equals(object obj) { @@ -700,7 +701,7 @@ namespace IronPython.Runtime.Binding { return false; } - return ob._state.Binder == _state.Binder && + return ob._context.Binder == _context.Binder && base.Equals(obj); } } Merlin/Main/Languages/IronPython/IronPython/Runtime/Binding/PythonGetMemberBinder.cs @@ -29,7 +29,7 @@ using System.Collections; namespace IronPython.Runtime.Binding { internal sealed class PythonOverloadResolverFactory : OverloadResolverFactory { private readonly PythonBinder/*!*/ _binder; - private readonly Expression/*!*/ _codeContext; + internal readonly Expression/*!*/ _codeContext; public PythonOverloadResolverFactory(PythonBinder/*!*/ binder, Expression/*!*/ codeContext) { Assert.NotNull(binder, codeContext); @@ -137,7 +137,7 @@ namespace IronPython.Runtime.Binding { } public override Expression Convert(DynamicMetaObject metaObject, Type restrictedType, ParameterInfo info, Type toType) { - return Binder.ConvertExpression(metaObject.Expression, toType, ConversionResultKind.ExplicitCast, _context); + return Binder.ConvertExpression(metaObject.Expression, toType, ConversionResultKind.ExplicitCast, new PythonOverloadResolverFactory(Binder, _context)); } public override Expression GetDynamicConversion(Expression value, Type type) { Merlin/Main/Languages/IronPython/IronPython/Runtime/Binding/PythonOverloadResolver.cs @@ -637,50 +637,6 @@ namespace IronPython.Runtime.Binding { ); } - private static DynamicMetaObject/*!*/ MakeMemberNamesOperation(PythonOperationBinder/*!*/ operation, DynamicMetaObject[] args) { - DynamicMetaObject self = args[0]; - CodeContext context; - if (args.Length > 1 && args[0].GetLimitType() == typeof(CodeContext)) { - self = args[1]; - context = (CodeContext)args[0].Value; - } else { - context = PythonContext.GetPythonContext(operation).SharedContext; - } - - if (typeof(IMembersList).IsAssignableFrom(self.GetLimitType())) { - return MakeIMembersListRule(PythonContext.GetCodeContext(operation), self); - } - - PythonType pt = DynamicHelpers.GetPythonType(self.Value); - List<string> strNames = GetMemberNames(context, pt, self.Value); - - if (pt.IsSystemType) { - return new DynamicMetaObject( - AstUtils.Constant(strNames), - BindingRestrictions.GetInstanceRestriction(self.Expression, self.Value).Merge(self.Restrictions) - ); - } - - return new DynamicMetaObject( - AstUtils.Constant(strNames), - BindingRestrictions.GetInstanceRestriction(self.Expression, self.Value).Merge(self.Restrictions) - ); - } - - private static DynamicMetaObject MakeIMembersListRule(Expression codeContext, DynamicMetaObject target) { - return new DynamicMetaObject( - Ast.Call( - typeof(BinderOps).GetMethod("GetStringMembers"), - Ast.Call( - AstUtils.Convert(target.Expression, typeof(IMembersList)), - typeof(IMembersList).GetMethod("GetMemberNames"), - codeContext - ) - ), - BindingRestrictionsHelpers.GetRuntimeTypeRestriction(target.Expression, target.GetLimitType()).Merge(target.Restrictions) - ); - } - internal static DynamicMetaObject/*!*/ MakeCallSignatureOperation(DynamicMetaObject/*!*/ self, IList<MethodBase/*!*/>/*!*/ targets) { List<string> arrres = new List<string>(); foreach (MethodBase mb in targets) { @@ -1783,10 +1739,14 @@ namespace IronPython.Runtime.Binding { _slot.MakeGetExpression( Binder, AstUtils.Constant(PythonContext.SharedContext), - args[0].Expression, - Ast.Call( - typeof(DynamicHelpers).GetMethod("GetPythonType"), - AstUtils.Convert(args[0].Expression, typeof(object)) + args[0], + new DynamicMetaObject( + Ast.Call( + typeof(DynamicHelpers).GetMethod("GetPythonType"), + AstUtils.Convert(args[0].Expression, typeof(object)) + ), + BindingRestrictions.Empty, + DynamicHelpers.GetPythonType(args[0].Value) ), cb ); Merlin/Main/Languages/IronPython/IronPython/Runtime/Binding/PythonProtocol.Operations.cs @@ -145,7 +145,7 @@ namespace IronPython.Runtime.Binding { callSlot.MakeGetExpression( pyContext.Binder, PythonContext.GetCodeContext(call), - self.Expression, + self, GetPythonType(self), cb ); @@ -187,17 +187,25 @@ namespace IronPython.Runtime.Binding { return null; } - private static Expression/*!*/ GetPythonType(DynamicMetaObject/*!*/ self) { + private static DynamicMetaObject/*!*/ GetPythonType(DynamicMetaObject/*!*/ self) { Assert.NotNull(self); PythonType pt = DynamicHelpers.GetPythonType(self.Value); if (pt.IsSystemType) { - return AstUtils.Constant(pt); + return new DynamicMetaObject( + AstUtils.Constant(pt), + BindingRestrictions.Empty, + pt + ); } - return Ast.Property( - Ast.Convert(self.Expression, typeof(IPythonObject)), - TypeInfo._IPythonObject.PythonType + return new DynamicMetaObject( + Ast.Property( + Ast.Convert(self.Expression, typeof(IPythonObject)), + TypeInfo._IPythonObject.PythonType + ), + BindingRestrictions.Empty, + pt ); } Merlin/Main/Languages/IronPython/IronPython/Runtime/Binding/PythonProtocol.cs @@ -51,7 +51,7 @@ namespace IronPython.Runtime.Binding { return com; } #endif - return Context.Binder.SetMember(Name, self, value, AstUtils.Constant(Context.SharedContext)); + return Context.Binder.SetMember(Name, self, value, new PythonOverloadResolverFactory(_context.Binder, AstUtils.Constant(Context.SharedContext))); } public override T BindDelegate<T>(CallSite<T> site, object[] args) { Merlin/Main/Languages/IronPython/IronPython/Runtime/Binding/PythonSetMemberBinder.cs @@ -659,7 +659,7 @@ namespace IronPython.Runtime { ); } - public virtual string/*!*/ __repr__(Microsoft.Scripting.Runtime.CodeContext context) { + public virtual string/*!*/ __repr__(CodeContext context) { return _bytes.BytesRepr(); } Merlin/Main/Languages/IronPython/IronPython/Runtime/Bytes.cs @@ -360,7 +360,7 @@ the assembly object.")] private static void PublishTypeLibDesc(CodeContext context, ComTypeLibDesc typeLibDesc) { SymbolId symbol = SymbolTable.StringToId(typeLibDesc.Name); - context.LanguageContext.DomainManager.Globals.SetName(symbol, typeLibDesc); + context.LanguageContext.DomainManager.Globals.SetVariable(symbol, typeLibDesc); } #endif private static void AddReferenceByName(CodeContext/*!*/ context, string name) { @@ -438,13 +438,14 @@ import Namespace.")] string path = System.IO.Path.GetDirectoryName(file); List list; - if (!PythonContext.GetContext(context).TryGetSystemPath(out list)) { + PythonContext pc = PythonContext.GetContext(context); + if (!pc.TryGetSystemPath(out list)) { throw PythonOps.TypeError("cannot update path, it is not a list"); } list.append(path); - Assembly asm = DefaultContext.Default.LanguageContext.LoadAssemblyFromFile(file); + Assembly asm = pc.LoadAssemblyFromFile(file); if (asm == null) throw PythonOps.IOError("file does not exist: {0}", file); AddReference(context, asm); } Merlin/Main/Languages/IronPython/IronPython/Runtime/ClrModule.cs @@ -149,7 +149,7 @@ namespace IronPython.Runtime { } [SpecialName, PropertyMethod, WrapperDescriptor] - public static void Set__doc__(PythonProperty self) { + public static void Set__doc__(PythonProperty self, object value) { throw PythonOps.TypeError("'property' object is immutable"); } Merlin/Main/Languages/IronPython/IronPython/Runtime/Descriptors.cs @@ -1104,7 +1104,7 @@ for k, v in toError.iteritems(): /// </summary> [PythonHidden] public static PythonType CreateSubType(PythonContext/*!*/ context, PythonType baseType, string name, string module, string documentation) { - PythonType res = new PythonType(null, baseType, name, module, documentation); + PythonType res = new PythonType(context, baseType, name, module, documentation); res.SetCustomMember(context.SharedContext, Symbols.WeakRef, new PythonTypeWeakRefSlot(res)); res.IsWeakReferencable = true; return res; Merlin/Main/Languages/IronPython/IronPython/Runtime/Exceptions/PythonExceptions.cs @@ -98,11 +98,11 @@ namespace IronPython.Runtime.Exceptions { } internal TraceBackFrame(PythonTracebackListener traceAdapter, object code, TraceBackFrame back, PythonDebuggingPayload debugProperties, Func<Scope> scopeCallback) { - this._traceAdapter = traceAdapter; - this._code = code; - this._back = back; - this._debugProperties = debugProperties; - this._scopeCallback = scopeCallback; + _traceAdapter = traceAdapter; + _code = code; + _back = back; + _debugProperties = debugProperties; + _scopeCallback = scopeCallback; } public TracebackDelegate f_trace { Merlin/Main/Languages/IronPython/IronPython/Runtime/Exceptions/TraceBack.cs @@ -44,9 +44,9 @@ namespace IronPython.Runtime { public static void PerformModuleReload(PythonContext context, IAttributesCollection dict) { Scope scope = Importer.ImportModule(context.SharedContext, context.SharedContext.GlobalScope.Dict, "itertools", false, -1) as Scope; if (scope != null) { - dict[SymbolTable.StringToId("map")] = scope.LookupName(context, SymbolTable.StringToId("imap")); - dict[SymbolTable.StringToId("filter")] = scope.LookupName(context, SymbolTable.StringToId("ifilter")); - dict[SymbolTable.StringToId("zip")] = scope.LookupName(context, SymbolTable.StringToId("izip")); + dict[SymbolTable.StringToId("map")] = scope.GetVariable(SymbolTable.StringToId("imap")); + dict[SymbolTable.StringToId("filter")] = scope.GetVariable(SymbolTable.StringToId("ifilter")); + dict[SymbolTable.StringToId("zip")] = scope.GetVariable(SymbolTable.StringToId("izip")); } } Merlin/Main/Languages/IronPython/IronPython/Runtime/FutureBuiltins.cs @@ -19,7 +19,7 @@ using Microsoft.Scripting.Runtime; namespace IronPython.Runtime { internal class GlobalScopeDictionaryStorage : ScopeDictionaryStorage { public GlobalScopeDictionaryStorage(Scope scope) - : base(scope.ModuleScope) { + : base(CodeContext.GetModuleScope(scope)) { } Merlin/Main/Languages/IronPython/IronPython/Runtime/GlobalScopeDictionaryStorage.cs @@ -102,13 +102,13 @@ namespace IronPython.Runtime { NamespaceTracker nt; if (scope != null) { object ret; - if (scope.TryGetName(SymbolTable.StringToId(name), out ret)) { + if (scope.TryGetVariable(SymbolTable.StringToId(name), out ret)) { return ret; } object path; List listPath; - if (scope.TryGetName(Symbols.Path, out path) && (listPath = path as List) != null) { + if (scope.TryGetVariable(Symbols.Path, out path) && (listPath = path as List) != null) { return ImportNestedModule(context, scope, name, listPath); } } else if ((pt = from as PythonType) != null) { @@ -141,7 +141,7 @@ namespace IronPython.Runtime { if (scope != null) { object path; List listPath; - if (scope.TryGetName(Symbols.Path, out path) && (listPath = path as List) != null) { + if (scope.TryGetVariable(Symbols.Path, out path) && (listPath = path as List) != null) { return ImportNestedModule(context, scope, name, listPath); } } @@ -209,7 +209,7 @@ namespace IronPython.Runtime { if (!TryGetExistingOrMetaPathModule(context, name, path, out newmod)) { newmod = ImportFromPath(context, parts[0], name, path); if (newmod != null && parentScope != null) { - parentScope.SetName(SymbolTable.StringToId(modName), newmod); + parentScope.SetVariable(SymbolTable.StringToId(modName), newmod); } } else if (parts.Length == 1) { // if we imported before having the assembly @@ -229,8 +229,8 @@ namespace IronPython.Runtime { object parentPkg; if (package != null && !PythonContext.GetContext(context).SystemStateModules.TryGetValue(package, out parentPkg)) { Scope warnScope = new Scope(); - warnScope.SetName(Symbols.File, package); - warnScope.SetName(Symbols.Name, package); + warnScope.SetVariable(Symbols.File, package); + warnScope.SetVariable(Symbols.Name, package); PythonOps.Warn( new CodeContext(warnScope, context.LanguageContext), PythonExceptions.RuntimeWarning, @@ -462,7 +462,7 @@ namespace IronPython.Runtime { if (parentScope != null) { object objPath; // get its path as a List if it's there - if (parentScope.TryGetName(Symbols.Path, out objPath)) { + if (parentScope.TryGetVariable(Symbols.Path, out objPath)) { path = objPath as List; } } @@ -591,7 +591,7 @@ namespace IronPython.Runtime { private static bool TryGetNestedModule(CodeContext/*!*/ context, Scope/*!*/ scope, string/*!*/ name, out object nested) { Assert.NotNull(context, scope, name); - if (scope.TryGetName(SymbolTable.StringToId(name), out nested)) { + if (scope.TryGetVariable(SymbolTable.StringToId(name), out nested)) { if (nested is Scope) return true; // This allows from System.Math import * @@ -611,7 +611,7 @@ namespace IronPython.Runtime { string fullName = CreateFullName(module.GetName() as string, name); if (TryGetExistingOrMetaPathModule(context, fullName, path, out ret)) { - module.Scope.SetName(SymbolTable.StringToId(name), ret); + module.Scope.SetVariable(SymbolTable.StringToId(name), ret); return ret; } @@ -619,7 +619,7 @@ namespace IronPython.Runtime { object importedScope = ImportFromPath(context, name, fullName, path); if (importedScope != null) { - module.Scope.SetName(SymbolTable.StringToId(name), importedScope); + module.Scope.SetVariable(SymbolTable.StringToId(name), importedScope); return importedScope; } @@ -628,12 +628,12 @@ namespace IronPython.Runtime { private static object FindImportFunction(CodeContext/*!*/ context) { object builtin, import; - if (!context.GlobalScope.TryGetName(Symbols.Builtins, out builtin)) { + if (!context.GlobalScope.TryGetVariable(Symbols.Builtins, out builtin)) { builtin = PythonContext.GetContext(context).BuiltinModuleInstance; } Scope scope = builtin as Scope; - if (scope != null && scope.TryGetName(Symbols.Import, out import)) { + if (scope != null && scope.TryGetVariable(Symbols.Import, out import)) { return import; } @@ -669,7 +669,7 @@ namespace IronPython.Runtime { private static object ImportReflected(CodeContext/*!*/ context, string/*!*/ name) { object ret; PythonContext pc = PythonContext.GetContext(context); - if (!pc.DomainManager.Globals.TryGetName(SymbolTable.StringToId(name), out ret)) { + if (!pc.DomainManager.Globals.TryGetVariable(SymbolTable.StringToId(name), out ret)) { ret = TryImportSourceFile(pc, name); } @@ -713,7 +713,7 @@ namespace IronPython.Runtime { // foreign language, we should publish in sys.modules too context.SystemStateModules[name] = scope; } - sourceUnit.LanguageContext.DomainManager.Globals.SetName(SymbolTable.StringToId(name), scope); + sourceUnit.LanguageContext.DomainManager.Globals.SetVariable(SymbolTable.StringToId(name), scope); return scope; } Merlin/Main/Languages/IronPython/IronPython/Runtime/Importer.cs @@ -13,6 +13,7 @@ * * ***************************************************************************/ +using System.Collections.Generic; using Microsoft.Scripting.Runtime; namespace IronPython.Runtime { @@ -53,4 +54,18 @@ namespace IronPython.Runtime { public interface IProxyObject { object Target { get; } } + + /// <summary> + /// Provides a list of all the members of an instance. ie. all the keys in the + /// dictionary of the object. Note that it can contain objects that are not strings. + /// + /// Such keys can be added in IronPython using syntax like: + /// obj.__dict__[100] = someOtherObject + /// + /// This Python specific version also supports filtering based upon the show cls + /// flag by flowing in the code context. + /// </summary> + public interface IPythonMembersList : IMembersList { + IList<object> GetMemberNames(CodeContext context); + } } \ No newline at end of file Merlin/Main/Languages/IronPython/IronPython/Runtime/Interfaces.cs @@ -28,7 +28,7 @@ using IronPython.Runtime.Types; namespace IronPython.Runtime { [PythonType("instancemethod"), DontMapGetMemberNamesToDir] - public sealed partial class Method : PythonTypeSlot, IWeakReferenceable, IMembersList, IDynamicMetaObjectProvider, ICodeFormattable { + public sealed partial class Method : PythonTypeSlot, IWeakReferenceable, IPythonMembersList, IDynamicMetaObjectProvider, ICodeFormattable { private readonly object _func; private readonly object _inst; private readonly object _declaringClass; @@ -204,7 +204,11 @@ namespace IronPython.Runtime { TypeCache.Method.DeleteMember(context, this, SymbolTable.StringToId(name)); } - IList<object> IMembersList.GetMemberNames(CodeContext context) { + IList<string> IMembersList.GetMemberNames() { + return PythonOps.GetStringMemberList(this); + } + + IList<object> IPythonMembersList.GetMemberNames(CodeContext/*!*/ context) { List ret = TypeCache.Method.GetMemberNames(context); ret.AddNoLockNoDups(SymbolTable.IdToString(Symbols.Module)); Merlin/Main/Languages/IronPython/IronPython/Runtime/Method.cs @@ -42,7 +42,7 @@ namespace IronPython.Runtime { if (pc.SystemStateModules.TryGetValue(_parentName, out parent)) { Scope s = parent as Scope; if (s != null) { - s.SetName(SymbolTable.StringToId(_name), res); + s.SetVariable(SymbolTable.StringToId(_name), res); } } } Merlin/Main/Languages/IronPython/IronPython/Runtime/ModuleLoader.cs @@ -501,7 +501,7 @@ namespace IronPython.Runtime.Operations { PythonTuple data = ClrModule.Serialize(self); object deserializeNew; - bool res = PythonContext.GetContext(context).ClrModule.TryGetName( + bool res = PythonContext.GetContext(context).ClrModule.TryGetVariable( SymbolTable.StringToId("Deserialize"), out deserializeNew ); Merlin/Main/Languages/IronPython/IronPython/Runtime/Operations/InstanceOps.cs @@ -1006,10 +1006,25 @@ namespace IronPython.Runtime.Operations { throw PythonOps.AttributeErrorForMissingAttribute(PythonTypeOps.GetName(o), name); } + internal static IList<string> GetStringMemberList(IPythonMembersList pyMemList) { + List<string> res = new List<string>(); + foreach (object o in pyMemList.GetMemberNames(DefaultContext.Default)) { + if (o is string) { + res.Add((string)o); + } + } + return res; + } + public static IList<object> GetAttrNames(CodeContext/*!*/ context, object o) { + IPythonMembersList pyMemList = o as IPythonMembersList; + if (pyMemList != null) { + return pyMemList.GetMemberNames(context); + } + IMembersList memList = o as IMembersList; if (memList != null) { - return memList.GetMemberNames(context); + return new List(memList.GetMemberNames()); } IPythonObject po = o as IPythonObject; @@ -1220,7 +1235,7 @@ namespace IronPython.Runtime.Operations { } // Otherwise, if there's a global variable named __metaclass__, it is used. - if (context.GlobalScope.TryLookupName(Symbols.MetaClass, out ret) && ret != null) { + if (context.GlobalScope.TryGetVariable(Symbols.MetaClass, out ret) && ret != null) { return ret; } @@ -1661,22 +1676,22 @@ namespace IronPython.Runtime.Operations { // we special case several types to avoid one-off code gen of dynamic sites if (scope != null) { - context.Scope.SetName(fieldId, scope.Dict[fieldId]); + context.Scope.SetVariable(fieldId, scope.Dict[fieldId]); } else if (nt != null) { object value = NamespaceTrackerOps.GetCustomMember(context, nt, name); if (value != OperationFailed.Value) { - context.Scope.SetName(fieldId, value); + context.Scope.SetVariable(fieldId, value); } } else if (pt != null) { PythonTypeSlot pts; object value; if (pt.TryResolveSlot(context, fieldId, out pts) && pts.TryGetValue(context, null, pt, out value)) { - context.Scope.SetName(fieldId, value); + context.Scope.SetVariable(fieldId, value); } } else { // not a known type, we'll do use a site to do the get... - context.Scope.SetName(fieldId, PythonOps.GetBoundAttr(context, newmod, fieldId)); + context.Scope.SetVariable(fieldId, PythonOps.GetBoundAttr(context, newmod, fieldId)); } } } @@ -2004,8 +2019,12 @@ namespace IronPython.Runtime.Operations { // dynamic method, strip the trailing id... name = name.Substring(0, name.IndexOf('#')); } - CodeContext context = frame.CodeContext; - if (context == null) { + + PythonDynamicStackFrame pyFrame = frame as PythonDynamicStackFrame; + CodeContext context; + if (pyFrame != null) { + context = pyFrame.CodeContext; + } else { context = DefaultContext.Default; } @@ -3038,7 +3057,7 @@ namespace IronPython.Runtime.Operations { [NoSideEffects] public static object CheckUninitialized(object value, SymbolId name) { if (value == Uninitialized.Instance) { - ScriptingRuntimeHelpers.ThrowUnboundLocalError(name); + throw new UnboundLocalException(String.Format("Local variable '{0}' referenced before assignment.", SymbolTable.IdToString(name))); } return value; } @@ -3208,7 +3227,7 @@ namespace IronPython.Runtime.Operations { } public static void ModuleStarted(CodeContext/*!*/ context, PythonLanguageFeatures features) { - PythonModule scopeExtension = (PythonModule)context.LanguageContext.EnsureScopeExtension(context.Scope.ModuleScope); + PythonModule scopeExtension = (PythonModule)context.LanguageContext.EnsureScopeExtension(context.GlobalScope); scopeExtension.LanguageFeatures |= features; } @@ -3502,22 +3521,33 @@ namespace IronPython.Runtime.Operations { /// <summary> /// Called from generated code, helper to remove a name /// </summary> - public static object RemoveName(CodeContext context, SymbolId name) { - return context.LanguageContext.RemoveName(context.Scope, name); + public static void RemoveName(CodeContext context, SymbolId name) { + if (!context.Scope.TryRemoveVariable(name)) { + throw PythonOps.NameError(name); + } } /// <summary> /// Called from generated code, helper to do name lookup /// </summary> public static object LookupName(CodeContext context, SymbolId name) { - return context.LanguageContext.LookupName(context.Scope, name); + object value; + if (context.TryLookupName(name, out value) && value != Uninitialized.Instance) { + return value; + } + + if (context.TryLookupGlobal(name, out value) && value != Uninitialized.Instance) { + return value; + } + + throw PythonOps.NameError(name); } /// <summary> /// Called from generated code, helper to do name assignment /// </summary> public static object SetName(CodeContext context, SymbolId name, object value) { - context.LanguageContext.SetName(context.Scope, name, value); + context.Scope.SetVariable(name, value); return value; } @@ -3585,24 +3615,30 @@ namespace IronPython.Runtime.Operations { return generator.Context; } - public static object GetGlobal(Scope scope, SymbolId name) { - return GetVariable(scope.ModuleScope, name, true); + public static object GetGlobal(CodeContext/*!*/ context, SymbolId name) { + return GetVariable(context, name, true); } - public static object GetLocal(Scope scope, SymbolId name) { - return GetVariable(scope, name, false); + public static object GetLocal(CodeContext/*!*/ context, SymbolId name) { + return GetVariable(context, name, false); } - private static object GetVariable(Scope scope, SymbolId name, bool isGlobal) { + private static object GetVariable(CodeContext/*!*/ context, SymbolId name, bool isGlobal) { object res; - if (scope.TryLookupName(name, out res)) { - return res; + if (isGlobal) { + if (context.GlobalScope.TryGetVariable(name, out res)) { + return res; + } + } else { + if (context.TryLookupName(name, out res)) { + return res; + } } object builtins; - if (scope.ModuleScope.TryGetName(Symbols.Builtins, out builtins)) { + if (context.GlobalScope.TryGetVariable(Symbols.Builtins, out builtins)) { Scope builtinsScope = builtins as Scope; - if (builtinsScope != null && builtinsScope.TryGetName(name, out res)) { + if (builtinsScope != null && builtinsScope.TryGetVariable(name, out res)) { return res; } @@ -3618,46 +3654,51 @@ namespace IronPython.Runtime.Operations { throw NameError(name); } - public static object RawGetGlobal(Scope scope, SymbolId name) { - return RawGetLocal(scope.ModuleScope, name); + public static object RawGetGlobal(CodeContext/*!*/ context, SymbolId name) { + object res; + if (context.GlobalScope.TryGetVariable(name, out res)) { + return res; + } + + return Uninitialized.Instance; } - public static object RawGetLocal(Scope scope, SymbolId name) { + public static object RawGetLocal(CodeContext/*!*/ context, SymbolId name) { object res; - if (scope.TryLookupName(name, out res)) { + if (context.TryLookupName(name, out res)) { return res; } return Uninitialized.Instance; } - public static void SetGlobal(Scope scope, SymbolId name, object value) { - scope.ModuleScope.Dict[name] = value; + public static void SetGlobal(CodeContext/*!*/ context, SymbolId name, object value) { + context.GlobalScope.Dict[name] = value; } - public static void SetLocal(Scope scope, SymbolId name, object value) { - scope.Dict[name] = value; + public static void SetLocal(CodeContext/*!*/ context, SymbolId name, object value) { + context.Scope.Dict[name] = value; } - public static void DeleteGlobal(Scope scope, SymbolId name) { - if (scope.ModuleScope.Dict.Remove(name)) { + public static void DeleteGlobal(CodeContext/*!*/ context, SymbolId name) { + if (context.GlobalScope.Dict.Remove(name)) { return; } throw NameError(name); } - public static void DeleteLocal(Scope scope, SymbolId name) { - if (scope.Dict.Remove(name)) { + public static void DeleteLocal(CodeContext/*!*/ context, SymbolId name) { + if (context.Scope.Dict.Remove(name)) { return; } throw NameError(name); - } + public static CodeContext/*!*/ CreateTopLevelCodeContext(Scope/*!*/ scope, LanguageContext/*!*/ context) { - context.EnsureScopeExtension(scope.ModuleScope); - return new CodeContext(scope, context); + context.EnsureScopeExtension(CodeContext.GetModuleScope(scope)); + return new CodeContext(scope, (PythonContext)context); } public static PythonGlobal/*!*/[]/*!*/ GetGlobalArray(Scope/*!*/ scope) { @@ -4062,6 +4103,20 @@ namespace IronPython.Runtime.Operations { code.Parameters ); } + + public static void UpdateStackTrace(CodeContext context, MethodBase method, string funcName, string filename, int line) { + if (line != -1) { + Debug.Assert(filename != null); + if (ExceptionHelpers.DynamicStackFrames == null) { + ExceptionHelpers.DynamicStackFrames = new List<DynamicStackFrame>(); + } + + Debug.Assert(line != SourceLocation.None.Line); + + ExceptionHelpers.DynamicStackFrames.Add(new PythonDynamicStackFrame(context, method, funcName, filename, line)); + } + } + } public struct FunctionStack { Merlin/Main/Languages/IronPython/IronPython/Runtime/Operations/PythonOps.cs @@ -52,10 +52,10 @@ namespace IronPython.Runtime.Types { } public static void __init__(Scope/*!*/ scope, string name, string documentation) { - scope.SetName(Symbols.Name, name); + scope.SetVariable(Symbols.Name, name); if (documentation != null) { - scope.SetName(Symbols.Doc, documentation); + scope.SetVariable(Symbols.Doc, documentation); } } @@ -68,7 +68,7 @@ namespace IronPython.Runtime.Types { SymbolId si = SymbolTable.StringToId(name); object res; - if (self.TryGetName(si, out res)) { + if (self.TryGetVariable(si, out res)) { return res; } @@ -85,7 +85,7 @@ namespace IronPython.Runtime.Types { SymbolId si = SymbolTable.StringToId(name); object res; - if (self.TryGetName(si, out res)) { + if (self.TryGetVariable(si, out res)) { return res; } @@ -98,12 +98,12 @@ namespace IronPython.Runtime.Types { } public static void __setattr__(Scope/*!*/ self, string name, object value) { - self.SetName(SymbolTable.StringToId(name), value); + self.SetVariable(SymbolTable.StringToId(name), value); } public static void __delattr__(Scope/*!*/ self, string name) { SymbolId si = SymbolTable.StringToId(name); - if (!self.TryRemoveName(si)) { + if (!self.TryRemoveVariable(si)) { throw PythonOps.AttributeErrorForMissingAttribute("module", si); } } @@ -161,7 +161,7 @@ namespace IronPython.Runtime.Types { [SpecialName] public static object GetCustomMember(CodeContext/*!*/ context, Scope/*!*/ scope, string name) { object value; - if (scope.TryGetName(SymbolTable.StringToId(name), out value)) { + if (scope.TryGetVariable(SymbolTable.StringToId(name), out value)) { if (value != Uninitialized.Instance) { return value; } @@ -174,13 +174,13 @@ namespace IronPython.Runtime.Types { if (name == "__dict__") { Set__dict__(scope, value); } else { - scope.SetName(SymbolTable.StringToId(name), value); + scope.SetVariable(SymbolTable.StringToId(name), value); } } [SpecialName] public static bool DeleteMember(CodeContext/*!*/ context, Scope/*!*/ scope, string name) { - return scope.TryRemoveName(SymbolTable.StringToId(name)); + return scope.TryRemoveVariable(SymbolTable.StringToId(name)); } } } Merlin/Main/Languages/IronPython/IronPython/Runtime/Operations/ScopeOps.cs @@ -61,6 +61,7 @@ namespace IronPython.Runtime { private readonly PythonOptions/*!*/ _options; private readonly Scope/*!*/ _systemState; private readonly Dictionary<string, Type>/*!*/ _builtinsDict; + private readonly PythonOverloadResolverFactory _sharedOverloadResolverFactory; #if !SILVERLIGHT private readonly AssemblyResolveHolder _resolveHolder; #endif @@ -190,6 +191,7 @@ namespace IronPython.Runtime { Scope defaultScope = new Scope(); _defaultContext = new CodeContext(defaultScope, this); PythonBinder binder = new PythonBinder(manager, this, _defaultContext); + _sharedOverloadResolverFactory = new PythonOverloadResolverFactory(binder, Expression.Constant(_defaultContext)); Binder = binder; CodeContext defaultClsContext = DefaultContext.CreateDefaultCLSContext(this); @@ -251,12 +253,17 @@ namespace IronPython.Runtime { if (options == null || !options.TryGetValue("NoAssemblyResolveHook", out asmResolve) || !System.Convert.ToBoolean(asmResolve)) { - HookAssemblyResolve(); + try { + HookAssemblyResolve(); + } catch (System.Security.SecurityException) { + // We may not have SecurityPermissionFlag.ControlAppDomain. + // If so, we will not look up sys.path for module loads + } } #endif _equalityComparer = new PythonEqualityComparer(this); - + EnsureModule(_defaultContext); } @@ -967,8 +974,8 @@ namespace IronPython.Runtime { } PythonModule mod = CreateModule(null, new Scope(dict), null, options); - mod.Scope.SetName(Symbols.Name, moduleName); - mod.Scope.SetName(Symbols.Package, null); + mod.Scope.SetVariable(Symbols.Name, moduleName); + mod.Scope.SetVariable(Symbols.Package, null); return mod; } @@ -997,8 +1004,8 @@ namespace IronPython.Runtime { if ((options & ModuleOptions.Initialize) != 0) { scriptCode.Run(module.Scope); - if (!scope.ContainsName(Symbols.Package)) { - scope.SetName(Symbols.Package, null); + if (!scope.ContainsVariable(Symbols.Package)) { + scope.SetVariable(Symbols.Package, null); } } @@ -1016,9 +1023,9 @@ namespace IronPython.Runtime { // pass the appropriate flags to control this behavior. if ((options & ModuleOptions.NoBuiltins) == 0 && !scope.Dict.ContainsKey(Symbols.Builtins)) { if ((options & ModuleOptions.ModuleBuiltins) != 0) { - module.Scope.SetName(Symbols.Builtins, BuiltinModuleInstance); + module.Scope.SetVariable(Symbols.Builtins, BuiltinModuleInstance); } else { - module.Scope.SetName(Symbols.Builtins, BuiltinModuleInstance.Dict); + module.Scope.SetVariable(Symbols.Builtins, BuiltinModuleInstance.Dict); } } @@ -1027,7 +1034,7 @@ namespace IronPython.Runtime { if (fileName != null && Path.GetFileName(fileName) == "__init__.py") { string dirname = Path.GetDirectoryName(fileName); string dir_path = DomainManager.Platform.GetFullPath(dirname); - module.Scope.SetName(Symbols.Path, PythonOps.MakeList(dir_path)); + module.Scope.SetVariable(Symbols.Path, PythonOps.MakeList(dir_path)); } return module; @@ -1049,7 +1056,7 @@ namespace IronPython.Runtime { } object name; - if (!scope.TryLookupName(Symbols.Name, out name) || !(name is string)) { + if (!scope.TryGetVariable(Symbols.Name, out name) || !(name is string)) { throw PythonOps.SystemError("nameless module"); } @@ -1085,31 +1092,6 @@ namespace IronPython.Runtime { } } - /// <summary> - /// Python's global scope includes looking at built-ins. First check built-ins, and if - /// not there then fallback to any DLR globals. - /// </summary> - public override bool TryLookupGlobal(Scope scope, SymbolId name, out object value) { - object builtins; - if (!scope.ModuleScope.TryGetName(Symbols.Builtins, out builtins)) { - value = null; - return false; - } - - Scope builtinsScope = builtins as Scope; - if (builtinsScope != null && builtinsScope.TryGetName(name, out value)) return true; - - IAttributesCollection dict = builtins as IAttributesCollection; - if (dict != null && dict.TryGetValue(name, out value)) return true; - - value = null; - return false; - } - - protected override Exception MissingName(SymbolId name) { - throw PythonOps.NameError(name); - } - internal ModuleGlobalCache GetModuleGlobalCache(SymbolId name) { ModuleGlobalCache res; if (!TryGetModuleGlobalCache(name, out res)) { @@ -1121,7 +1103,7 @@ namespace IronPython.Runtime { #region Assembly Loading - public override Assembly LoadAssemblyFromFile(string file) { + internal Assembly LoadAssemblyFromFile(string file) { #if !SILVERLIGHT // check all files in the path... List path; @@ -1165,13 +1147,9 @@ namespace IronPython.Runtime { /// However, when the CLR loader tries to resolve any of assembly references, it will not be able to /// find the dependencies, unless we can hook into the CLR loader. /// </summary> + [MethodImpl(MethodImplOptions.NoInlining)] // avoid inlining due to LinkDemand from assembly resolve. private void HookAssemblyResolve() { - try { - AppDomain.CurrentDomain.AssemblyResolve += _resolveHolder.AssemblyResolveEvent; - } catch (System.Security.SecurityException) { - // We may not have SecurityPermissionFlag.ControlAppDomain. - // If so, we will not look up sys.path for module loads - } + AppDomain.CurrentDomain.AssemblyResolve += _resolveHolder.AssemblyResolveEvent; } class AssemblyResolveHolder { @@ -1230,7 +1208,7 @@ namespace IronPython.Runtime { #endif try { - if (_systemState.TryGetName(Symbols.SysExitFunc, out callable)) { + if (_systemState.TryGetVariable(Symbols.SysExitFunc, out callable)) { PythonCalls.Call(new CodeContext(new Scope(), this), callable); } } finally { @@ -1702,7 +1680,7 @@ namespace IronPython.Runtime { // only cache values currently in built-ins, everything else will have // no caching policy and will fall back to the LanguageContext. object value; - if (BuiltinModuleInstance.TryGetName(name, out value)) { + if (BuiltinModuleInstance.TryGetVariable(name, out value)) { _builtinCache[name] = cache = new ModuleGlobalCache(value); } } @@ -2775,6 +2753,16 @@ namespace IronPython.Runtime { } /// <summary> + /// Returns an overload resolver for the current PythonContext. The overload + /// resolver will flow the shared context through as it's CodeContext. + /// </summary> + internal PythonOverloadResolverFactory SharedOverloadResolverFactory { + get { + return _sharedOverloadResolverFactory; + } + } + + /// <summary> /// Returns a shared code context for the current PythonContext. This shared /// context can be used for doing lookups which need to occur as if they /// happened in a module which has done "import clr". Merlin/Main/Languages/IronPython/IronPython/Runtime/PythonContext.cs @@ -39,7 +39,7 @@ namespace IronPython.Runtime { /// Created for a user-defined function. /// </summary> [PythonType("function"), DontMapGetMemberNamesToDir] - public sealed partial class PythonFunction : PythonTypeSlot, IWeakReferenceable, IMembersList, IDynamicMetaObjectProvider, ICodeFormattable, Binding.IFastInvokable { + public sealed partial class PythonFunction : PythonTypeSlot, IWeakReferenceable, IPythonMembersList, IDynamicMetaObjectProvider, ICodeFormattable, Binding.IFastInvokable { private readonly CodeContext/*!*/ _context; // the creating code context of the function [PythonHidden] public readonly MutableTuple Closure; @@ -440,7 +440,11 @@ namespace IronPython.Runtime { return _dict.Remove(SymbolTable.StringToId(name)); } - IList<object> IMembersList.GetMemberNames(CodeContext context) { + IList<string> IMembersList.GetMemberNames() { + return PythonOps.GetStringMemberList(this); + } + + IList<object> IPythonMembersList.GetMemberNames(CodeContext/*!*/ context) { List list; if (_dict == null) { list = PythonOps.MakeList(); Merlin/Main/Languages/IronPython/IronPython/Runtime/PythonFunction.cs @@ -157,13 +157,13 @@ namespace IronPython.Runtime { internal object GetName() { object result; - Scope.TryLookupName(Symbols.Name, out result); + Scope.TryGetVariable(Symbols.Name, out result); return result; } internal object GetFile() { object result; - Scope.TryLookupName(Symbols.File, out result); + Scope.TryGetVariable(Symbols.File, out result); return result; } } Merlin/Main/Languages/IronPython/IronPython/Runtime/PythonModule.cs @@ -28,14 +28,14 @@ namespace IronPython.Runtime { public override void Add(object key, object value) { string strKey = key as string; if (strKey != null) { - Scope.SetName(SymbolTable.StringToId(strKey), value); + Scope.SetVariable(SymbolTable.StringToId(strKey), value); } else { Scope.SetObjectName(key, value); } } public override void Add(SymbolId key, object value) { - Scope.SetName(key, value); + Scope.SetVariable(key, value); } public override bool Contains(object key) { @@ -49,7 +49,7 @@ namespace IronPython.Runtime { public override bool Contains(SymbolId key) { foreach (Scope scope in GetVisibleScopes()) { - if (scope.ContainsName(key)) { + if (scope.ContainsVariable(key)) { return true; } } @@ -60,7 +60,7 @@ namespace IronPython.Runtime { foreach (Scope scope in GetVisibleScopes()) { string strKey = key as string; if (strKey != null) { - if (scope.TryRemoveName(SymbolTable.StringToId(strKey))) { + if (scope.TryRemoveVariable(SymbolTable.StringToId(strKey))) { return true; } } else if (scope.TryRemoveObjectName(key)) { @@ -75,7 +75,7 @@ namespace IronPython.Runtime { foreach (Scope scope in GetVisibleScopes()) { string strKey = key as string; if (strKey != null) { - if (scope.TryGetName(SymbolTable.StringToId(strKey), out value)) { + if (scope.TryGetVariable(SymbolTable.StringToId(strKey), out value)) { return true; } } else if (scope.TryGetObjectName(key, out value)) { @@ -89,7 +89,7 @@ namespace IronPython.Runtime { public override bool TryGetValue(SymbolId key, out object value) { foreach (Scope scope in GetVisibleScopes()) { - if (scope.TryGetName(key, out value)) { + if (scope.TryGetVariable(key, out value)) { return true; } } @@ -130,7 +130,7 @@ namespace IronPython.Runtime { string strKey = key as string; if (strKey != null) { object dummy; - if (scope.TryGetName(SymbolTable.StringToId(strKey), out dummy)) { + if (scope.TryGetVariable(SymbolTable.StringToId(strKey), out dummy)) { return true; } } else { Merlin/Main/Languages/IronPython/IronPython/Runtime/ScopeDictionaryStorage.cs @@ -329,7 +329,7 @@ namespace IronPython.Runtime.Types { } } - internal override void MakeGetExpression(PythonBinder/*!*/ binder, Expression/*!*/ codeContext, Expression instance, Expression/*!*/ owner, ConditionalBuilder/*!*/ builder) { + internal override void MakeGetExpression(PythonBinder/*!*/ binder, Expression/*!*/ codeContext, DynamicMetaObject instance, DynamicMetaObject/*!*/ owner, ConditionalBuilder/*!*/ builder) { builder.FinishCondition(Ast.Constant(this)); } Merlin/Main/Languages/IronPython/IronPython/Runtime/Types/BuiltinFunction.cs @@ -51,13 +51,13 @@ namespace IronPython.Runtime.Types { return true; } - internal override void MakeGetExpression(PythonBinder/*!*/ binder, Expression/*!*/ codeContext, Expression instance, Expression/*!*/ owner, ConditionalBuilder/*!*/ builder) { + internal override void MakeGetExpression(PythonBinder/*!*/ binder, Expression/*!*/ codeContext, DynamicMetaObject instance, DynamicMetaObject/*!*/ owner, ConditionalBuilder/*!*/ builder) { if (instance != null) { builder.FinishCondition( Ast.Call( typeof(PythonOps).GetMethod("MakeBoundBuiltinFunction"), AstUtils.Constant(_template), - instance + instance.Expression ) ); } else { Merlin/Main/Languages/IronPython/IronPython/Runtime/Types/BuiltinMethodDescriptor.cs @@ -16,11 +16,16 @@ using System; using System.Collections.Generic; using System.Diagnostics; -using System.Linq.Expressions; +using System.Dynamic; using System.Reflection; -using IronPython.Runtime.Operations; + using Microsoft.Scripting; using Microsoft.Scripting.Actions; +using Microsoft.Scripting.Actions.Calls; + +using IronPython.Runtime.Binding; +using IronPython.Runtime.Operations; + using Ast = System.Linq.Expressions.Expression; using AstUtils = Microsoft.Scripting.Ast.Utils; @@ -28,52 +33,48 @@ namespace IronPython.Runtime.Types { public abstract class PythonCustomTracker : CustomTracker { public abstract PythonTypeSlot/*!*/ GetSlot(); - public override Expression GetValue(Expression context, ActionBinder binder, Type type) { - return AstUtils.Constant(GetSlot(), typeof(PythonTypeSlot)); + public override DynamicMetaObject GetValue(OverloadResolverFactory resolverFactory, ActionBinder binder, Type type) { + return new DynamicMetaObject(AstUtils.Constant(GetSlot(), typeof(PythonTypeSlot)), BindingRestrictions.Empty); } - public override MemberTracker BindToInstance(Expression instance) { + public override MemberTracker BindToInstance(DynamicMetaObject instance) { return new BoundMemberTracker(this, instance); } - public override Expression SetValue(Expression context, ActionBinder binder, Type type, Expression value) { - return SetBoundValue(context, binder, type, value, AstUtils.Constant(null)); + public override DynamicMetaObject SetValue(OverloadResolverFactory resolverFactory, ActionBinder binder, Type type, DynamicMetaObject value) { + return SetBoundValue(resolverFactory, binder, type, value, new DynamicMetaObject(AstUtils.Constant(null), BindingRestrictions.Empty)); } - protected override Expression GetBoundValue(Expression context, ActionBinder binder, Type type, Expression instance) { - return Ast.Call( - typeof(PythonOps).GetMethod("SlotGetValue"), - context, - AstUtils.Constant(GetSlot(), typeof(PythonTypeSlot)), - AstUtils.Convert( - instance, - typeof(object) + protected override DynamicMetaObject GetBoundValue(OverloadResolverFactory factory, ActionBinder binder, Type type, DynamicMetaObject instance) { + return new DynamicMetaObject( + Ast.Call( + typeof(PythonOps).GetMethod("SlotGetValue"), + ((PythonOverloadResolverFactory)factory)._codeContext, + AstUtils.Constant(GetSlot(), typeof(PythonTypeSlot)), + AstUtils.Convert( + instance.Expression, + typeof(object) + ), + AstUtils.Constant(DynamicHelpers.GetPythonTypeFromType(type)) ), - AstUtils.Constant(DynamicHelpers.GetPythonTypeFromType(type)) + BindingRestrictions.Empty ); } - protected override Expression SetBoundValue(Expression context, ActionBinder binder, Type type, Expression value, Expression instance) { - return Ast.Call( - typeof(PythonOps).GetMethod("SlotSetValue"), - context, - AstUtils.Constant(GetSlot(), typeof(PythonTypeSlot)), - AstUtils.Convert( - instance, - typeof(object) + protected override DynamicMetaObject SetBoundValue(OverloadResolverFactory factory, ActionBinder binder, Type type, DynamicMetaObject value, DynamicMetaObject instance) { + return new DynamicMetaObject( + Ast.Call( + typeof(PythonOps).GetMethod("SlotSetValue"), + ((PythonOverloadResolverFactory)factory)._codeContext, + AstUtils.Constant(GetSlot(), typeof(PythonTypeSlot)), + AstUtils.Convert( + instance.Expression, + typeof(object) + ), + AstUtils.Constant(DynamicHelpers.GetPythonTypeFromType(type)), + value.Expression ), - AstUtils.Constant(DynamicHelpers.GetPythonTypeFromType(type)), - value - ); - } - - public Expression GetBoundPythonValue(RuleBuilder builder, ActionBinder binder, PythonType accessing) { - return Ast.Call( - typeof(PythonOps).GetMethod("SlotGetValue"), - builder.Context, - AstUtils.Constant(GetSlot(), typeof(PythonTypeSlot)), - AstUtils.Constant(null), - AstUtils.Constant(accessing) + BindingRestrictions.Empty ); } } @@ -97,8 +98,8 @@ namespace IronPython.Runtime.Types { _slot = slot; } - public override Expression GetValue(Expression context, ActionBinder binder, Type type) { - return GetBoundValue(context, binder, type, AstUtils.Constant(null)); + public override DynamicMetaObject GetValue(OverloadResolverFactory factory, ActionBinder binder, Type type) { + return GetBoundValue(factory, binder, type, new DynamicMetaObject(AstUtils.Constant(null), BindingRestrictions.Empty)); } public override string Name { @@ -143,8 +144,8 @@ namespace IronPython.Runtime.Types { ); } - public override Expression GetValue(Expression context, ActionBinder binder, Type type) { - return GetBoundValue(context, binder, type, AstUtils.Constant(null)); + public override DynamicMetaObject GetValue(OverloadResolverFactory factory, ActionBinder binder, Type type) { + return GetBoundValue(factory, binder, type, new DynamicMetaObject(AstUtils.Constant(null), BindingRestrictions.Empty)); } public override Type DeclaringType { Merlin/Main/Languages/IronPython/IronPython/Runtime/Types/CustomAttributeTracker.cs @@ -55,7 +55,8 @@ namespace IronPython.Runtime.Types { #endif ICodeFormattable, IMembersList, - IDynamicMetaObjectProvider { + IDynamicMetaObjectProvider, + IPythonMembersList { [NonSerialized] private List<OldClass> _bases; @@ -77,7 +78,7 @@ namespace IronPython.Runtime.Types { if (!dict.ContainsKey(Symbols.Module)) { object moduleValue; - if (context.GlobalScope.TryGetName(Symbols.Name, out moduleValue)) { + if (context.GlobalScope.TryGetVariable(Symbols.Name, out moduleValue)) { dict[Symbols.Module] = moduleValue; } } @@ -410,7 +411,11 @@ namespace IronPython.Runtime.Types { #region IMembersList Members - IList<object> IMembersList.GetMemberNames(CodeContext context) { + IList<string> IMembersList.GetMemberNames() { + return PythonOps.GetStringMemberList(this); + } + + IList<object> IPythonMembersList.GetMemberNames(CodeContext/*!*/ context) { PythonDictionary attrs = new PythonDictionary(_dict); RecurseAttrHierarchy(this, attrs); return PythonOps.MakeListFromSequence(attrs); Merlin/Main/Languages/IronPython/IronPython/Runtime/Types/OldClass.cs @@ -40,8 +40,8 @@ namespace IronPython.Runtime.Types { #endif ISerializable, IWeakReferenceable, - IMembersList, - IDynamicMetaObjectProvider + IDynamicMetaObjectProvider, + IPythonMembersList { private PythonDictionary _dict; @@ -587,7 +587,11 @@ namespace IronPython.Runtime.Types { #region IMembersList Members - IList<object> IMembersList.GetMemberNames(CodeContext context) { + IList<string> IMembersList.GetMemberNames() { + return PythonOps.GetStringMemberList(this); + } + + IList<object> IPythonMembersList.GetMemberNames(CodeContext/*!*/ context) { PythonDictionary attrs = new PythonDictionary(_dict); OldClass.RecurseAttrHierarchy(this._class, attrs); return PythonOps.MakeListFromSequence(attrs); Merlin/Main/Languages/IronPython/IronPython/Runtime/Types/OldInstance.cs @@ -1,4 +1,4 @@ -/* **************************************************************************** +/* **************************************************************************** * * Copyright (c) Microsoft Corporation. * @@ -15,14 +15,19 @@ using System; using System.Collections.Generic; -using System.Text; +using System.Dynamic; +using System.Linq.Expressions; +using System.Reflection; using System.Runtime.CompilerServices; + +using Microsoft.Scripting.Actions; using Microsoft.Scripting.Runtime; +using Microsoft.Scripting.Utils; + using IronPython.Runtime.Binding; -using System.Reflection; using IronPython.Runtime.Operations; -using System.Linq.Expressions; -using Microsoft.Scripting.Actions; + +using AstUtils = Microsoft.Scripting.Ast.Utils; namespace IronPython.Runtime.Types { public partial class PythonType { @@ -36,11 +41,9 @@ namespace IronPython.Runtime.Types { /// of the same types and improved startup time due to reduced code generation. /// </summary> FastBindResult<T> IFastInvokable.MakeInvokeBinding<T>(CallSite<T> site, PythonInvokeBinder binder, CodeContext context, object[] args) { - PythonTypeSlot del; if (IsSystemType || // limited numbers of these, just generate optimal code IsMixedNewStyleOldStyle() || // old-style classes shouldn't be commonly used - TryResolveSlot(context, Symbols.Unassign, out del) || // same w/ finalizers. - args.Length > 5 || // and we only generate optimal code for a small number of calls. + args.Length > 5 || // and we only generate optimal code for a small number of calls. GetType() != typeof(PythonType)) { // and we don't handle meta classes yet (they could override __call__)... return new FastBindResult<T>(); } @@ -102,8 +105,7 @@ namespace IronPython.Runtime.Types { public FastBindingBuilderBase(CodeContext context, PythonType type, PythonInvokeBinder binder, Type siteType, Type[] genTypeArgs) { _context = context; _type = type; - // binder is used for nested call sites which have 1 extra argument (the type passed to __new__, or the instance passed to __init__). - _binder = binder.Context.Invoke(binder.Signature.InsertArgument(Argument.Simple)); + _binder = binder; _siteType = siteType; _genTypeArgs = genTypeArgs; } @@ -116,24 +118,16 @@ namespace IronPython.Runtime.Types { _type.TryResolveSlot(_context, Symbols.Init, out init); Delegate newDlg; - Delegate initDlg; - if (init == InstanceOps.Init) { - if (_genTypeArgs.Length > 0 & newInst == InstanceOps.New) { - // init needs to report an error, we don't optimize for the error case. + + if (newInst == InstanceOps.New) { + if (_genTypeArgs.Length > 0 && init == InstanceOps.Init) { + // new needs to report an error, we don't optimize for the error case. return null; } - initDlg = null; - } else if (init is PythonFunction) { - initDlg = GetNewOrInitSiteDelegate(_binder, init); - } else { - // odd slot in __init__, we don't handle this either. - return null; - } - - if (newInst == InstanceOps.New) { newDlg = GetOrCreateFastNew(); } else if (newInst.GetType() == typeof(staticmethod) && ((staticmethod)newInst)._func is PythonFunction) { - newDlg = GetNewOrInitSiteDelegate(_binder, ((staticmethod)newInst)._func); + // need an extra argument to pass the class to __new__ + newDlg = GetNewSiteDelegate(_binder.Context.Invoke(_binder.Signature.InsertArgument(Argument.Simple)), ((staticmethod)newInst)._func); } else { // odd slot in __new__, we don't handle this. newDlg = null; @@ -144,7 +138,7 @@ namespace IronPython.Runtime.Types { return null; } - return MakeDelegate(version, newDlg, initDlg); + return MakeDelegate(version, newDlg, _type.GetLateBoundInitBinder(_binder.Signature)); } /// <summary> @@ -191,8 +185,8 @@ namespace IronPython.Runtime.Types { return newDlg; } - protected abstract Delegate GetNewOrInitSiteDelegate(PythonInvokeBinder binder, object func); - protected abstract Delegate MakeDelegate(int version, Delegate newDlg, Delegate initDlg); + protected abstract Delegate GetNewSiteDelegate(PythonInvokeBinder binder, object func); + protected abstract Delegate MakeDelegate(int version, Delegate newDlg, LateBoundInitBinder initBinder); } class FastBindingBuilder : FastBindingBuilderBase { @@ -200,16 +194,17 @@ namespace IronPython.Runtime.Types { base(context, type, binder, siteType, genTypeArgs) { } - protected override Delegate GetNewOrInitSiteDelegate(PythonInvokeBinder binder, object func) { - return new Func<CodeContext, object, object>(new NewInitSite(binder, func).Call); + protected override Delegate GetNewSiteDelegate(PythonInvokeBinder binder, object func) { + return new Func<CodeContext, object, object>(new NewSite(binder, func).Call); } - protected override Delegate MakeDelegate(int version, Delegate newDlg, Delegate initDlg) { + protected override Delegate MakeDelegate(int version, Delegate newDlg, LateBoundInitBinder initBinder) { return new Func<CallSite, CodeContext, object, object>( new FastTypeSite( version, (Func<CodeContext, object, object>)newDlg, - (Func<CodeContext, object, object>)initDlg).CallTarget + initBinder + ).CallTarget ); } } @@ -217,21 +212,19 @@ namespace IronPython.Runtime.Types { class FastTypeSite { private readonly int _version; private readonly Func<CodeContext, object, object> _new; - private readonly Func<CodeContext, object, object> _init; + private readonly CallSite<Func<CallSite, CodeContext, object, object>> _initSite; - public FastTypeSite(int version, Func<CodeContext, object, object> @new, Func<CodeContext, object, object> init) { + public FastTypeSite(int version, Func<CodeContext, object, object> @new, LateBoundInitBinder initBinder) { _version = version; _new = @new; - _init = init; + _initSite = CallSite<Func<CallSite, CodeContext, object, object>>.Create(initBinder); } public object CallTarget(CallSite site, CodeContext context, object type) { PythonType pt = type as PythonType; if (pt != null && pt.Version == _version) { object res = _new(context, type); - if (_init != null && res != null && res.GetType() == pt.UnderlyingSystemType) { - _init(context, res); - } + _initSite.Target(_initSite, context, res); return res; } @@ -240,17 +233,17 @@ namespace IronPython.Runtime.Types { } } - class NewInitSite { + class NewSite { private readonly CallSite<Func<CallSite, CodeContext, object, object, object>> _site; private readonly object _target; - public NewInitSite(PythonInvokeBinder binder, object target) { + public NewSite(PythonInvokeBinder binder, object target) { _site = CallSite<Func<CallSite, CodeContext, object, object, object>>.Create(binder); _target = target; } - public object Call(CodeContext context, object typeOrInstance) { - return _site.Target(_site, context, _target, typeOrInstance); + public object Call(CodeContext context, object type) { + return _site.Target(_site, context, _target, type); } } @@ -267,16 +260,17 @@ namespace IronPython.Runtime.Types { base(context, type, binder, siteType, genTypeArgs) { } - protected override Delegate GetNewOrInitSiteDelegate(PythonInvokeBinder binder, object func) { - return new Func<CodeContext, object, T0, object>(new NewInitSite<T0>(binder, func).Call); + protected override Delegate GetNewSiteDelegate(PythonInvokeBinder binder, object func) { + return new Func<CodeContext, object, T0, object>(new NewSite<T0>(binder, func).Call); } - protected override Delegate MakeDelegate(int version, Delegate newDlg, Delegate initDlg) { + protected override Delegate MakeDelegate(int version, Delegate newDlg, LateBoundInitBinder initBinder) { return new Func<CallSite, CodeContext, object, T0, object>( - new FastTypeSite<T0> - (version, - (Func<CodeContext, object, T0, object>)newDlg, - (Func<CodeContext, object, T0, object>)initDlg).CallTarget + new FastTypeSite<T0>( + version, + (Func<CodeContext, object, T0, object>)newDlg, + initBinder + ).CallTarget ); } } @@ -284,21 +278,19 @@ namespace IronPython.Runtime.Types { class FastTypeSite<T0> { private readonly int _version; private readonly Func<CodeContext, object, T0, object> _new; - private readonly Func<CodeContext, object, T0, object> _init; + private readonly CallSite<Func<CallSite, CodeContext, object, T0, object>> _initSite; - public FastTypeSite(int version, Func<CodeContext, object, T0, object> @new, Func<CodeContext, object, T0, object> init) { + public FastTypeSite(int version, Func<CodeContext, object, T0, object> @new, LateBoundInitBinder initBinder) { _version = version; _new = @new; - _init = init; + _initSite = CallSite<Func<CallSite, CodeContext, object, T0, object>>.Create(initBinder); } public object CallTarget(CallSite site, CodeContext context, object type, T0 arg0) { PythonType pt = type as PythonType; if (pt != null && pt.Version == _version) { object res = _new(context, type, arg0); - if (_init != null && res != null && res.GetType() == pt.UnderlyingSystemType) { - _init(context, res, arg0); - } + _initSite.Target(_initSite, context, res, arg0); return res; } @@ -307,11 +299,11 @@ namespace IronPython.Runtime.Types { } } - class NewInitSite<T0> { + class NewSite<T0> { private readonly CallSite<Func<CallSite, CodeContext, object, object, T0, object>> _site; private readonly object _target; - public NewInitSite(PythonInvokeBinder binder, object target) { + public NewSite(PythonInvokeBinder binder, object target) { _site = CallSite<Func<CallSite, CodeContext, object, object, T0, object>>.Create(binder); _target = target; } @@ -327,16 +319,17 @@ namespace IronPython.Runtime.Types { base(context, type, binder, siteType, genTypeArgs) { } - protected override Delegate GetNewOrInitSiteDelegate(PythonInvokeBinder binder, object func) { - return new Func<CodeContext, object, T0, T1, object>(new NewInitSite<T0, T1>(binder, func).Call); + protected override Delegate GetNewSiteDelegate(PythonInvokeBinder binder, object func) { + return new Func<CodeContext, object, T0, T1, object>(new NewSite<T0, T1>(binder, func).Call); } - protected override Delegate MakeDelegate(int version, Delegate newDlg, Delegate initDlg) { + protected override Delegate MakeDelegate(int version, Delegate newDlg, LateBoundInitBinder initBinder) { return new Func<CallSite, CodeContext, object, T0, T1, object>( - new FastTypeSite<T0, T1> - (version, - (Func<CodeContext, object, T0, T1, object>)newDlg, - (Func<CodeContext, object, T0, T1, object>)initDlg).CallTarget + new FastTypeSite<T0, T1>( + version, + (Func<CodeContext, object, T0, T1, object>)newDlg, + initBinder + ).CallTarget ); } } @@ -344,21 +337,19 @@ namespace IronPython.Runtime.Types { class FastTypeSite<T0, T1> { private readonly int _version; private readonly Func<CodeContext, object, T0, T1, object> _new; - private readonly Func<CodeContext, object, T0, T1, object> _init; + private readonly CallSite<Func<CallSite, CodeContext, object, T0, T1, object>> _initSite; - public FastTypeSite(int version, Func<CodeContext, object, T0, T1, object> @new, Func<CodeContext, object, T0, T1, object> init) { + public FastTypeSite(int version, Func<CodeContext, object, T0, T1, object> @new, LateBoundInitBinder initBinder) { _version = version; _new = @new; - _init = init; + _initSite = CallSite<Func<CallSite, CodeContext, object, T0, T1, object>>.Create(initBinder); } public object CallTarget(CallSite site, CodeContext context, object type, T0 arg0, T1 arg1) { PythonType pt = type as PythonType; if (pt != null && pt.Version == _version) { object res = _new(context, type, arg0, arg1); - if (_init != null && res != null && res.GetType() == pt.UnderlyingSystemType) { - _init(context, res, arg0, arg1); - } + _initSite.Target(_initSite, context, res, arg0, arg1); return res; } @@ -367,11 +358,11 @@ namespace IronPython.Runtime.Types { } } - class NewInitSite<T0, T1> { + class NewSite<T0, T1> { private readonly CallSite<Func<CallSite, CodeContext, object, object, T0, T1, object>> _site; private readonly object _target; - public NewInitSite(PythonInvokeBinder binder, object target) { + public NewSite(PythonInvokeBinder binder, object target) { _site = CallSite<Func<CallSite, CodeContext, object, object, T0, T1, object>>.Create(binder); _target = target; } @@ -387,16 +378,17 @@ namespace IronPython.Runtime.Types { base(context, type, binder, siteType, genTypeArgs) { } - protected override Delegate GetNewOrInitSiteDelegate(PythonInvokeBinder binder, object func) { - return new Func<CodeContext, object, T0, T1, T2, object>(new NewInitSite<T0, T1, T2>(binder, func).Call); + protected override Delegate GetNewSiteDelegate(PythonInvokeBinder binder, object func) { + return new Func<CodeContext, object, T0, T1, T2, object>(new NewSite<T0, T1, T2>(binder, func).Call); } - protected override Delegate MakeDelegate(int version, Delegate newDlg, Delegate initDlg) { + protected override Delegate MakeDelegate(int version, Delegate newDlg, LateBoundInitBinder initBinder) { return new Func<CallSite, CodeContext, object, T0, T1, T2, object>( - new FastTypeSite<T0, T1, T2> - (version, - (Func<CodeContext, object, T0, T1, T2, object>)newDlg, - (Func<CodeContext, object, T0, T1, T2, object>)initDlg).CallTarget + new FastTypeSite<T0, T1, T2>( + version, + (Func<CodeContext, object, T0, T1, T2, object>)newDlg, + initBinder + ).CallTarget ); } } @@ -404,21 +396,19 @@ namespace IronPython.Runtime.Types { class FastTypeSite<T0, T1, T2> { private readonly int _version; private readonly Func<CodeContext, object, T0, T1, T2, object> _new; - private readonly Func<CodeContext, object, T0, T1, T2, object> _init; + private readonly CallSite<Func<CallSite, CodeContext, object, T0, T1, T2, object>> _initSite; - public FastTypeSite(int version, Func<CodeContext, object, T0, T1, T2, object> @new, Func<CodeContext, object, T0, T1, T2, object> init) { + public FastTypeSite(int version, Func<CodeContext, object, T0, T1, T2, object> @new, LateBoundInitBinder initBinder) { _version = version; _new = @new; - _init = init; + _initSite = CallSite<Func<CallSite, CodeContext, object, T0, T1, T2, object>>.Create(initBinder); } public object CallTarget(CallSite site, CodeContext context, object type, T0 arg0, T1 arg1, T2 arg2) { PythonType pt = type as PythonType; if (pt != null && pt.Version == _version) { object res = _new(context, type, arg0, arg1, arg2); - if (_init != null && res != null && res.GetType() == pt.UnderlyingSystemType) { - _init(context, res, arg0, arg1, arg2); - } + _initSite.Target(_initSite, context, res, arg0, arg1, arg2); return res; } @@ -427,11 +417,11 @@ namespace IronPython.Runtime.Types { } } - class NewInitSite<T0, T1, T2> { + class NewSite<T0, T1, T2> { private readonly CallSite<Func<CallSite, CodeContext, object, object, T0, T1, T2, object>> _site; private readonly object _target; - public NewInitSite(PythonInvokeBinder binder, object target) { + public NewSite(PythonInvokeBinder binder, object target) { _site = CallSite<Func<CallSite, CodeContext, object, object, T0, T1, T2, object>>.Create(binder); _target = target; } @@ -447,16 +437,17 @@ namespace IronPython.Runtime.Types { base(context, type, binder, siteType, genTypeArgs) { } - protected override Delegate GetNewOrInitSiteDelegate(PythonInvokeBinder binder, object func) { - return new Func<CodeContext, object, T0, T1, T2, T3, object>(new NewInitSite<T0, T1, T2, T3>(binder, func).Call); + protected override Delegate GetNewSiteDelegate(PythonInvokeBinder binder, object func) { + return new Func<CodeContext, object, T0, T1, T2, T3, object>(new NewSite<T0, T1, T2, T3>(binder, func).Call); } - protected override Delegate MakeDelegate(int version, Delegate newDlg, Delegate initDlg) { + protected override Delegate MakeDelegate(int version, Delegate newDlg, LateBoundInitBinder initBinder) { return new Func<CallSite, CodeContext, object, T0, T1, T2, T3, object>( - new FastTypeSite<T0, T1, T2, T3> - (version, - (Func<CodeContext, object, T0, T1, T2, T3, object>)newDlg, - (Func<CodeContext, object, T0, T1, T2, T3, object>)initDlg).CallTarget + new FastTypeSite<T0, T1, T2, T3>( + version, + (Func<CodeContext, object, T0, T1, T2, T3, object>)newDlg, + initBinder + ).CallTarget ); } } @@ -464,21 +455,19 @@ namespace IronPython.Runtime.Types { class FastTypeSite<T0, T1, T2, T3> { private readonly int _version; private readonly Func<CodeContext, object, T0, T1, T2, T3, object> _new; - private readonly Func<CodeContext, object, T0, T1, T2, T3, object> _init; + private readonly CallSite<Func<CallSite, CodeContext, object, T0, T1, T2, T3, object>> _initSite; - public FastTypeSite(int version, Func<CodeContext, object, T0, T1, T2, T3, object> @new, Func<CodeContext, object, T0, T1, T2, T3, object> init) { + public FastTypeSite(int version, Func<CodeContext, object, T0, T1, T2, T3, object> @new, LateBoundInitBinder initBinder) { _version = version; _new = @new; - _init = init; + _initSite = CallSite<Func<CallSite, CodeContext, object, T0, T1, T2, T3, object>>.Create(initBinder); } public object CallTarget(CallSite site, CodeContext context, object type, T0 arg0, T1 arg1, T2 arg2, T3 arg3) { PythonType pt = type as PythonType; if (pt != null && pt.Version == _version) { object res = _new(context, type, arg0, arg1, arg2, arg3); - if (_init != null && res != null && res.GetType() == pt.UnderlyingSystemType) { - _init(context, res, arg0, arg1, arg2, arg3); - } + _initSite.Target(_initSite, context, res, arg0, arg1, arg2, arg3); return res; } @@ -487,11 +476,11 @@ namespace IronPython.Runtime.Types { } } - class NewInitSite<T0, T1, T2, T3> { + class NewSite<T0, T1, T2, T3> { private readonly CallSite<Func<CallSite, CodeContext, object, object, T0, T1, T2, T3, object>> _site; private readonly object _target; - public NewInitSite(PythonInvokeBinder binder, object target) { + public NewSite(PythonInvokeBinder binder, object target) { _site = CallSite<Func<CallSite, CodeContext, object, object, T0, T1, T2, T3, object>>.Create(binder); _target = target; } @@ -507,16 +496,17 @@ namespace IronPython.Runtime.Types { base(context, type, binder, siteType, genTypeArgs) { } - protected override Delegate GetNewOrInitSiteDelegate(PythonInvokeBinder binder, object func) { - return new Func<CodeContext, object, T0, T1, T2, T3, T4, object>(new NewInitSite<T0, T1, T2, T3, T4>(binder, func).Call); + protected override Delegate GetNewSiteDelegate(PythonInvokeBinder binder, object func) { + return new Func<CodeContext, object, T0, T1, T2, T3, T4, object>(new NewSite<T0, T1, T2, T3, T4>(binder, func).Call); } - protected override Delegate MakeDelegate(int version, Delegate newDlg, Delegate initDlg) { + protected override Delegate MakeDelegate(int version, Delegate newDlg, LateBoundInitBinder initBinder) { return new Func<CallSite, CodeContext, object, T0, T1, T2, T3, T4, object>( - new FastTypeSite<T0, T1, T2, T3, T4> - (version, - (Func<CodeContext, object, T0, T1, T2, T3, T4, object>)newDlg, - (Func<CodeContext, object, T0, T1, T2, T3, T4, object>)initDlg).CallTarget + new FastTypeSite<T0, T1, T2, T3, T4>( + version, + (Func<CodeContext, object, T0, T1, T2, T3, T4, object>)newDlg, + initBinder + ).CallTarget ); } } @@ -524,21 +514,19 @@ namespace IronPython.Runtime.Types { class FastTypeSite<T0, T1, T2, T3, T4> { private readonly int _version; private readonly Func<CodeContext, object, T0, T1, T2, T3, T4, object> _new; - private readonly Func<CodeContext, object, T0, T1, T2, T3, T4, object> _init; + private readonly CallSite<Func<CallSite, CodeContext, object, T0, T1, T2, T3, T4, object>> _initSite; - public FastTypeSite(int version, Func<CodeContext, object, T0, T1, T2, T3, T4, object> @new, Func<CodeContext, object, T0, T1, T2, T3, T4, object> init) { + public FastTypeSite(int version, Func<CodeContext, object, T0, T1, T2, T3, T4, object> @new, LateBoundInitBinder initBinder) { _version = version; _new = @new; - _init = init; + _initSite = CallSite<Func<CallSite, CodeContext, object, T0, T1, T2, T3, T4, object>>.Create(initBinder); } public object CallTarget(CallSite site, CodeContext context, object type, T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { PythonType pt = type as PythonType; if (pt != null && pt.Version == _version) { object res = _new(context, type, arg0, arg1, arg2, arg3, arg4); - if (_init != null && res != null && res.GetType() == pt.UnderlyingSystemType) { - _init(context, res, arg0, arg1, arg2, arg3, arg4); - } + _initSite.Target(_initSite, context, res, arg0, arg1, arg2, arg3, arg4); return res; } @@ -547,11 +535,11 @@ namespace IronPython.Runtime.Types { } } - class NewInitSite<T0, T1, T2, T3, T4> { + class NewSite<T0, T1, T2, T3, T4> { private readonly CallSite<Func<CallSite, CodeContext, object, object, T0, T1, T2, T3, T4, object>> _site; private readonly object _target; - public NewInitSite(PythonInvokeBinder binder, object target) { + public NewSite(PythonInvokeBinder binder, object target) { _site = CallSite<Func<CallSite, CodeContext, object, object, T0, T1, T2, T3, T4, object>>.Create(binder); _target = target; } @@ -565,6 +553,456 @@ namespace IronPython.Runtime.Types { // *** END GENERATED CODE *** #endregion + } + + /// <summary> + /// Used when a type overrides __new__ with a Python function or other object + /// that can return an arbitrary value. If the return value is not the same type + /// as the type which had __new__ then we need to lookup __init__ on the type + /// and invoke it. Also handles initialization for finalization when __del__ + /// is defined for the same reasons. + /// </summary> + class LateBoundInitBinder : DynamicMetaObjectBinder { + private readonly PythonType _newType; // the type __new__ was invoked on + private readonly CallSignature _signature; // the call signature for the call + + public LateBoundInitBinder(PythonType type, CallSignature signature) { + _newType = type; + _signature = signature; + } + + /// <summary> + /// target is the newly initialized value. + /// args are the arguments to be passed to __init__ + /// </summary> + public override DynamicMetaObject Bind(DynamicMetaObject target, DynamicMetaObject[] args) { + DynamicMetaObject codeContext = target; + CodeContext context = (CodeContext)codeContext.Value; + target = args[0]; + args = ArrayUtils.RemoveFirst(args); + + ValidationInfo valInfo = BindingHelpers.GetValidationInfo(target); + + Expression res; + PythonType instType = DynamicHelpers.GetPythonType(target.Value); + BindingRestrictions initRestrictions = BindingRestrictions.Empty; + + if (IronPython.Modules.Builtin.isinstance(target.Value, _newType) && + NeedsInitCall((CodeContext)codeContext.Value, instType, args.Length)) { + + // resolve __init__ + PythonTypeSlot init; + instType.TryResolveSlot(context, Symbols.Init, out init); + + if (instType.IsMixedNewStyleOldStyle()) { + // mixed new-style/old-style class, we need to look up __init__ every time + res = MakeDynamicInitInvoke( + context, + args, + Expression.Call( + typeof(PythonOps).GetMethod("GetMixedMember"), + codeContext.Expression, + Expression.Convert(AstUtils.WeakConstant(instType), typeof(PythonType)), + AstUtils.Convert(target.Expression, typeof(object)), + AstUtils.Constant(Symbols.Init) + ), + codeContext.Expression + ); + } else if (init is PythonFunction) { + // avoid creating the bound method, just invoke it directly + Expression[] allArgs = new Expression[args.Length + 3]; + allArgs[0] = codeContext.Expression; + allArgs[1] = AstUtils.WeakConstant(init); + allArgs[2] = target.Expression; + for (int i = 0; i < args.Length; i++) { + allArgs[3 + i] = args[i].Expression; + } + + res = Expression.Dynamic( + context.LanguageContext.Invoke(_signature.InsertArgument(Argument.Simple)), + typeof(object), + allArgs + ); + } else if(init is BuiltinMethodDescriptor || init is BuiltinFunction) { + IList<MethodBase> targets; + if (init is BuiltinMethodDescriptor) { + targets = ((BuiltinMethodDescriptor)init).Template.Targets; + } else { + targets = ((BuiltinFunction)init).Targets; + } + + PythonBinder binder = context.LanguageContext.Binder; + + DynamicMetaObject initInvoke = binder.CallMethod( + new PythonOverloadResolver( + binder, + target, + args, + _signature, + codeContext.Expression + ), + targets, + BindingRestrictions.Empty + ); + + res = initInvoke.Expression; + initRestrictions = initInvoke.Restrictions; + } else { + // some weird descriptor has been put in place for __init__, we need + // to call __get__ on it each time. + res = MakeDynamicInitInvoke( + context, + args, + Expression.Call( + typeof(PythonOps).GetMethod("GetInitSlotMember"), + codeContext.Expression, + Expression.Convert(AstUtils.WeakConstant(_newType), typeof(PythonType)), + Expression.Convert(AstUtils.WeakConstant(init), typeof(PythonTypeSlot)), + AstUtils.Convert(target.Expression, typeof(object)) + ), + codeContext.Expression + ); + } + } else { + // returned something that isn't a subclass of the creating type + // __init__ will not be run. + res = AstUtils.Empty(); + } + + // check for __del__ + PythonTypeSlot delSlot; + if (instType.TryResolveSlot(context, Symbols.Unassign, out delSlot)) { + res = Expression.Block( + res, + Expression.Call( + typeof(PythonOps).GetMethod("InitializeForFinalization"), + codeContext.Expression, + AstUtils.Convert(target.Expression, typeof(object)) + ) + ); + } + + return BindingHelpers.AddDynamicTestAndDefer( + this, + new DynamicMetaObject( + Expression.Block( + res, + target.Expression + ), + target.Restrict(target.LimitType).Restrictions.Merge(initRestrictions) + ), + args, + valInfo + ); + } + + #region Generated Python Fast Init Max Args + + // *** BEGIN GENERATED CODE *** + // generated by function: gen_fast_init_max_args from: generate_calls.py + + public const int MaxFastLateBoundInitArgs = 6; + + // *** END GENERATED CODE *** + + #endregion + + public override T BindDelegate<T>(CallSite<T> site, object[] args) { + if (args.Length <= MaxFastLateBoundInitArgs) { + CodeContext context = (CodeContext)args[0]; + object inst = args[1]; + PythonType instType = DynamicHelpers.GetPythonType(inst); + + PythonTypeSlot delSlot; + PythonFunction initFunc = null; + string callTarget = null; + if (!instType.TryResolveSlot(context, Symbols.Unassign, out delSlot) // we don't have fast code for classes w/ finalizers + && !instType.IsMixedNewStyleOldStyle()) { // we also don't have fast code for mixed new-style/old-style classes + + if (IronPython.Modules.Builtin.isinstance(inst, _newType) && + NeedsInitCall((CodeContext)context, instType, args.Length)) { + + PythonTypeSlot init; + instType.TryResolveSlot(context, Symbols.Init, out init); + + if (init is PythonFunction) { + // we can do a fast bind + callTarget = "CallTarget"; + initFunc = (PythonFunction)init; + } + } else { + // we need no initialization, we can do a fast bind + callTarget = "EmptyCallTarget"; + } + } + + if (callTarget != null) { + int genArgCount = args.Length - 2; + PythonInvokeBinder binder = context.LanguageContext.Invoke(_signature.InsertArgument(Argument.Simple)); + if (genArgCount == 0) { + FastInitSite fastSite = new FastInitSite(instType.Version, binder, initFunc); + if (callTarget == "CallTarget") { + return (T)(object)new Func<CallSite, CodeContext, object, object>(fastSite.CallTarget); + } else { + return (T)(object)new Func<CallSite, CodeContext, object, object>(fastSite.EmptyCallTarget); + } + + } else { + Type[] genArgs = ArrayUtils.ConvertAll(typeof(T).GetMethod("Invoke").GetParameters(), x => x.ParameterType); + Type initSiteType; + + switch (args.Length - 2) { + #region Generated Python Fast Init Switch + + // *** BEGIN GENERATED CODE *** + // generated by function: gen_fast_init_switch from: generate_calls.py + + case 1: initSiteType = typeof(FastInitSite<>); break; + case 2: initSiteType = typeof(FastInitSite<,>); break; + case 3: initSiteType = typeof(FastInitSite<,,>); break; + case 4: initSiteType = typeof(FastInitSite<,,,>); break; + case 5: initSiteType = typeof(FastInitSite<,,,,>); break; + + // *** END GENERATED CODE *** + + #endregion + + default: throw new InvalidOperationException(); + } + + Type genType = initSiteType.MakeGenericType(ArrayUtils.ShiftLeft(genArgs, 3)); + object initSiteInst = Activator.CreateInstance(genType, instType.Version, binder, initFunc); + return (T)(object)Delegate.CreateDelegate(typeof(T), initSiteInst, genType.GetMethod(callTarget)); + } + } + } + + return base.BindDelegate(site, args); + } + + class FastInitSite { + private readonly int _version; + private readonly PythonFunction _slot; + private readonly CallSite<Func<CallSite, CodeContext, PythonFunction, object, object>> _initSite; + + public FastInitSite(int version, PythonInvokeBinder binder, PythonFunction target) { + _version = version; + _slot = target; + _initSite = CallSite<Func<CallSite, CodeContext, PythonFunction, object, object>>.Create(binder); + } + + public object CallTarget(CallSite site, CodeContext context, object inst) { + IPythonObject pyObj = inst as IPythonObject; + if (pyObj != null && pyObj.PythonType.Version == _version) { + _initSite.Target(_initSite, context, _slot, inst); + return inst; + } + + return ((CallSite<Func<CallSite, CodeContext, object, object>>)site).Update(site, context, inst); + } + + public object EmptyCallTarget(CallSite site, CodeContext context, object inst) { + IPythonObject pyObj = inst as IPythonObject; + if ((pyObj != null && pyObj.PythonType.Version == _version) || DynamicHelpers.GetPythonType(inst).Version == _version) { + return inst; + } + + return ((CallSite<Func<CallSite, CodeContext, object, object>>)site).Update(site, context, inst); + } + } + + #region Generated Python Fast Init Callers + + // *** BEGIN GENERATED CODE *** + // generated by function: gen_fast_init_callers from: generate_calls.py + + + class FastInitSite<T0> { + private readonly int _version; + private readonly PythonFunction _slot; + private readonly CallSite<Func<CallSite, CodeContext, PythonFunction, object, T0, object>> _initSite; + + public FastInitSite(int version, PythonInvokeBinder binder, PythonFunction target) { + _version = version; + _slot = target; + _initSite = CallSite<Func<CallSite, CodeContext, PythonFunction, object, T0, object>>.Create(binder); + } + + public object CallTarget(CallSite site, CodeContext context, object inst, T0 arg0) { + IPythonObject pyObj = inst as IPythonObject; + if (pyObj != null && pyObj.PythonType.Version == _version) { + _initSite.Target(_initSite, context, _slot, inst, arg0); + return inst; + } + + return ((CallSite<Func<CallSite, CodeContext, object, T0, object>>)site).Update(site, context, inst, arg0); + } + + public object EmptyCallTarget(CallSite site, CodeContext context, object inst, T0 arg0) { + IPythonObject pyObj = inst as IPythonObject; + if ((pyObj != null && pyObj.PythonType.Version == _version) || DynamicHelpers.GetPythonType(inst).Version == _version) { + return inst; + } + + return ((CallSite<Func<CallSite, CodeContext, object, T0, object>>)site).Update(site, context, inst, arg0); + } + } + + + class FastInitSite<T0, T1> { + private readonly int _version; + private readonly PythonFunction _slot; + private readonly CallSite<Func<CallSite, CodeContext, PythonFunction, object, T0, T1, object>> _initSite; + + public FastInitSite(int version, PythonInvokeBinder binder, PythonFunction target) { + _version = version; + _slot = target; + _initSite = CallSite<Func<CallSite, CodeContext, PythonFunction, object, T0, T1, object>>.Create(binder); + } + + public object CallTarget(CallSite site, CodeContext context, object inst, T0 arg0, T1 arg1) { + IPythonObject pyObj = inst as IPythonObject; + if (pyObj != null && pyObj.PythonType.Version == _version) { + _initSite.Target(_initSite, context, _slot, inst, arg0, arg1); + return inst; + } + + return ((CallSite<Func<CallSite, CodeContext, object, T0, T1, object>>)site).Update(site, context, inst, arg0, arg1); + } + + public object EmptyCallTarget(CallSite site, CodeContext context, object inst, T0 arg0, T1 arg1) { + IPythonObject pyObj = inst as IPythonObject; + if ((pyObj != null && pyObj.PythonType.Version == _version) || DynamicHelpers.GetPythonType(inst).Version == _version) { + return inst; + } + + return ((CallSite<Func<CallSite, CodeContext, object, T0, T1, object>>)site).Update(site, context, inst, arg0, arg1); + } + } + + + class FastInitSite<T0, T1, T2> { + private readonly int _version; + private readonly PythonFunction _slot; + private readonly CallSite<Func<CallSite, CodeContext, PythonFunction, object, T0, T1, T2, object>> _initSite; + + public FastInitSite(int version, PythonInvokeBinder binder, PythonFunction target) { + _version = version; + _slot = target; + _initSite = CallSite<Func<CallSite, CodeContext, PythonFunction, object, T0, T1, T2, object>>.Create(binder); + } + + public object CallTarget(CallSite site, CodeContext context, object inst, T0 arg0, T1 arg1, T2 arg2) { + IPythonObject pyObj = inst as IPythonObject; + if (pyObj != null && pyObj.PythonType.Version == _version) { + _initSite.Target(_initSite, context, _slot, inst, arg0, arg1, arg2); + return inst; + } + + return ((CallSite<Func<CallSite, CodeContext, object, T0, T1, T2, object>>)site).Update(site, context, inst, arg0, arg1, arg2); + } + + public object EmptyCallTarget(CallSite site, CodeContext context, object inst, T0 arg0, T1 arg1, T2 arg2) { + IPythonObject pyObj = inst as IPythonObject; + if ((pyObj != null && pyObj.PythonType.Version == _version) || DynamicHelpers.GetPythonType(inst).Version == _version) { + return inst; + } + + return ((CallSite<Func<CallSite, CodeContext, object, T0, T1, T2, object>>)site).Update(site, context, inst, arg0, arg1, arg2); + } + } + + + class FastInitSite<T0, T1, T2, T3> { + private readonly int _version; + private readonly PythonFunction _slot; + private readonly CallSite<Func<CallSite, CodeContext, PythonFunction, object, T0, T1, T2, T3, object>> _initSite; + + public FastInitSite(int version, PythonInvokeBinder binder, PythonFunction target) { + _version = version; + _slot = target; + _initSite = CallSite<Func<CallSite, CodeContext, PythonFunction, object, T0, T1, T2, T3, object>>.Create(binder); + } + + public object CallTarget(CallSite site, CodeContext context, object inst, T0 arg0, T1 arg1, T2 arg2, T3 arg3) { + IPythonObject pyObj = inst as IPythonObject; + if (pyObj != null && pyObj.PythonType.Version == _version) { + _initSite.Target(_initSite, context, _slot, inst, arg0, arg1, arg2, arg3); + return inst; + } + + return ((CallSite<Func<CallSite, CodeContext, object, T0, T1, T2, T3, object>>)site).Update(site, context, inst, arg0, arg1, arg2, arg3); + } + + public object EmptyCallTarget(CallSite site, CodeContext context, object inst, T0 arg0, T1 arg1, T2 arg2, T3 arg3) { + IPythonObject pyObj = inst as IPythonObject; + if ((pyObj != null && pyObj.PythonType.Version == _version) || DynamicHelpers.GetPythonType(inst).Version == _version) { + return inst; + } + + return ((CallSite<Func<CallSite, CodeContext, object, T0, T1, T2, T3, object>>)site).Update(site, context, inst, arg0, arg1, arg2, arg3); + } + } + + + class FastInitSite<T0, T1, T2, T3, T4> { + private readonly int _version; + private readonly PythonFunction _slot; + private readonly CallSite<Func<CallSite, CodeContext, PythonFunction, object, T0, T1, T2, T3, T4, object>> _initSite; + + public FastInitSite(int version, PythonInvokeBinder binder, PythonFunction target) { + _version = version; + _slot = target; + _initSite = CallSite<Func<CallSite, CodeContext, PythonFunction, object, T0, T1, T2, T3, T4, object>>.Create(binder); + } + + public object CallTarget(CallSite site, CodeContext context, object inst, T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { + IPythonObject pyObj = inst as IPythonObject; + if (pyObj != null && pyObj.PythonType.Version == _version) { + _initSite.Target(_initSite, context, _slot, inst, arg0, arg1, arg2, arg3, arg4); + return inst; + } + + return ((CallSite<Func<CallSite, CodeContext, object, T0, T1, T2, T3, T4, object>>)site).Update(site, context, inst, arg0, arg1, arg2, arg3, arg4); + } + + public object EmptyCallTarget(CallSite site, CodeContext context, object inst, T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { + IPythonObject pyObj = inst as IPythonObject; + if ((pyObj != null && pyObj.PythonType.Version == _version) || DynamicHelpers.GetPythonType(inst).Version == _version) { + return inst; + } + + return ((CallSite<Func<CallSite, CodeContext, object, T0, T1, T2, T3, T4, object>>)site).Update(site, context, inst, arg0, arg1, arg2, arg3, arg4); + } + } + + + // *** END GENERATED CODE *** + + #endregion + + + private bool NeedsInitCall(CodeContext context, PythonType type, int argCount) { + if (!type.HasObjectInit(context) || type.IsMixedNewStyleOldStyle()) { + return true; + } else if (_newType.HasObjectNew(context)) { + return argCount > 0; + } + + return false; + } + + private DynamicExpression MakeDynamicInitInvoke(CodeContext context, DynamicMetaObject[] args, Expression initFunc, Expression codeContext) { + return Expression.Dynamic( + context.LanguageContext.Invoke(_signature), + typeof(object), + ArrayUtils.Insert( + codeContext, + initFunc, + DynamicUtils.GetExpressions(args) + ) + ); + } } } Merlin/Main/Languages/IronPython/IronPython/Runtime/Types/PythonType.Generated.cs @@ -45,7 +45,7 @@ namespace IronPython.Runtime.Types { [PythonType("type")] [Documentation(@"type(object) -> gets the type of the object type(name, bases, dict) -> creates a new type instance with the given name, base classes, and members from the dictionary")] - public partial class PythonType : IMembersList, IDynamicMetaObjectProvider, IWeakReferenceable, ICodeFormattable, IFastGettable, IFastSettable, IFastInvokable { + public partial class PythonType : IPythonMembersList, IDynamicMetaObjectProvider, IWeakReferenceable, ICodeFormattable, IFastGettable, IFastSettable, IFastInvokable { private Type/*!*/ _underlyingSystemType; // the underlying CLI system type for this type private string _name; // the name of the type private Dictionary<SymbolId, PythonTypeSlot> _dict; // type-level slots & attributes @@ -75,6 +75,7 @@ type(name, bases, dict) -> creates a new type instance with the given name, base private CallSite<Func<CallSite, object, int>> _hashSite; private CallSite<Func<CallSite, object, object, bool>> _eqSite; private CallSite<Func<CallSite, object, object, int>> _compareSite; + private Dictionary<CallSignature, LateBoundInitBinder> _lateBoundInitBinders; private PythonSiteCache _siteCache = new PythonSiteCache(); @@ -1014,7 +1015,25 @@ type(name, bases, dict) -> creates a new type instance with the given name, base return !TryResolveSlot(DefaultContext.Default, SymbolTable.StringToId(name), out dummySlot) && TryResolveSlot(DefaultContext.DefaultCLS, SymbolTable.StringToId(name), out dummySlot); } + + internal LateBoundInitBinder GetLateBoundInitBinder(CallSignature signature) { + Debug.Assert(!IsSystemType); // going to hold onto a PythonContext, shouldn't ever be a system type + Debug.Assert(_pythonContext != null); + + if (_lateBoundInitBinders == null) { + Interlocked.CompareExchange(ref _lateBoundInitBinders, new Dictionary<CallSignature, LateBoundInitBinder>(), null); + } + lock(_lateBoundInitBinders) { + LateBoundInitBinder res; + if (!_lateBoundInitBinders.TryGetValue(signature, out res)) { + _lateBoundInitBinders[signature] = res = new LateBoundInitBinder(this, signature); + } + + return res; + } + } + #endregion #region Type member access @@ -1893,7 +1912,7 @@ type(name, bases, dict) -> creates a new type instance with the given name, base } object modName; - if (context.Scope.TryLookupName(Symbols.Name, out modName)) { + if (context.Scope.TryGetVariable(Symbols.Name, out modName)) { PopulateSlot(Symbols.Module, modName); } @@ -1974,7 +1993,7 @@ type(name, bases, dict) -> creates a new type instance with the given name, base private static void EnsureModule(CodeContext context, IAttributesCollection dict) { if (!dict.ContainsKey(Symbols.Module)) { object modName; - if (context.Scope.TryLookupName(Symbols.Name, out modName)) { + if (context.Scope.TryGetVariable(Symbols.Name, out modName)) { dict[Symbols.Module] = modName; } } @@ -2260,7 +2279,11 @@ type(name, bases, dict) -> creates a new type instance with the given name, base #region IMembersList Members - IList<object> IMembersList.GetMemberNames(CodeContext context) { + IList<string> IMembersList.GetMemberNames() { + return PythonOps.GetStringMemberList(this); + } + + IList<object> IPythonMembersList.GetMemberNames(CodeContext/*!*/ context) { IList<object> res = GetMemberNames(context); object[] arr = new object[res.Count]; @@ -2900,5 +2923,7 @@ type(name, bases, dict) -> creates a new type instance with the given name, base return type == _self; } - } + } + + } Merlin/Main/Languages/IronPython/IronPython/Runtime/Types/PythonType.cs @@ -13,12 +13,10 @@ * * ***************************************************************************/ -using System; +using System.Dynamic; using System.Linq.Expressions; using System.Runtime.InteropServices; -using Microsoft.Scripting.Runtime; - using IronPython.Runtime.Binding; using IronPython.Runtime.Operations; @@ -80,14 +78,14 @@ namespace IronPython.Runtime.Types { /// The default implementation just calls the TryGetValue method. Subtypes of PythonTypeSlot can override /// this and provide a more optimal implementation. /// </summary> - internal virtual void MakeGetExpression(PythonBinder/*!*/ binder, Expression/*!*/ codeContext, Expression instance, Expression/*!*/ owner, ConditionalBuilder/*!*/ builder) { + internal virtual void MakeGetExpression(PythonBinder/*!*/ binder, Expression/*!*/ codeContext, DynamicMetaObject instance, DynamicMetaObject/*!*/ owner, ConditionalBuilder/*!*/ builder) { ParameterExpression tmp = Ast.Variable(typeof(object), "slotTmp"); Expression call = Ast.Call( typeof(PythonOps).GetMethod("SlotTryGetValue"), codeContext, AstUtils.Convert(AstUtils.WeakConstant(this), typeof(PythonTypeSlot)), - instance ?? AstUtils.Constant(null), - owner, + instance != null ? instance.Expression : AstUtils.Constant(null), + owner.Expression, tmp ); Merlin/Main/Languages/IronPython/IronPython/Runtime/Types/PythonTypeSlot.cs @@ -162,7 +162,7 @@ namespace IronPython.Runtime.Types { } } - internal override void MakeGetExpression(PythonBinder/*!*/ binder, Expression/*!*/ codeContext, Expression instance, Expression/*!*/ owner, ConditionalBuilder/*!*/ builder) { + internal override void MakeGetExpression(PythonBinder/*!*/ binder, Expression/*!*/ codeContext, DynamicMetaObject instance, DynamicMetaObject/*!*/ owner, ConditionalBuilder/*!*/ builder) { if (!_info.IsPublic || _info.DeclaringType.ContainsGenericParameters) { // fallback to reflection base.MakeGetExpression(binder, codeContext, instance, owner, builder); @@ -177,10 +177,10 @@ namespace IronPython.Runtime.Types { AstUtils.Convert( Ast.Field( binder.ConvertExpression( - instance, + instance.Expression, _info.DeclaringType, ConversionResultKind.ExplicitCast, - codeContext + new PythonOverloadResolverFactory(binder, codeContext) ), _info ), Merlin/Main/Languages/IronPython/IronPython/Runtime/Types/ReflectedField.cs @@ -15,6 +15,7 @@ using System; using System.Diagnostics; +using System.Dynamic; using System.Linq.Expressions; using System.Reflection; using System.Runtime.CompilerServices; @@ -22,7 +23,6 @@ using System.Runtime.CompilerServices; using Microsoft.Scripting; using Microsoft.Scripting.Actions; using Microsoft.Scripting.Generation; -using Microsoft.Scripting.Runtime; using Microsoft.Scripting.Utils; using IronPython.Runtime.Binding; @@ -160,7 +160,7 @@ namespace IronPython.Runtime.Types { return true; } - internal override void MakeGetExpression(PythonBinder/*!*/ binder, Expression/*!*/ codeContext, Expression instance, Expression/*!*/ owner, ConditionalBuilder/*!*/ builder) { + internal override void MakeGetExpression(PythonBinder/*!*/ binder, Expression/*!*/ codeContext, DynamicMetaObject instance, DynamicMetaObject/*!*/ owner, ConditionalBuilder/*!*/ builder) { if (Getter.Length != 0 && !Getter[0].IsPublic) { // fallback to runtime call base.MakeGetExpression(binder, codeContext, instance, owner, builder); @@ -173,16 +173,16 @@ namespace IronPython.Runtime.Types { MemberTracker.FromMemberInfo(_info) ), typeof(object) - ) + ).Expression ); } else if (instance != null) { builder.FinishCondition( AstUtils.Convert( binder.MakeCallExpression( - codeContext, + new PythonOverloadResolverFactory(binder, codeContext), Getter[0], instance - ), + ).Expression, typeof(object) ) ); @@ -190,9 +190,9 @@ namespace IronPython.Runtime.Types { builder.FinishCondition( AstUtils.Convert( binder.MakeCallExpression( - codeContext, + new PythonOverloadResolverFactory(binder, codeContext), Getter[0] - ), + ).Expression, typeof(object) ) ); Merlin/Main/Languages/IronPython/IronPython/Runtime/Types/ReflectedProperty.cs @@ -18,7 +18,7 @@ using System.Collections.Generic; using System.Diagnostics; using System.Runtime.CompilerServices; using System.Text; -using Microsoft.Scripting.Runtime; +using IronPython.Runtime; namespace IronPythonTest { Merlin/Main/Languages/IronPython/IronPythonTest/InheritTest.cs @@ -21,7 +21,7 @@ <SignAssembly Condition="'$(SignAssembly)' == '' And Exists('$(AssemblyOriginatorKeyFile)')">true</SignAssembly> <SignedSym Condition="'$(SignAssembly)' == 'true'">SIGNED</SignedSym> <DelaySign>true</DelaySign> - <SilverlightPath Condition="$(SilverlightPath) == ''">..\..\..\Utilities\Silverlight\x86ret\</SilverlightPath> + <SilverlightPath Condition="'$(SilverlightPath)' == ''">..\..\..\Utilities\Silverlight\x86ret\</SilverlightPath> </PropertyGroup> <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> <DebugSymbols>true</DebugSymbols> Merlin/Main/Languages/IronPython/IronPythonTest/IronPythonTest.csproj @@ -655,10 +655,6 @@ internal class LibraryDef { var type = parameterInfos[i].ParameterType; - if (type == typeof(CodeContext)) { - LogMethodError("CodeContext is obsolete use RubyContext instead.", methodDef, overload); - } - if (type.IsSubclassOf(typeof(RubyCallSiteStorage))) { if (hasSelf || hasContext || hasBlock) { LogMethodError("RubyCallSiteStorage must precede all other parameters", methodDef, overload); Merlin/Main/Languages/Ruby/ClassInitGenerator/Libraries/LibraryDef.cs @@ -14,6 +14,7 @@ * ***************************************************************************/ using System; +using Microsoft.Scripting; using Microsoft.Scripting.Hosting; using Microsoft.Scripting.Hosting.Shell; using IronRuby; @@ -39,9 +40,23 @@ internal sealed class RubyConsoleHost : ConsoleHost { return Ruby.CreateRubySetup(); } + private static void SetHome() { + try { + PlatformAdaptationLayer platform = PlatformAdaptationLayer.Default; + string homeDir = RubyUtils.GetHomeDirectory(platform); + platform.SetEnvironmentVariable("HOME", homeDir); + } catch (System.Security.SecurityException e) { + // Ignore EnvironmentPermission exception + if (e.PermissionType != typeof(System.Security.Permissions.EnvironmentPermission)) { + throw; + } + } + } + [STAThread] [RubyStackTraceHidden] static int Main(string[] args) { + SetHome(); return new RubyConsoleHost().Run(args); } } \ No newline at end of file Merlin/Main/Languages/Ruby/Console/Program.cs @@ -46,8 +46,8 @@ namespace IronRuby.Tests { Scenario_ParseRegex1, Scenario_RubyCategorizer1, - Scenario_RubyNameMangling1, - Scenario_RubyNameMangling2, + NameMangling1, + NameMangling2, OverloadResolution_Block1, OverloadResolution_ParamArrays1, @@ -354,6 +354,7 @@ namespace IronRuby.Tests { Require1, RequireInterop1, + RequireInterop2, Load1, LibraryLoader1, @@ -620,6 +621,7 @@ namespace IronRuby.Tests { Dlr_Comparable, Dlr_RubyObjects, Dlr_Methods, + Dlr_Visibility, Dlr_Languages, }; } Merlin/Main/Languages/Ruby/IronRuby.Tests/RubyTests.cs @@ -787,6 +787,50 @@ end //assert_equal Methods.with_block {|x| x + 1000}, 1100 } + public void Dlr_Visibility() { + Engine.Execute(@" +class D < Hash +end + +class C + def public_m + 0 + end + + private + def private_m + 1 + end + + protected + def protected_m + 2 + end +end +"); + var classC = Runtime.Globals.GetVariable("C"); + var c = Engine.Operations.CreateInstance(classC); + + AssertExceptionThrown<MissingMethodException>(() => MyInvokeMemberBinder.Invoke(c, "private_m")); + AssertExceptionThrown<MissingMethodException>(() => MyInvokeMemberBinder.Invoke(c, "protected_m")); + var r1 = MyInvokeMemberBinder.Invoke(c, "public_m"); + Assert(r1 is int && (int)r1 == 0); + + Engine.Execute(@" +class C + def method_missing name + 3 + end +end"); + var r2 = MyInvokeMemberBinder.Invoke(c, "private_m"); + Assert(r2 is int && (int)r2 == 3); + + // private initialize method can be called if called via new: + var classD = Runtime.Globals.GetVariable("D"); + var d = Engine.Operations.CreateInstance(classD); + Assert(d is Hash); + } + public void Dlr_Languages() { //# Pass in ref/out params //# Named arguments Merlin/Main/Languages/Ruby/IronRuby.Tests/Runtime/DlrInteropTests.cs @@ -140,6 +140,42 @@ Hello from Python } } + public void RequireInterop2() { + if (_driver.PartialTrust || !_driver.RunPython) return; + + try { + string temp = _driver.MakeTempDir(); + Context.Loader.SetLoadPaths(new[] { temp }); + + File.WriteAllText(Path.Combine(temp, "a.py"), @" +def WhoIsThis(): + print 'Python' + +Foo = 1 + +class Bar(object): + def baz(self): + print Foo +"); + + TestOutput(@" +a = IronRuby.require('a') +scopes = IronRuby.loaded_scripts.collect { |z| z.value } +a.who_is_this.call +a.foo += 1 +a.bar.new.baz +puts scopes[0].Foo +", @" +Python +2 +2 +"); + + } finally { + File.Delete("b.py"); + } + } + public class TestLibraryInitializer1 : LibraryInitializer { protected override void LoadModules() { Context.ObjectClass.SetConstant("TEST_LIBRARY", "hello from library"); Merlin/Main/Languages/Ruby/IronRuby.Tests/Runtime/LoaderTests.cs @@ -17,34 +17,124 @@ using IronRuby.Runtime; namespace IronRuby.Tests { public partial class Tests { - public void Scenario_RubyNameMangling1() { - Assert(RubyUtils.TryUnmangleName("ip_stack") == "IpStack"); // TODO + public void NameMangling1() { Assert(RubyUtils.TryUnmangleName("stack") == "Stack"); Assert(RubyUtils.TryUnmangleName("this_is_my_long_name") == "ThisIsMyLongName"); - Assert(RubyUtils.TryUnmangleName("") == null); Assert(RubyUtils.TryUnmangleName("f") == "F"); - Assert(RubyUtils.TryUnmangleName("fo") == "Fo"); - Assert(RubyUtils.TryUnmangleName("foo") == "Foo"); - Assert(RubyUtils.TryUnmangleName("foo_bar") == "FooBar"); - Assert(RubyUtils.TryUnmangleName("ma_m") == "MaM"); - Assert(RubyUtils.TryUnmangleName("initialize") == "initialize"); - Assert(RubyUtils.TryUnmangleName("Initialize") == "Initialize"); + Assert(RubyUtils.TryUnmangleName("initialize") == "Initialize"); + + // non-alpha characters are treated as lower-case letters: + Assert(RubyUtils.TryUnmangleName("foo_bar=") == "FooBar="); + Assert(RubyUtils.TryUnmangleName("foo?") == "Foo?"); + Assert(RubyUtils.TryUnmangleName("???") == "???"); + Assert(RubyUtils.TryUnmangleName("1_2_3") == "123"); + + // special cases: + Assert(RubyUtils.TryUnmangleName("on") == "On"); + Assert(RubyUtils.TryUnmangleName("up") == "Up"); + Assert(RubyUtils.TryUnmangleName("in") == "In"); + Assert(RubyUtils.TryUnmangleName("to") == "To"); + Assert(RubyUtils.TryUnmangleName("of") == "Of"); + Assert(RubyUtils.TryUnmangleName("it") == "It"); + Assert(RubyUtils.TryUnmangleName("is") == "Is"); + Assert(RubyUtils.TryUnmangleName("if") == "If"); + Assert(RubyUtils.TryUnmangleName("go") == "Go"); + Assert(RubyUtils.TryUnmangleName("do") == "Do"); + Assert(RubyUtils.TryUnmangleName("by") == "By"); + Assert(RubyUtils.TryUnmangleName("at") == "At"); + Assert(RubyUtils.TryUnmangleName("as") == "As"); + Assert(RubyUtils.TryUnmangleName("my") == "My"); + + Assert(RubyUtils.TryUnmangleName("ip") == "IP"); + Assert(RubyUtils.TryUnmangleName("rx") == "RX"); + Assert(RubyUtils.TryUnmangleName("pi") == "PI"); + + Assert(RubyUtils.TryUnmangleName("na_n") == null); + Assert(RubyUtils.TryUnmangleName("nan") == "Nan"); + Assert(RubyUtils.TryUnmangleName("ip_address") == "IPAddress"); + Assert(RubyUtils.TryUnmangleName("i_id_id") == "IIdId"); + Assert(RubyUtils.TryUnmangleName("i_ip_ip") == null); + Assert(RubyUtils.TryUnmangleName("ip_foo_ip") == "IPFooIP"); + Assert(RubyUtils.TryUnmangleName("active_x") == "ActiveX"); + + Assert(RubyUtils.TryUnmangleName("get_u_int16") == "GetUInt16"); + Assert(RubyUtils.TryUnmangleName("get_ui_parent_core") == "GetUIParentCore"); + + // TODO: ??? + Assert(RubyUtils.TryUnmangleName("i_pv6") == "IPv6"); + + // names that cannot be mangled: + Assert(RubyUtils.TryUnmangleName("") == null); + Assert(RubyUtils.TryUnmangleName("IPX") == null); + Assert(RubyUtils.TryUnmangleName("FO") == null); + Assert(RubyUtils.TryUnmangleName("FOOBar") == null); + Assert(RubyUtils.TryUnmangleName("FooBAR") == null); + Assert(RubyUtils.TryUnmangleName("foo__bar") == null); + Assert(RubyUtils.TryUnmangleName("_foo") == null); + Assert(RubyUtils.TryUnmangleName("foo_") == null); } - public void Scenario_RubyNameMangling2() { - Assert(RubyUtils.MangleName("IPStack") == "ip_stack"); // TODO - Assert(RubyUtils.MangleName("Stack") == "stack"); - Assert(RubyUtils.MangleName("ThisIsMyLongName") == "this_is_my_long_name"); - Assert(RubyUtils.MangleName("") == ""); - Assert(RubyUtils.MangleName("F") == "f"); - Assert(RubyUtils.MangleName("FO") == "fo"); - Assert(RubyUtils.MangleName("FOO") == "foo"); - Assert(RubyUtils.MangleName("FOOBar") == "foo_bar"); - Assert(RubyUtils.MangleName("MaM") == "ma_m"); - Assert(RubyUtils.MangleName("foo") == "foo"); - Assert(RubyUtils.MangleName("foo_bar=") == "foo_bar="); - Assert(RubyUtils.MangleName("initialize") == "initialize"); - Assert(RubyUtils.MangleName("Initialize") == "Initialize"); + public void NameMangling2() { + Assert(RubyUtils.TryMangleName("Stack") == "stack"); + Assert(RubyUtils.TryMangleName("ThisIsMyLongName") == "this_is_my_long_name"); + Assert(RubyUtils.TryMangleName("F") == "f"); + Assert(RubyUtils.TryMangleName("Initialize") == "initialize"); + Assert(RubyUtils.TryMangleName("fooBar") == "foo_bar"); + + // characters that are not upper case letters are treated as lower-case: + Assert(RubyUtils.TryMangleName("Foo123bar") == "foo123bar"); + Assert(RubyUtils.TryMangleName("123Bar") == "123_bar"); + Assert(RubyUtils.TryMangleName("?Bar") == "?_bar"); + Assert(RubyUtils.TryMangleName("B__") == "b__"); + + // special cases: + Assert(RubyUtils.TryUnmangleName("ON") == null); + Assert(RubyUtils.TryUnmangleName("UP") == null); + Assert(RubyUtils.TryUnmangleName("IN") == null); + Assert(RubyUtils.TryUnmangleName("TO") == null); + Assert(RubyUtils.TryUnmangleName("OF") == null); + Assert(RubyUtils.TryUnmangleName("IT") == null); + Assert(RubyUtils.TryUnmangleName("IF") == null); + Assert(RubyUtils.TryUnmangleName("IS") == null); + Assert(RubyUtils.TryUnmangleName("GO") == null); + Assert(RubyUtils.TryUnmangleName("DO") == null); + Assert(RubyUtils.TryUnmangleName("BY") == null); + Assert(RubyUtils.TryUnmangleName("AT") == null); + Assert(RubyUtils.TryUnmangleName("AS") == null); + Assert(RubyUtils.TryUnmangleName("MY") == null); + Assert(RubyUtils.TryUnmangleName("ID") == null); + Assert(RubyUtils.TryUnmangleName("OK") == null); + + Assert(RubyUtils.TryMangleName("NaN") == null); + Assert(RubyUtils.TryMangleName("NaNValue") == null); + Assert(RubyUtils.TryMangleName("At") == "at"); + Assert(RubyUtils.TryMangleName("IP") == "ip"); + Assert(RubyUtils.TryMangleName("FO") == "fo"); + Assert(RubyUtils.TryMangleName("PI") == "pi"); + Assert(RubyUtils.TryMangleName("IPAddress") == "ip_address"); + Assert(RubyUtils.TryMangleName("MyDB") == "my_db"); + Assert(RubyUtils.TryMangleName("PyPy") == "py_py"); + Assert(RubyUtils.TryMangleName("IPFooIP") == "ip_foo_ip"); + Assert(RubyUtils.TryMangleName("ActiveX") == "active_x"); + + Assert(RubyUtils.TryMangleName("GetUInt16") == "get_u_int16"); + Assert(RubyUtils.TryMangleName("GetUIParentCore") == "get_ui_parent_core"); + + // TODO: ??? + Assert(RubyUtils.TryMangleName("IPv6") == "i_pv6"); + + // names that cannot be mangled: + Assert(RubyUtils.TryMangleName("") == null); + Assert(RubyUtils.TryMangleName("IPX") == null); + Assert(RubyUtils.TryMangleName("FOO") == null); + Assert(RubyUtils.TryMangleName("FOOBar") == null); + Assert(RubyUtils.TryMangleName("FooBAR") == null); + Assert(RubyUtils.TryMangleName("foo") == null); + Assert(RubyUtils.TryMangleName("initialize") == null); + Assert(RubyUtils.TryMangleName("foo_bar=") == null); + Assert(RubyUtils.TryMangleName("foo__bar") == null); + Assert(RubyUtils.TryMangleName("_foo") == null); + Assert(RubyUtils.TryMangleName("foo_") == null); } } } Merlin/Main/Languages/Ruby/IronRuby.Tests/Runtime/RubyUtilsTests.cs @@ -227,10 +227,21 @@ namespace IronRuby.Builtins { } count = Int32.Parse(format.Substring(pos1, (i - pos1))); i--; + } else if (c == '@' && c2 == '-') { + int pos1 = i; + i += 2; + while (i < format.Length && Char.IsDigit(format[i])) { + i++; + } + count = Int32.Parse(format.Substring(pos1, (i - pos1))); + i--; } else if (c2 == '*') { count = null; } else { i--; + if (c == '@') { + count = 0; + } } yield return new FormatDirective(c, count); Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/ArrayOps.cs @@ -100,7 +100,7 @@ namespace IronRuby.Builtins { [RubyMethod("chdir", RubyMethodAttributes.PublicSingleton)] public static object ChangeDirectory(RubyContext/*!*/ context, object self) { #if !SILVERLIGHT - string defaultDirectory = RubyFileOps.GetHomeDirectory(context); + string defaultDirectory = RubyUtils.GetHomeDirectory(context.DomainManager.Platform); if (defaultDirectory == null) throw RubyExceptions.CreateArgumentError("HOME / USERPROFILE not set"); Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/Dir.cs @@ -441,26 +441,21 @@ namespace IronRuby.Builtins { #region zip - [RubyMethod("zip")] - public static RubyArray/*!*/ Zip(CallSiteStorage<EachSite>/*!*/ each, ConversionStorage<IList>/*!*/ tryToA, BlockParam block, - object self, [NotNull]params object[] args) { - RubyArray results = (block == null) ? new RubyArray() : null; + internal static RubyArray/*!*/ Zip(CallSiteStorage<EachSite>/*!*/ each, ConversionStorage<IList>/*!*/ tryToA, BlockParam block, + object self, params IList[]/*!*/ args) { - // Call to_a on each argument - IList[] otherArrays = new IList[args.Length]; - for (int i = 0; i < args.Length; i++) { - otherArrays[i] = Protocols.TryConvertToArray(tryToA, args[i]); - } + RubyArray results = (block == null) ? new RubyArray() : null; int index = 0; Each(each, self, Proc.Create(each.Context, delegate(BlockParam/*!*/ selfBlock, object _, object item) { // Collect items - RubyArray array = new RubyArray(otherArrays.Length + 1); + RubyArray array = new RubyArray(args.Length + 1); array.Add(item); - foreach (IList otherArray in otherArrays) { + foreach (IList otherArray in args) { if (index < otherArray.Count) { array.Add(otherArray[index]); - } else { + } + else { array.Add(null); } } @@ -472,7 +467,8 @@ namespace IronRuby.Builtins { if (block.Yield(array, out blockResult)) { return blockResult; } - } else { + } + else { results.Add(array); } return null; @@ -481,6 +477,19 @@ namespace IronRuby.Builtins { return results; } + [RubyMethod("zip")] + public static RubyArray/*!*/ Zip(CallSiteStorage<EachSite>/*!*/ each, ConversionStorage<IList>/*!*/ tryToA, BlockParam block, + object self, [NotNull]params object[] args) { + + // Call to_a on each argument + IList[] otherArrays = new IList[args.Length]; + for (int i = 0; i < args.Length; i++) { + otherArrays[i] = args[i] as IList != null ? args[i] as IList : Protocols.TryConvertToArray(tryToA, args[i]); + } + + return Zip(each, tryToA, block, self, otherArrays); + } + #endregion #region TODO: count, none?, one?, first (1.9) Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/Enumerable.cs @@ -483,146 +483,7 @@ namespace IronRuby.Builtins { #endregion - #region expand_path - #if !SILVERLIGHT - // Algorithm to find HOME equivalents under Windows. This is equivalent to Ruby 1.9 behavior: - // - // 1. Try get HOME - // 2. Try to generate HOME equivalent using HOMEDRIVE + HOMEPATH - // 3. Try to generate HOME equivalent from USERPROFILE - // 4. Try to generate HOME equivalent from Personal special folder - - internal static string/*!*/ GetHomeDirectory(RubyContext/*!*/ context) { - PlatformAdaptationLayer pal = context.DomainManager.Platform; - string result = pal.GetEnvironmentVariable("HOME"); - - if (result == null) { - string homeDrive = pal.GetEnvironmentVariable("HOMEDRIVE"); - string homePath = pal.GetEnvironmentVariable("HOMEPATH"); - if (homeDrive == null && homePath == null) { - string userEnvironment = pal.GetEnvironmentVariable("USERPROFILE"); - if (userEnvironment == null) { - // This will always succeed with a non-null string, but it can fail - // if the Personal folder was renamed or deleted. In this case it returns - // an empty string. - result = Environment.GetFolderPath(Environment.SpecialFolder.Personal); - } else { - result = userEnvironment; - } - } else if (homeDrive == null) { - result = homePath; - } else if (homePath == null) { - result = homeDrive; - } else { - result = Path.Combine(homeDrive, homePath); - } - } - return result; - } - - class PathExpander { - List<string> _pathComponents = new List<string>(); // does not include the root - string _root; // Typically "c:/" on Windows, and "/" on Unix - - internal PathExpander(RubyContext/*!*/ context, string absoluteBasePath) { - Debug.Assert(RubyUtils.IsAbsolutePath(absoluteBasePath)); - - string basePathAfterRoot = null; - _root = RubyUtils.GetPathRoot(context, absoluteBasePath, out basePathAfterRoot); - - // Normally, basePathAfterRoot[0] will not be '/', but here we deal with cases like "c:////foo" - basePathAfterRoot = basePathAfterRoot.TrimStart('/'); - - AddRelativePath(basePathAfterRoot); - } - - internal void AddRelativePath(string relPath) { - Debug.Assert(!RubyUtils.IsAbsolutePath(relPath)); - - string[] relPathComponents = relPath.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries); - - foreach (string pathComponent in relPathComponents) { - if (pathComponent == "..") { - if (_pathComponents.Count == 0) { - // MRI allows more pops than the base path components - continue; - } - _pathComponents.RemoveAt(_pathComponents.Count - 1); - } else if (pathComponent == ".") { - continue; - } else { - _pathComponents.Add(pathComponent); - } - } - } - - internal MutableString/*!*/ GetResult() { - StringBuilder result = new StringBuilder(_root); - - if (_pathComponents.Count >= 1) { - // Here we make this work: - // File.expand_path("c:/..a..") -> "c:/..a" - string lastComponent = _pathComponents[_pathComponents.Count - 1]; - if (RubyUtils.FileSystemUsesDriveLetters && !String.IsNullOrEmpty(lastComponent.TrimEnd('.'))) { - _pathComponents[_pathComponents.Count - 1] = lastComponent.TrimEnd('.'); - } - } - - for(int i = 0; i < _pathComponents.Count; i++) { - result.Append(_pathComponents[i]); - if (i < (_pathComponents.Count - 1)) { - result.Append('/'); - } - } -#if DEBUG - _pathComponents = null; - _root = null; -#endif - return MutableString.CreateMutable(result.ToString()); - } - } - - // Expand directory path - these cases exist: - // - // 1. Empty string or nil means return current directory - // 2. ~ with non-existent HOME directory throws exception - // 3. ~, ~/ or ~\ which expands to HOME - // 4. ~foo is left unexpanded - // 5. Expand to full path if path is a relative path - // - // No attempt is made to determine whether the path is valid or not - // Returned path is always canonicalized to forward slashes - - private static MutableString/*!*/ ExpandPath(RubyContext/*!*/ context, RubyClass/*!*/ self, MutableString/*!*/ path) { - if (MutableString.IsNullOrEmpty(path)) { - return MutableString.Create(RubyUtils.CanonicalizePath(context.DomainManager.Platform.CurrentDirectory)); - } - - int length = path.Length; - - if (path.GetChar(0) == '~') { - if (length == 1 || (path.GetChar(1) == '/')) { - - string homeDirectory = context.DomainManager.Platform.GetEnvironmentVariable("HOME"); - if (homeDirectory == null) { - throw RubyExceptions.CreateArgumentError("couldn't find HOME environment -- expanding `~'"); - } - - if (length <= 2) { - path = MutableString.Create(homeDirectory); - } else { - path = MutableString.Create(Path.Combine(homeDirectory, path.GetSlice(2).ConvertToString())); - } - return RubyUtils.CanonicalizePath(path); - } else { - return path; - } - } else { - MutableString currentDirectory = ExpandPath(context, self, null); - return ExpandPath(context, self, path, currentDirectory); - } - } [RubyMethod("expand_path", RubyMethodAttributes.PublicSingleton, BuildConfig = "!SILVERLIGHT")] public static MutableString/*!*/ ExpandPath( @@ -631,53 +492,14 @@ namespace IronRuby.Builtins { [DefaultProtocol, NotNull]MutableString/*!*/ path, [DefaultProtocol, Optional]MutableString basePath) { - // We ignore basePath parameter if first string starts with a ~ - if (basePath == null || path.GetFirstChar() == '~') { - return ExpandPath(context, self, path); - } - - string pathStr = RubyUtils.CanonicalizePath(path).ConvertToString(); - string basePathStr = RubyUtils.CanonicalizePath(basePath).ConvertToString(); - char partialDriveLetter; - string relativePath; - - if (RubyUtils.IsAbsolutePath(pathStr)) { - // "basePath" can be ignored is "path" is an absolute path - PathExpander pathExpander = new PathExpander(context, pathStr); - return pathExpander.GetResult(); - } else if (RubyUtils.HasPartialDriveLetter(pathStr, out partialDriveLetter, out relativePath)) { - string currentDirectory = partialDriveLetter.ToString() + ":/"; - if (DirectoryExists(context, currentDirectory)) { - // File.expand_path("c:foo") returns "c:/current_folder_for_c_drive/foo" - currentDirectory = Path.GetFullPath(partialDriveLetter.ToString() + ":"); - } - - return ExpandPath( - context, - self, - MutableString.CreateMutable(relativePath), - MutableString.CreateMutable(currentDirectory)); - } else if (RubyUtils.IsAbsolutePath(basePathStr)) { - PathExpander pathExpander = new PathExpander(context, basePathStr); - pathExpander.AddRelativePath(pathStr); - return pathExpander.GetResult(); - } else if (RubyUtils.HasPartialDriveLetter(basePathStr, out partialDriveLetter, out relativePath)) { - // First expand basePath - MutableString expandedBasePath = ExpandPath(context, self, basePath); - - return ExpandPath(context, self, path, expandedBasePath); - } else { - // First expand basePath - MutableString expandedBasePath = ExpandPath(context, self, basePath); - Debug.Assert(RubyUtils.IsAbsolutePath(expandedBasePath.ConvertToString())); - - return ExpandPath(context, self, path, expandedBasePath); - } + string result = RubyUtils.ExpandPath( + context.DomainManager.Platform, + path.ConvertToString(), + basePath == null ? null : basePath.ConvertToString()); + return MutableString.Create(result); } #endif - #endregion - //lchmod //lchown //link @@ -710,12 +532,14 @@ namespace IronRuby.Builtins { if (!FileExists(context, strOldPath) && !DirectoryExists(context, strOldPath)) { throw RubyErrno.CreateENOENT(String.Format("No such file or directory - {0}", oldPath)); } + + string strNewPath = newPath.ConvertToString(); #if !SILVERLIGHT - if (ExpandPath(context, self, oldPath) == ExpandPath(context, self, newPath)) { + PlatformAdaptationLayer platform = context.DomainManager.Platform; + if (RubyUtils.ExpandPath(platform, strOldPath) == RubyUtils.ExpandPath(platform, strNewPath)) { return 0; } #endif - string strNewPath = newPath.ConvertToString(); if (FileExists(context, strNewPath)) { Delete(self, newPath); } Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/FileOps.cs @@ -134,14 +134,19 @@ namespace IronRuby.Builtins { #if !SILVERLIGHT // Looks for RUBYSHELL and then COMSPEC under Windows - // It appears that COMSPEC is a special environment variable that cannot be undefined internal static ProcessStartInfo/*!*/ GetShell(RubyContext/*!*/ context, MutableString/*!*/ command) { PlatformAdaptationLayer pal = context.DomainManager.Platform; string shell = pal.GetEnvironmentVariable("RUBYSHELL"); if (shell == null) { shell = pal.GetEnvironmentVariable("COMSPEC"); } - return new ProcessStartInfo(shell, String.Format("/C \"{0}\"", command.ConvertToString())); + + if (shell == null) { + string [] commandParts = command.ConvertToString().Split(new char[] { ' ' }, 2); + return new ProcessStartInfo(commandParts[0], commandParts.Length == 2 ? commandParts[1] : null); + } else { + return new ProcessStartInfo(shell, String.Format("/C \"{0}\"", command.ConvertToString())); + } } private static MutableString/*!*/ JoinArguments(MutableString/*!*/[]/*!*/ args) { @@ -398,12 +403,11 @@ namespace IronRuby.Builtins { return block.Proc.ToLambda(); } - #region load, require + #region load, load_assembly, require [RubyMethod("load", RubyMethodAttributes.PrivateInstance)] [RubyMethod("load", RubyMethodAttributes.PublicSingleton)] - public static bool Load(RubyScope/*!*/ scope, object self, - [DefaultProtocol, NotNull]MutableString/*!*/ libraryName, [Optional]bool wrap) { + public static bool Load(RubyScope/*!*/ scope, object self, [DefaultProtocol, NotNull]MutableString/*!*/ libraryName, [Optional]bool wrap) { return scope.RubyContext.Loader.LoadFile(scope.GlobalScope.Scope, self, libraryName, wrap ? LoadFlags.LoadIsolated : LoadFlags.None); } @@ -413,13 +417,12 @@ namespace IronRuby.Builtins { [DefaultProtocol, NotNull]MutableString/*!*/ assemblyName, [DefaultProtocol, Optional, NotNull]MutableString libraryNamespace) { string initializer = libraryNamespace != null ? LibraryInitializer.GetFullTypeName(libraryNamespace.ConvertToString()) : null; - return context.Loader.LoadAssembly(assemblyName.ConvertToString(), initializer, true, true); + return context.Loader.LoadAssembly(assemblyName.ConvertToString(), initializer, true, true) != null; } [RubyMethod("require", RubyMethodAttributes.PrivateInstance)] [RubyMethod("require", RubyMethodAttributes.PublicSingleton)] - public static bool Require(RubyScope/*!*/ scope, object self, - [DefaultProtocol, NotNull]MutableString/*!*/ libraryName) { + public static bool Require(RubyScope/*!*/ scope, object self, [DefaultProtocol, NotNull]MutableString/*!*/ libraryName) { return scope.RubyContext.Loader.LoadFile(scope.GlobalScope.Scope, self, libraryName, LoadFlags.LoadOnce | LoadFlags.AppendExtensions); } @@ -1537,7 +1540,7 @@ namespace IronRuby.Builtins { // thread-safe: [RubyMethod("method")] public static RubyMethod/*!*/ GetMethod(RubyContext/*!*/ context, object self, [DefaultProtocol, NotNull]string/*!*/ name) { - RubyMemberInfo info = context.ResolveMethod(self, name, RubyClass.IgnoreVisibility).Info; + RubyMemberInfo info = context.ResolveMethod(self, name, VisibilityContext.AllVisible).Info; if (info == null) { throw RubyExceptions.CreateUndefinedMethodError(context.GetClassOf(self), name); } Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/KernelOps.cs @@ -25,6 +25,7 @@ using Microsoft.Scripting.Math; using Microsoft.Scripting.Runtime; using Microsoft.Scripting.Utils; using Microsoft.Scripting.Generation; +using IronRuby.Runtime.Calls; namespace IronRuby.Builtins { @@ -384,8 +385,8 @@ namespace IronRuby.Builtins { // TODO: replace with a table-driven implementation // TODO: visibility? - bool implementsDump = _context.ResolveMethod(obj, "_dump", RubyClass.IgnoreVisibility).Found; - bool implementsMarshalDump = _context.ResolveMethod(obj, "marshal_dump", RubyClass.IgnoreVisibility).Found; + bool implementsDump = _context.ResolveMethod(obj, "_dump", VisibilityContext.AllVisible).Found; + bool implementsMarshalDump = _context.ResolveMethod(obj, "marshal_dump", VisibilityContext.AllVisible).Found; bool writeInstanceData = false; string[] instanceNames = null; Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/Marshal.cs @@ -266,7 +266,7 @@ namespace IronRuby.Builtins { options |= MethodLookup.ReturnForwarder; } - method = module.ResolveMethodNoLock(methodName, RubyClass.IgnoreVisibility, options).Info; + method = module.ResolveMethodNoLock(methodName, VisibilityContext.AllVisible, options).Info; if (method == null) { throw RubyExceptions.CreateNameError(RubyExceptions.FormatMethodMissingMessage(context, module, methodName)); } @@ -310,7 +310,9 @@ namespace IronRuby.Builtins { public static RubyMethod/*!*/ DefineMethod(RubyScope/*!*/ scope, RubyModule/*!*/ self, [NotNull]ClrName/*!*/ methodName, [NotNull]RubyMethod/*!*/ method) { var result = DefineMethod(scope, self, methodName.MangledName, method); - self.AddMethodAlias(methodName.ActualName, methodName.MangledName); + if (methodName.HasMangledName) { + self.AddMethodAlias(methodName.ActualName, methodName.MangledName); + } return result; } @@ -329,7 +331,9 @@ namespace IronRuby.Builtins { public static UnboundMethod/*!*/ DefineMethod(RubyScope/*!*/ scope, RubyModule/*!*/ self, [NotNull]ClrName/*!*/ methodName, [NotNull]UnboundMethod/*!*/ method) { var result = DefineMethod(scope, self, methodName.MangledName, method); - self.AddMethodAlias(methodName.ActualName, methodName.MangledName); + if (methodName.HasMangledName) { + self.AddMethodAlias(methodName.ActualName, methodName.MangledName); + } return result; } @@ -366,7 +370,9 @@ namespace IronRuby.Builtins { RubyModule/*!*/ self, [NotNull]ClrName/*!*/ methodName) { var result = DefineMethod(scope, block, self, methodName.MangledName); - self.AddMethodAlias(methodName.ActualName, methodName.MangledName); + if (methodName.HasMangledName) { + self.AddMethodAlias(methodName.ActualName, methodName.MangledName); + } return result; } @@ -386,7 +392,9 @@ namespace IronRuby.Builtins { [NotNull]ClrName/*!*/ methodName, [NotNull]Proc/*!*/ method) { var result = DefineMethod(scope, self, methodName.MangledName, method); - self.AddMethodAlias(methodName.ActualName, methodName.MangledName); + if (methodName.HasMangledName) { + self.AddMethodAlias(methodName.ActualName, methodName.MangledName); + } return result; } @@ -528,7 +536,7 @@ namespace IronRuby.Builtins { // thread-safe: [RubyMethod("undef_method", RubyMethodAttributes.PrivateInstance)] public static RubyModule/*!*/ UndefineMethod(RubyModule/*!*/ self, [DefaultProtocol, NotNull]string/*!*/ methodName) { - if (!self.ResolveMethod(methodName, RubyClass.IgnoreVisibility).Found) { + if (!self.ResolveMethod(methodName, VisibilityContext.AllVisible).Found) { throw RubyExceptions.CreateUndefinedMethodError(self, methodName); } self.UndefineMethod(methodName); @@ -882,28 +890,28 @@ namespace IronRuby.Builtins { // thread-safe: [RubyMethod("method_defined?")] public static bool MethodDefined(RubyModule/*!*/ self, [DefaultProtocol, NotNull]string/*!*/ methodName) { - RubyMemberInfo method = self.ResolveMethod(methodName, RubyClass.IgnoreVisibility).Info; + RubyMemberInfo method = self.ResolveMethod(methodName, VisibilityContext.AllVisible).Info; return method != null && method.Visibility != RubyMethodVisibility.Private; } // thread-safe: [RubyMethod("private_method_defined?")] public static bool PrivateMethodDefined(RubyModule/*!*/ self, [DefaultProtocol, NotNull]string/*!*/ methodName) { - RubyMemberInfo method = self.ResolveMethod(methodName, RubyClass.IgnoreVisibility).Info; + RubyMemberInfo method = self.ResolveMethod(methodName, VisibilityContext.AllVisible).Info; return method != null && method.Visibility == RubyMethodVisibility.Private; } // thread-safe: [RubyMethod("protected_method_defined?")] public static bool ProtectedMethodDefined(RubyModule/*!*/ self, [DefaultProtocol, NotNull]string/*!*/ methodName) { - RubyMemberInfo method = self.ResolveMethod(methodName, RubyClass.IgnoreVisibility).Info; + RubyMemberInfo method = self.ResolveMethod(methodName, VisibilityContext.AllVisible).Info; return method != null && method.Visibility == RubyMethodVisibility.Protected; } // thread-safe: [RubyMethod("public_method_defined?")] public static bool PublicMethodDefined(RubyModule/*!*/ self, [DefaultProtocol, NotNull]string/*!*/ methodName) { - RubyMemberInfo method = self.ResolveMethod(methodName, RubyClass.IgnoreVisibility).Info; + RubyMemberInfo method = self.ResolveMethod(methodName, VisibilityContext.AllVisible).Info; return method != null && method.Visibility == RubyMethodVisibility.Public; } @@ -914,7 +922,7 @@ namespace IronRuby.Builtins { // thread-safe: [RubyMethod("instance_method")] public static UnboundMethod/*!*/ GetInstanceMethod(RubyModule/*!*/ self, [DefaultProtocol, NotNull]string/*!*/ methodName) { - RubyMemberInfo method = self.ResolveMethod(methodName, RubyClass.IgnoreVisibility).Info; + RubyMemberInfo method = self.ResolveMethod(methodName, VisibilityContext.AllVisible).Info; if (method == null) { throw RubyExceptions.CreateUndefinedMethodError(self, methodName); } Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/ModuleOps.cs @@ -2613,7 +2613,15 @@ namespace IronRuby.Builtins { int nilCount = 0; switch (directive.Directive) { case '@': - stream.Position = directive.Count.HasValue ? directive.Count.Value : stream.Position; + if (directive.Count.HasValue) { + if (directive.Count.Value > stream.Length) { + throw RubyExceptions.CreateArgumentError("@ outside of string"); + } + stream.Position = directive.Count.Value > 0 ? directive.Count.Value : 0; + } + else { + stream.Position = stream.Length; + } break; case 'A': @@ -2683,6 +2691,9 @@ namespace IronRuby.Builtins { for (int pos = 0; pos < count; pos++) { if (buffer[pos] == 0) { str.Remove(pos, count - pos); + if (!directive.Count.HasValue) { + stream.Seek(pos - count + 1, SeekOrigin.End); + } break; } } @@ -2755,6 +2766,55 @@ namespace IronRuby.Builtins { } break; + case 'q': + count = CalculateCounts(stream, directive.Count, sizeof(long), out nilCount); + for (int j = 0; j < count; j++) { + long value = reader.ReadInt64(); + if (!BitConverter.IsLittleEndian) { + ulong uvalue = (ulong)value; + uvalue = (0x00000000000000FF & (uvalue >> 56)) | + (0x000000000000FF00 & (uvalue >> 40)) | + (0x0000000000FF0000 & (uvalue >> 24)) | + (0x00000000FF000000 & (uvalue >> 8)) | + (0x000000FF00000000 & (uvalue << 8)) | + (0x0000FF0000000000 & (uvalue << 24)) | + (0x00FF000000000000 & (uvalue << 40)) | + (0xFF00000000000000 & (uvalue << 56)); + value = (long)uvalue; + } + if (value <= Int32.MaxValue && value >= Int32.MinValue) { + result.Add((int)value); + } + else { + result.Add((BigInteger)value); + } + } + break; + + case 'Q': + count = CalculateCounts(stream, directive.Count, sizeof(ulong), out nilCount); + nilCount = 0; + for (int j = 0; j < count; j++) { + ulong value = reader.ReadUInt64(); + if (!BitConverter.IsLittleEndian) { + value = (0x00000000000000FF & (value >> 56)) | + (0x000000000000FF00 & (value >> 40)) | + (0x0000000000FF0000 & (value >> 24)) | + (0x00000000FF000000 & (value >> 8)) | + (0x000000FF00000000 & (value << 8)) | + (0x0000FF0000000000 & (value << 24)) | + (0x00FF000000000000 & (value << 40)) | + (0xFF00000000000000 & (value << 56)); + } + if (value <= Int32.MaxValue) { + result.Add((int)value); + } + else { + result.Add((BigInteger)value); + } + } + break; + case 'm': // TODO: Recognize "==" as end of base 64 encoding int len = (int)(stream.Length - stream.Position); Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/MutableStringOps.cs @@ -172,12 +172,21 @@ namespace IronRuby.Builtins { /// Divides self by other, where other is Float /// </summary> /// <returns>self / other as Float</returns> - [RubyMethod("/"), RubyMethod("div")] - public static object Divide(BigInteger/*!*/ self, double other) { + [RubyMethod("/")] + public static object DivideOp(BigInteger/*!*/ self, double other) { return self.ToFloat64() / other; } /// <summary> + /// Divides self by other, where other is Float + /// </summary> + /// <returns>self divided by other as Float</returns> + [RubyMethod("div")] + public static object Divide(BigInteger/*!*/ self, double other) { + return DivMod(self, other)[0]; + } + + /// <summary> /// Divides self by other, where other is not a Float, Fixnum or Bignum /// </summary> /// <returns>self / other</returns> @@ -300,6 +309,20 @@ namespace IronRuby.Builtins { } /// <summary> + /// Returns self modulo other, where other is Float. + /// </summary> + /// <returns>self modulo other, as Float</returns> + /// <remarks>Calls divmod directly to get the modulus.</remarks> + [RubyMethod("%"), RubyMethod("modulo")] + public static object Modulo(BigInteger/*!*/ self, double other) { + if (other == 0.0) { + return Double.NaN; + } + RubyArray result = DivMod(self, other); + return result[1]; + } + + /// <summary> /// Returns self % other, where other is not Fixnum or Bignum. /// </summary> /// <returns>self % other, as Fixnum or Bignum</returns> @@ -343,6 +366,27 @@ namespace IronRuby.Builtins { } /// <summary> + /// Returns an array containing the quotient and modulus obtained by dividing self by other, where other is Float. + /// If <code>q, r = x.divmod(y)</code>, then + /// <code>q = floor(float(x)/float(y))</code> + /// <code>x = q*y + r</code> + /// </summary> + /// <returns>[self div other, self modulo other] as RubyArray</returns> + /// <remarks>Normalizes div to Fixnum as necessary</remarks> + [RubyMethod("divmod")] + public static RubyArray DivMod(BigInteger/*!*/ self, double other) { + if (other == 0.0) { + throw new FloatDomainError("NaN"); + } + + double selfFloat = self.ToFloat64(); + BigInteger div = BigInteger.Create(selfFloat / other); + double mod = selfFloat % other; + + return RubyOps.MakeArray2(Protocols.Normalize(div), mod); + } + + /// <summary> /// Returns an array containing the quotient and modulus obtained by dividing self by other, where other is not Fixnum or Bignum. /// If <code>q, r = x.divmod(y)</code>, then /// <code>q = floor(float(x)/float(y))</code> @@ -374,12 +418,24 @@ namespace IronRuby.Builtins { } /// <summary> - /// Returns the remainder after dividing self by other, where other is not Fixnum or Bignum. + /// Returns the remainder after dividing self by other, where other is Float. /// </summary> /// <example> /// -1234567890987654321.remainder(13731.24) #=> -9906.22531493148 /// </example> - /// <returns>Float, Fixnum or Bignum</returns> + /// <returns>Float</returns> + [RubyMethod("remainder")] + public static double Remainder(BigInteger/*!*/ self, double other) { + return self.ToFloat64() % other; + } + + /// <summary> + /// Returns the remainder after dividing self by other, where other is not Fixnum or Bignum. + /// </summary> + /// <example> + /// -1234567890987654321.remainder(13731) #=> -6966 + /// </example> + /// <returns>Fixnum or Bignum</returns> /// <remarks>Coerces self and other using other.coerce(self) then dynamically invokes remainder</remarks> [RubyMethod("remainder")] public static object Remainder(BinaryOpStorage/*!*/ coercionStorage, BinaryOpStorage/*!*/ binaryOpSite, object/*!*/ self, object other) { @@ -762,7 +818,7 @@ namespace IronRuby.Builtins { /// </summary> /// <param name="radix">An integer between 2 and 36 inclusive</param> [RubyMethod("to_s")] - public static MutableString/*!*/ ToString(BigInteger/*!*/ self, uint radix) { + public static MutableString/*!*/ ToString(BigInteger/*!*/ self, int radix) { if (radix < 2 || radix > 36) { throw RubyExceptions.CreateArgumentError(String.Format("illegal radix {0}", radix)); } Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Extensions/ClrBigInteger.cs @@ -88,5 +88,29 @@ namespace IronRuby.Builtins { public static object Compare(BinaryOpStorage/*!*/ comparisonStorage, RespondToStorage/*!*/ respondToStorage, ClrName/*!*/ self, object other) { return MutableStringOps.Compare(comparisonStorage, respondToStorage, self.MangledName, other); } + + /// <summary> + /// Converts a Ruby name to PascalCase name (e.g. "foo_bar" to "FooBar"). + /// Returns null if the name is not a well-formed Ruby name (it contains upper-case latter or subsequent underscores). + /// Characters that are not upper case letters are treated as lower-case letters. + /// </summary> + [RubyMethod("ruby_to_clr", RubyMethodAttributes.PublicSingleton)] + [RubyMethod("unmangle", RubyMethodAttributes.PublicSingleton)] + public static MutableString Unmangle(RubyClass/*!*/ self, [DefaultProtocol]string/*!*/ rubyName) { + var clr = RubyUtils.TryUnmangleName(rubyName); + return clr != null ? MutableString.Create(clr) : null; + } + + /// <summary> + /// Converts a camelCase or PascalCase name to a Ruby name (e.g. "FooBar" to "foo_bar"). + /// Returns null if the name is not in camelCase or PascalCase (FooBAR, foo, etc.). + /// Characters that are not upper case letters are treated as lower-case letters. + /// </summary> + [RubyMethod("clr_to_ruby", RubyMethodAttributes.PublicSingleton)] + [RubyMethod("mangle", RubyMethodAttributes.PublicSingleton)] + public static MutableString Mangle(RubyClass/*!*/ self, [DefaultProtocol]string/*!*/ clrName) { + var ruby = RubyUtils.TryMangleName(clrName); + return ruby != null ? MutableString.Create(ruby) : null; + } } } Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Extensions/ClrNameOps.cs @@ -30,6 +30,10 @@ namespace IronRuby.Builtins { public static object Each(BlockParam block, IEnumerable/*!*/ self) { foreach (object obj in self) { object result; + if (block == null) { + throw RubyExceptions.NoBlockGiven(); + } + if (block.Yield(obj, out result)) { return result; } Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Extensions/IEnumerableOps.cs @@ -27,6 +27,8 @@ using Microsoft.Scripting.Utils; using IronRuby.Runtime; using IronRuby.Runtime.Calls; +using EachSite = System.Func<System.Runtime.CompilerServices.CallSite, object, IronRuby.Builtins.Proc, object>; + namespace IronRuby.Builtins { [RubyModule(Extends = typeof(IList), Restrictions = ModuleRestrictions.None)] @@ -302,8 +304,8 @@ namespace IronRuby.Builtins { #region ==, <=>, eql?, hash [RubyMethod("==")] - public static bool Equals(ConversionStorage<IList>/*!*/ arrayTryCast, BinaryOpStorage/*!*/ equals, IList/*!*/ self, object other) { - IList otherAsArray = Protocols.TryCastToArray(arrayTryCast, other); + public static bool Equals(ConversionStorage<IList>/*!*/ arrayTryConvert, BinaryOpStorage/*!*/ equals, IList/*!*/ self, object other) { + IList otherAsArray = Protocols.TryConvertToArray(arrayTryConvert, other); return otherAsArray != null ? Equals(equals, self, otherAsArray) : false; } @@ -1533,5 +1535,16 @@ namespace IronRuby.Builtins { } #endregion + + #region zip + + [RubyMethod("zip")] + public static IList/*!*/ Zip(CallSiteStorage<EachSite>/*!*/ each, ConversionStorage<IList>/*!*/ tryToAry, BlockParam block, + object self, [DefaultProtocol, NotNull, NotNullItems]params IList[]/*!*/ args) { + + return Enumerable.Zip(each, tryToAry, block, self, args); + } + + #endregion } } Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Extensions/IListOps.cs @@ -19,16 +19,64 @@ using IronRuby.Runtime; using Microsoft.Scripting.Runtime; using System.Diagnostics; using System; +using System.Collections.Generic; +using Microsoft.Scripting.Utils; +using System.Reflection; +using System.Runtime.InteropServices; namespace IronRuby.Builtins { [RubyModule("IronRuby", Extends = typeof(Ruby), Restrictions = ModuleRestrictions.None)] public static class IronRubyOps { - [RubyMethod("dlr_config", RubyMethodAttributes.PublicSingleton)] - public static DlrConfiguration/*!*/ GetCurrentRuntimeConfiguration(RubyContext/*!*/ context, object self) { + [RubyMethod("configuration", RubyMethodAttributes.PublicSingleton)] + public static DlrConfiguration/*!*/ GetConfiguration(RubyContext/*!*/ context, RubyModule/*!*/ self) { return context.DomainManager.Configuration; } + [RubyMethod("globals", RubyMethodAttributes.PublicSingleton)] + public static Scope/*!*/ GetGlobalScope(RubyContext/*!*/ context, RubyModule/*!*/ self) { + return context.DomainManager.Globals; + } + + [RubyMethod("loaded_assemblies", RubyMethodAttributes.PublicSingleton)] + public static RubyArray/*!*/ GetLoadedAssemblies(RubyContext/*!*/ context, RubyModule/*!*/ self) { + return new RubyArray(context.DomainManager.GetLoadedAssemblyList()); + } + + /// <summary> + /// Gets a live read-only and thread-safe dictionary that maps full paths of the loaded scripts to their scopes. + /// </summary> + [RubyMethod("loaded_scripts", RubyMethodAttributes.PublicSingleton)] + public static IDictionary<string, Scope>/*!*/ GetLoadedScripts(RubyContext/*!*/ context, RubyModule/*!*/ self) { + return new ReadOnlyDictionary<string, Scope>(context.Loader.LoadedScripts); + } + + /// <summary> + /// The same as Kernel#require except for that it returns the loaded Assembly or Scope (even if already loaded). + /// </summary> + [RubyMethod("require", RubyMethodAttributes.PublicSingleton)] + public static object/*!*/ Require(RubyScope/*!*/ scope, RubyModule/*!*/ self, MutableString/*!*/ libraryName) { + object loaded; + + scope.RubyContext.Loader.LoadFile( + null, self, libraryName, LoadFlags.LoadOnce | LoadFlags.AppendExtensions | LoadFlags.ResolveLoaded, out loaded + ); + + Debug.Assert(loaded != null); + return loaded; + } + + /// <summary> + /// The same as Kernel#require except for that it returns the loaded Assembly or Scope. + /// </summary> + [RubyMethod("load", RubyMethodAttributes.PublicSingleton)] + public static object/*!*/ Load(RubyScope/*!*/ scope, RubyModule/*!*/ self, MutableString/*!*/ libraryName) { + object loaded; + scope.RubyContext.Loader.LoadFile(null, self, libraryName, LoadFlags.ResolveLoaded, out loaded); + Debug.Assert(loaded != null); + return loaded; + } + [RubyModule("Clr", Restrictions = ModuleRestrictions.None)] public static class ClrOps { [RubyMethod("profile", RubyMethodAttributes.PublicSingleton)] Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Extensions/IronRubyOps.cs @@ -44,8 +44,8 @@ namespace IronRuby.Builtins { // Skipped primitive: __ClassSingleton // Skipped primitive: __MainSingleton - IronRuby.Builtins.RubyModule def42 = DefineGlobalModule("Comparable", typeof(IronRuby.Builtins.Comparable), 0x00000103, LoadComparable_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); - IronRuby.Builtins.RubyModule def33 = DefineGlobalModule("Enumerable", typeof(IronRuby.Builtins.Enumerable), 0x00000103, LoadEnumerable_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); + IronRuby.Builtins.RubyModule def43 = DefineGlobalModule("Comparable", typeof(IronRuby.Builtins.Comparable), 0x00000103, LoadComparable_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); + IronRuby.Builtins.RubyModule def34 = DefineGlobalModule("Enumerable", typeof(IronRuby.Builtins.Enumerable), 0x00000103, LoadEnumerable_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); IronRuby.Builtins.RubyModule def8 = DefineGlobalModule("Errno", typeof(IronRuby.Builtins.Errno), 0x00000103, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); IronRuby.Builtins.RubyModule def25 = DefineModule("File::Constants", typeof(IronRuby.Builtins.RubyFileOps.Constants), 0x00000103, null, null, LoadFile__Constants_Constants, IronRuby.Builtins.RubyModule.EmptyArray); DefineGlobalModule("FileTest", typeof(IronRuby.Builtins.FileTest), 0x00000103, null, LoadFileTest_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); @@ -63,7 +63,7 @@ namespace IronRuby.Builtins { DefineGlobalModule("Math", typeof(IronRuby.Builtins.RubyMath), 0x00000103, LoadMath_Instance, LoadMath_Class, LoadMath_Constants, IronRuby.Builtins.RubyModule.EmptyArray); ExtendClass(typeof(Microsoft.Scripting.Actions.TypeTracker), null, LoadMicrosoft__Scripting__Actions__TypeTracker_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); DefineGlobalModule("ObjectSpace", typeof(IronRuby.Builtins.ObjectSpace), 0x00000103, null, LoadObjectSpace_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); - IronRuby.Builtins.RubyModule def39 = DefineGlobalModule("Precision", typeof(IronRuby.Builtins.Precision), 0x00000103, LoadPrecision_Instance, LoadPrecision_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); + IronRuby.Builtins.RubyModule def40 = DefineGlobalModule("Precision", typeof(IronRuby.Builtins.Precision), 0x00000103, LoadPrecision_Instance, LoadPrecision_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); #if !SILVERLIGHT IronRuby.Builtins.RubyModule def26 = DefineGlobalModule("Process", typeof(IronRuby.Builtins.RubyProcess), 0x00000103, LoadProcess_Instance, LoadProcess_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); #endif @@ -73,227 +73,228 @@ namespace IronRuby.Builtins { ExtendClass(typeof(System.Type), null, LoadSystem__Type_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); // Skipped primitive: __ClassSingletonSingleton #if !SILVERLIGHT - object def1 = DefineSingleton(Load__Singleton_ArgFilesSingletonOps_Instance, null, null, def33); + object def1 = DefineSingleton(Load__Singleton_ArgFilesSingletonOps_Instance, null, null, def34); #endif - object def7 = DefineSingleton(Load__Singleton_EnvironmentSingletonOps_Instance, null, null, def33); - ExtendClass(typeof(Microsoft.Scripting.Actions.TypeGroup), null, LoadMicrosoft__Scripting__Actions__TypeGroup_Instance, null, null, new IronRuby.Builtins.RubyModule[] {def33}); + object def7 = DefineSingleton(Load__Singleton_EnvironmentSingletonOps_Instance, null, null, def34); + ExtendClass(typeof(Microsoft.Scripting.Actions.TypeGroup), null, LoadMicrosoft__Scripting__Actions__TypeGroup_Instance, null, null, new IronRuby.Builtins.RubyModule[] {def34}); // Skipped primitive: Object - ExtendClass(typeof(System.Char), null, null, null, null, new IronRuby.Builtins.RubyModule[] {def6, def33, def42}, + ExtendClass(typeof(System.Char), null, null, null, null, new IronRuby.Builtins.RubyModule[] {def6, def34, def43}, new System.Func<IronRuby.Builtins.RubyClass, System.Char, System.Char>(IronRuby.Builtins.CharOps.Create), new System.Func<IronRuby.Builtins.RubyClass, System.Char[], System.Char>(IronRuby.Builtins.CharOps.Create), new System.Func<IronRuby.Builtins.RubyClass, System.String, System.Char>(IronRuby.Builtins.CharOps.Create), new System.Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString, System.Char>(IronRuby.Builtins.CharOps.Create) ); - ExtendModule(typeof(System.Collections.Generic.IDictionary<System.Object, System.Object>), LoadSystem__Collections__Generic__IDictionary_Instance, null, null, def33); - ExtendModule(typeof(System.Collections.IEnumerable), LoadSystem__Collections__IEnumerable_Instance, null, null, def33); - ExtendModule(typeof(System.Collections.IList), LoadSystem__Collections__IList_Instance, null, null, def33); - ExtendModule(typeof(System.IComparable), LoadSystem__IComparable_Instance, null, null, def42); - ExtendClass(typeof(System.String), null, null, null, null, new IronRuby.Builtins.RubyModule[] {def6, def33, def42}, + ExtendModule(typeof(System.Collections.Generic.IDictionary<System.Object, System.Object>), LoadSystem__Collections__Generic__IDictionary_Instance, null, null, def34); + ExtendModule(typeof(System.Collections.IEnumerable), LoadSystem__Collections__IEnumerable_Instance, null, null, def34); + ExtendModule(typeof(System.Collections.IList), LoadSystem__Collections__IList_Instance, null, null, def34); + ExtendModule(typeof(System.IComparable), LoadSystem__IComparable_Instance, null, null, def43); + ExtendClass(typeof(System.String), null, null, null, null, new IronRuby.Builtins.RubyModule[] {def6, def34, def43}, new System.Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString, System.String>(IronRuby.Builtins.ClrStringOps.Create), new System.Func<IronRuby.Builtins.RubyClass, System.Char, System.Int32, System.String>(IronRuby.Builtins.ClrStringOps.Create), new System.Func<IronRuby.Builtins.RubyClass, System.Char[], System.String>(IronRuby.Builtins.ClrStringOps.Create), new System.Func<IronRuby.Builtins.RubyClass, System.Char[], System.Int32, System.Int32, System.String>(IronRuby.Builtins.ClrStringOps.Create) ); - DefineGlobalClass("Array", typeof(IronRuby.Builtins.RubyArray), 0x00000003, Context.ObjectClass, LoadArray_Instance, LoadArray_Class, null, new IronRuby.Builtins.RubyModule[] {def33}, + DefineGlobalClass("Array", typeof(IronRuby.Builtins.RubyArray), 0x00000003, Context.ObjectClass, LoadArray_Instance, LoadArray_Class, null, new IronRuby.Builtins.RubyModule[] {def34}, new System.Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.RubyArray>(IronRuby.Builtins.ArrayOps.CreateArray), new System.Func<IronRuby.Runtime.ConversionStorage<IronRuby.Runtime.Union<System.Collections.IList, System.Int32>>, IronRuby.Runtime.BlockParam, IronRuby.Builtins.RubyClass, System.Object, System.Object>(IronRuby.Builtins.ArrayOps.CreateArray), new System.Func<IronRuby.Runtime.BlockParam, IronRuby.Builtins.RubyClass, System.Int32, System.Object, IronRuby.Builtins.RubyArray>(IronRuby.Builtins.ArrayOps.CreateArray), new System.Func<IronRuby.Builtins.RubyClass, System.Int32, System.Object, IronRuby.Builtins.RubyArray>(IronRuby.Builtins.ArrayOps.CreateArray) ); DefineGlobalClass("Binding", typeof(IronRuby.Builtins.Binding), 0x00000003, Context.ObjectClass, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); - DefineGlobalClass("Dir", typeof(IronRuby.Builtins.RubyDir), 0x00000103, Context.ObjectClass, LoadDir_Instance, LoadDir_Class, null, new IronRuby.Builtins.RubyModule[] {def33}); + DefineGlobalClass("Dir", typeof(IronRuby.Builtins.RubyDir), 0x00000103, Context.ObjectClass, LoadDir_Instance, LoadDir_Class, null, new IronRuby.Builtins.RubyModule[] {def34}); #if !SILVERLIGHT if (Context.RubyOptions.Compatibility >= RubyCompatibility.Ruby19) { DefineGlobalClass("Encoding", typeof(IronRuby.Builtins.RubyEncoding), 0x00000003, Context.ObjectClass, LoadEncoding_Instance, LoadEncoding_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); } #endif - IronRuby.Builtins.RubyClass def43 = Context.ExceptionClass = DefineGlobalClass("Exception", typeof(System.Exception), 0x00000003, Context.ObjectClass, LoadException_Instance, LoadException_Class, null, IronRuby.Builtins.RubyModule.EmptyArray, + IronRuby.Builtins.RubyClass def44 = Context.ExceptionClass = DefineGlobalClass("Exception", typeof(System.Exception), 0x00000003, Context.ObjectClass, LoadException_Instance, LoadException_Class, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__Exception)); Context.FalseClass = DefineGlobalClass("FalseClass", typeof(IronRuby.Builtins.FalseClass), 0x00000103, Context.ObjectClass, LoadFalseClass_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); #if !SILVERLIGHT - IronRuby.Builtins.RubyClass def31 = DefineClass("File::Stat", typeof(System.IO.FileSystemInfo), 0x00000003, Context.ObjectClass, LoadFile__Stat_Instance, null, null, new IronRuby.Builtins.RubyModule[] {def42}, + IronRuby.Builtins.RubyClass def32 = DefineClass("File::Stat", typeof(System.IO.FileSystemInfo), 0x00000003, Context.ObjectClass, LoadFile__Stat_Instance, null, null, new IronRuby.Builtins.RubyModule[] {def43}, new System.Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString, System.IO.FileSystemInfo>(IronRuby.Builtins.RubyFileOps.RubyStatOps.Create) ); #endif - DefineGlobalClass("Hash", typeof(IronRuby.Builtins.Hash), 0x00000003, Context.ObjectClass, LoadHash_Instance, LoadHash_Class, null, new IronRuby.Builtins.RubyModule[] {def33}, + DefineGlobalClass("Hash", typeof(IronRuby.Builtins.Hash), 0x00000003, Context.ObjectClass, LoadHash_Instance, LoadHash_Class, null, new IronRuby.Builtins.RubyModule[] {def34}, new System.Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.Hash>(IronRuby.Builtins.HashOps.CreateHash), new System.Func<IronRuby.Runtime.BlockParam, IronRuby.Builtins.RubyClass, System.Object, IronRuby.Builtins.Hash>(IronRuby.Builtins.HashOps.CreateHash), new System.Func<IronRuby.Runtime.BlockParam, IronRuby.Builtins.RubyClass, IronRuby.Builtins.Hash>(IronRuby.Builtins.HashOps.CreateHash) ); - IronRuby.Builtins.RubyClass def44 = DefineGlobalClass("IO", typeof(IronRuby.Builtins.RubyIO), 0x00000003, Context.ObjectClass, LoadIO_Instance, LoadIO_Class, LoadIO_Constants, new IronRuby.Builtins.RubyModule[] {def25, def33}, + IronRuby.Builtins.RubyClass def45 = DefineGlobalClass("IO", typeof(IronRuby.Builtins.RubyIO), 0x00000003, Context.ObjectClass, LoadIO_Instance, LoadIO_Class, LoadIO_Constants, new IronRuby.Builtins.RubyModule[] {def25, def34}, new System.Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.RubyIO>(IronRuby.Builtins.RubyIOOps.CreateIO), new System.Func<IronRuby.Builtins.RubyClass, System.Int32, IronRuby.Builtins.MutableString, IronRuby.Builtins.RubyIO>(IronRuby.Builtins.RubyIOOps.CreateIO) ); - IronRuby.Builtins.RubyClass def28 = DefineClass("IronRuby::Clr::Name", typeof(IronRuby.Runtime.ClrName), 0x00000003, Context.ObjectClass, LoadIronRuby__Clr__Name_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); + IronRuby.Builtins.RubyClass def28 = DefineClass("IronRuby::Clr::Name", typeof(IronRuby.Runtime.ClrName), 0x00000003, Context.ObjectClass, LoadIronRuby__Clr__Name_Instance, LoadIronRuby__Clr__Name_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); + IronRuby.Builtins.RubyClass def29 = DefineClass("IronRuby::Clr::Scope", typeof(Microsoft.Scripting.Runtime.Scope), 0x00000003, Context.ObjectClass, LoadIronRuby__Clr__Scope_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); DefineGlobalClass("MatchData", typeof(IronRuby.Builtins.MatchData), 0x00000003, Context.ObjectClass, LoadMatchData_Instance, LoadMatchData_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); DefineGlobalClass("Method", typeof(IronRuby.Builtins.RubyMethod), 0x00000003, Context.ObjectClass, LoadMethod_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); // Skipped primitive: Module Context.NilClass = DefineGlobalClass("NilClass", typeof(Microsoft.Scripting.Runtime.DynamicNull), 0x00000003, Context.ObjectClass, LoadNilClass_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); - IronRuby.Builtins.RubyClass def38 = DefineGlobalClass("Numeric", typeof(IronRuby.Builtins.Numeric), 0x00000103, Context.ObjectClass, LoadNumeric_Instance, null, null, new IronRuby.Builtins.RubyModule[] {def42}); + IronRuby.Builtins.RubyClass def39 = DefineGlobalClass("Numeric", typeof(IronRuby.Builtins.Numeric), 0x00000103, Context.ObjectClass, LoadNumeric_Instance, null, null, new IronRuby.Builtins.RubyModule[] {def43}); DefineGlobalClass("Proc", typeof(IronRuby.Builtins.Proc), 0x00000003, Context.ObjectClass, LoadProc_Instance, LoadProc_Class, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Action<IronRuby.Builtins.RubyClass, System.Object[]>(IronRuby.Builtins.ProcOps.Error) ); #if !SILVERLIGHT && !SILVERLIGHT IronRuby.Builtins.RubyClass def27 = DefineClass("Process::Status", typeof(IronRuby.Builtins.RubyProcess.Status), 0x00000103, Context.ObjectClass, LoadProcess__Status_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); #endif - DefineGlobalClass("Range", typeof(IronRuby.Builtins.Range), 0x00000003, Context.ObjectClass, LoadRange_Instance, null, null, new IronRuby.Builtins.RubyModule[] {def33}, + DefineGlobalClass("Range", typeof(IronRuby.Builtins.Range), 0x00000003, Context.ObjectClass, LoadRange_Instance, null, null, new IronRuby.Builtins.RubyModule[] {def34}, new System.Func<IronRuby.Runtime.BinaryOpStorage, IronRuby.Builtins.RubyClass, System.Object, System.Object, System.Boolean, IronRuby.Builtins.Range>(IronRuby.Builtins.RangeOps.CreateRange) ); - DefineGlobalClass("Regexp", typeof(IronRuby.Builtins.RubyRegex), 0x00000003, Context.ObjectClass, LoadRegexp_Instance, LoadRegexp_Class, LoadRegexp_Constants, new IronRuby.Builtins.RubyModule[] {def33}, + DefineGlobalClass("Regexp", typeof(IronRuby.Builtins.RubyRegex), 0x00000003, Context.ObjectClass, LoadRegexp_Instance, LoadRegexp_Class, LoadRegexp_Constants, new IronRuby.Builtins.RubyModule[] {def34}, new System.Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.RubyRegex, IronRuby.Builtins.RubyRegex>(IronRuby.Builtins.RegexpOps.Create), new System.Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.RubyRegex, System.Int32, System.Object, IronRuby.Builtins.RubyRegex>(IronRuby.Builtins.RegexpOps.Create), new System.Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.RubyRegex, System.Object, System.Object, IronRuby.Builtins.RubyRegex>(IronRuby.Builtins.RegexpOps.Create), new System.Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString, System.Int32, IronRuby.Builtins.MutableString, IronRuby.Builtins.RubyRegex>(IronRuby.Builtins.RegexpOps.Create), new System.Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString, System.Boolean, IronRuby.Builtins.MutableString, IronRuby.Builtins.RubyRegex>(IronRuby.Builtins.RegexpOps.Create) ); - DefineGlobalClass("String", typeof(IronRuby.Builtins.MutableString), 0x00000003, Context.ObjectClass, LoadString_Instance, null, null, new IronRuby.Builtins.RubyModule[] {def33, def42}, + DefineGlobalClass("String", typeof(IronRuby.Builtins.MutableString), 0x00000003, Context.ObjectClass, LoadString_Instance, null, null, new IronRuby.Builtins.RubyModule[] {def34, def43}, new System.Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString>(IronRuby.Builtins.MutableStringOps.Create), new System.Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString, IronRuby.Builtins.MutableString>(IronRuby.Builtins.MutableStringOps.Create) ); - DefineGlobalClass("Struct", typeof(IronRuby.Builtins.RubyStruct), 0x00000003, Context.ObjectClass, LoadStruct_Instance, LoadStruct_Class, LoadStruct_Constants, new IronRuby.Builtins.RubyModule[] {def33}, + DefineGlobalClass("Struct", typeof(IronRuby.Builtins.RubyStruct), 0x00000003, Context.ObjectClass, LoadStruct_Instance, LoadStruct_Class, LoadStruct_Constants, new IronRuby.Builtins.RubyModule[] {def34}, new System.Action<IronRuby.Builtins.RubyClass, System.Object[]>(IronRuby.Builtins.RubyStructOps.AllocatorUndefined) ); DefineGlobalClass("Symbol", typeof(Microsoft.Scripting.SymbolId), 0x00000003, Context.ObjectClass, LoadSymbol_Instance, LoadSymbol_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); DefineGlobalClass("Thread", typeof(System.Threading.Thread), 0x00000003, Context.ObjectClass, LoadThread_Instance, LoadThread_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); DefineGlobalClass("ThreadGroup", typeof(IronRuby.Builtins.ThreadGroup), 0x00000103, Context.ObjectClass, LoadThreadGroup_Instance, null, LoadThreadGroup_Constants, IronRuby.Builtins.RubyModule.EmptyArray); - DefineGlobalClass("Time", typeof(System.DateTime), 0x00000003, Context.ObjectClass, LoadTime_Instance, LoadTime_Class, null, new IronRuby.Builtins.RubyModule[] {def42}, + DefineGlobalClass("Time", typeof(System.DateTime), 0x00000003, Context.ObjectClass, LoadTime_Instance, LoadTime_Class, null, new IronRuby.Builtins.RubyModule[] {def43}, new System.Func<IronRuby.Builtins.RubyClass, System.DateTime>(IronRuby.Builtins.TimeOps.Create) ); Context.TrueClass = DefineGlobalClass("TrueClass", typeof(IronRuby.Builtins.TrueClass), 0x00000103, Context.ObjectClass, LoadTrueClass_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); DefineGlobalClass("UnboundMethod", typeof(IronRuby.Builtins.UnboundMethod), 0x00000103, Context.ObjectClass, LoadUnboundMethod_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray); // Skipped primitive: Class - IronRuby.Builtins.RubyClass def24 = DefineGlobalClass("File", typeof(IronRuby.Builtins.RubyFile), 0x00000003, def44, LoadFile_Instance, LoadFile_Class, LoadFile_Constants, IronRuby.Builtins.RubyModule.EmptyArray, + IronRuby.Builtins.RubyClass def24 = DefineGlobalClass("File", typeof(IronRuby.Builtins.RubyFile), 0x00000003, def45, LoadFile_Instance, LoadFile_Class, LoadFile_Constants, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, IronRuby.Runtime.Union<System.Int32, IronRuby.Builtins.MutableString>, IronRuby.Builtins.MutableString, System.Int32, IronRuby.Builtins.RubyFile>(IronRuby.Builtins.RubyFileOps.CreateFile), new System.Func<IronRuby.Builtins.RubyClass, IronRuby.Runtime.Union<System.Int32, IronRuby.Builtins.MutableString>, System.Int32, System.Int32, IronRuby.Builtins.RubyFile>(IronRuby.Builtins.RubyFileOps.CreateFile), new System.Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString, IronRuby.Builtins.RubyFile>(IronRuby.Builtins.RubyFileOps.CreateFile), new System.Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString, IronRuby.Builtins.MutableString, IronRuby.Builtins.RubyFile>(IronRuby.Builtins.RubyFileOps.CreateFile), new System.Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString, System.Int32, IronRuby.Builtins.RubyFile>(IronRuby.Builtins.RubyFileOps.CreateFile) ); - DefineGlobalClass("Float", typeof(System.Double), 0x00000003, def38, LoadFloat_Instance, LoadFloat_Class, LoadFloat_Constants, new IronRuby.Builtins.RubyModule[] {def39}); - IronRuby.Builtins.RubyClass def45 = DefineGlobalClass("Integer", typeof(IronRuby.Builtins.Integer), 0x00000103, def38, LoadInteger_Instance, LoadInteger_Class, null, new IronRuby.Builtins.RubyModule[] {def39}); - DefineGlobalClass("NoMemoryError", typeof(IronRuby.Builtins.NoMemoryError), 0x00000103, def43, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("Float", typeof(System.Double), 0x00000003, def39, LoadFloat_Instance, LoadFloat_Class, LoadFloat_Constants, new IronRuby.Builtins.RubyModule[] {def40}); + IronRuby.Builtins.RubyClass def46 = DefineGlobalClass("Integer", typeof(IronRuby.Builtins.Integer), 0x00000103, def39, LoadInteger_Instance, LoadInteger_Class, null, new IronRuby.Builtins.RubyModule[] {def40}); + DefineGlobalClass("NoMemoryError", typeof(IronRuby.Builtins.NoMemoryError), 0x00000103, def44, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__NoMemoryError)); - IronRuby.Builtins.RubyClass def41 = DefineGlobalClass("ScriptError", typeof(IronRuby.Builtins.ScriptError), 0x00000003, def43, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + IronRuby.Builtins.RubyClass def42 = DefineGlobalClass("ScriptError", typeof(IronRuby.Builtins.ScriptError), 0x00000003, def44, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__ScriptError)); - IronRuby.Builtins.RubyClass def40 = DefineGlobalClass("SignalException", typeof(IronRuby.Builtins.SignalException), 0x00000103, def43, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + IronRuby.Builtins.RubyClass def41 = DefineGlobalClass("SignalException", typeof(IronRuby.Builtins.SignalException), 0x00000103, def44, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__SignalException)); - IronRuby.Builtins.RubyClass def34 = Context.StandardErrorClass = DefineGlobalClass("StandardError", typeof(System.SystemException), 0x00000003, def43, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + IronRuby.Builtins.RubyClass def35 = Context.StandardErrorClass = DefineGlobalClass("StandardError", typeof(System.SystemException), 0x00000003, def44, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__StandardError)); - ExtendClass(typeof(System.Single), def38, LoadSystem__Single_Instance, LoadSystem__Single_Class, null, new IronRuby.Builtins.RubyModule[] {def39}, + ExtendClass(typeof(System.Single), def39, LoadSystem__Single_Instance, LoadSystem__Single_Class, null, new IronRuby.Builtins.RubyModule[] {def40}, new System.Func<IronRuby.Builtins.RubyClass, System.Double, System.Single>(IronRuby.Builtins.SingleOps.Create) ); - DefineGlobalClass("SystemExit", typeof(IronRuby.Builtins.SystemExit), 0x00000003, def43, LoadSystemExit_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("SystemExit", typeof(IronRuby.Builtins.SystemExit), 0x00000003, def44, LoadSystemExit_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, System.Object, IronRuby.Builtins.SystemExit>(IronRuby.Builtins.SystemExitOps.Factory), new System.Func<IronRuby.Builtins.RubyClass, System.Int32, System.Object, IronRuby.Builtins.SystemExit>(IronRuby.Builtins.SystemExitOps.Factory) ); - DefineGlobalClass("ArgumentError", typeof(System.ArgumentException), 0x00000003, def34, LoadArgumentError_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("ArgumentError", typeof(System.ArgumentException), 0x00000003, def35, LoadArgumentError_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__ArgumentError)); - DefineGlobalClass("Bignum", typeof(Microsoft.Scripting.Math.BigInteger), 0x00000003, def45, LoadBignum_Instance, LoadBignum_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); - DefineGlobalClass("EncodingError", typeof(IronRuby.Builtins.EncodingError), 0x00000003, def34, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("Bignum", typeof(Microsoft.Scripting.Math.BigInteger), 0x00000003, def46, LoadBignum_Instance, LoadBignum_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); + DefineGlobalClass("EncodingError", typeof(IronRuby.Builtins.EncodingError), 0x00000003, def35, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__EncodingError)); - DefineGlobalClass("Fixnum", typeof(System.Int32), 0x00000003, def45, LoadFixnum_Instance, LoadFixnum_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); - DefineGlobalClass("IndexError", typeof(System.IndexOutOfRangeException), 0x00000003, def34, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("Fixnum", typeof(System.Int32), 0x00000003, def46, LoadFixnum_Instance, LoadFixnum_Class, null, IronRuby.Builtins.RubyModule.EmptyArray); + DefineGlobalClass("IndexError", typeof(System.IndexOutOfRangeException), 0x00000003, def35, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__IndexError)); - DefineGlobalClass("Interrupt", typeof(IronRuby.Builtins.Interrupt), 0x00000103, def40, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("Interrupt", typeof(IronRuby.Builtins.Interrupt), 0x00000103, def41, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__Interrupt)); - IronRuby.Builtins.RubyClass def35 = DefineGlobalClass("IOError", typeof(System.IO.IOException), 0x00000003, def34, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + IronRuby.Builtins.RubyClass def36 = DefineGlobalClass("IOError", typeof(System.IO.IOException), 0x00000003, def35, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__IOError)); - DefineGlobalClass("LoadError", typeof(IronRuby.Builtins.LoadError), 0x00000003, def41, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("LoadError", typeof(IronRuby.Builtins.LoadError), 0x00000003, def42, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__LoadError)); - DefineGlobalClass("LocalJumpError", typeof(IronRuby.Builtins.LocalJumpError), 0x00000003, def34, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("LocalJumpError", typeof(IronRuby.Builtins.LocalJumpError), 0x00000003, def35, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__LocalJumpError)); - IronRuby.Builtins.RubyClass def46 = DefineGlobalClass("NameError", typeof(System.MemberAccessException), 0x00000003, def34, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + IronRuby.Builtins.RubyClass def47 = DefineGlobalClass("NameError", typeof(System.MemberAccessException), 0x00000003, def35, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__NameError)); - DefineGlobalClass("NotImplementedError", typeof(IronRuby.Builtins.NotImplementedError), 0x00000003, def41, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("NotImplementedError", typeof(IronRuby.Builtins.NotImplementedError), 0x00000003, def42, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__NotImplementedError)); - IronRuby.Builtins.RubyClass def37 = DefineGlobalClass("RangeError", typeof(System.ArgumentOutOfRangeException), 0x00000003, def34, LoadRangeError_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + IronRuby.Builtins.RubyClass def38 = DefineGlobalClass("RangeError", typeof(System.ArgumentOutOfRangeException), 0x00000003, def35, LoadRangeError_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__RangeError)); - DefineGlobalClass("RegexpError", typeof(IronRuby.Builtins.RegexpError), 0x00000003, def34, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("RegexpError", typeof(IronRuby.Builtins.RegexpError), 0x00000003, def35, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__RegexpError)); - DefineGlobalClass("RuntimeError", typeof(IronRuby.Builtins.RuntimeError), 0x00000103, def34, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("RuntimeError", typeof(IronRuby.Builtins.RuntimeError), 0x00000103, def35, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__RuntimeError)); - DefineGlobalClass("SecurityError", typeof(System.Security.SecurityException), 0x00000003, def34, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("SecurityError", typeof(System.Security.SecurityException), 0x00000003, def35, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__SecurityError)); - DefineGlobalClass("SyntaxError", typeof(IronRuby.Builtins.SyntaxError), 0x00000003, def41, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("SyntaxError", typeof(IronRuby.Builtins.SyntaxError), 0x00000003, def42, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__SyntaxError)); - ExtendClass(typeof(System.Byte), def45, LoadSystem__Byte_Instance, LoadSystem__Byte_Class, null, IronRuby.Builtins.RubyModule.EmptyArray, + ExtendClass(typeof(System.Byte), def46, LoadSystem__Byte_Instance, LoadSystem__Byte_Class, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, System.Int32, System.Byte>(IronRuby.Builtins.ByteOps.InducedFrom), new System.Func<IronRuby.Builtins.RubyClass, Microsoft.Scripting.Math.BigInteger, System.Byte>(IronRuby.Builtins.ByteOps.InducedFrom), new System.Func<IronRuby.Builtins.RubyClass, System.Double, System.Byte>(IronRuby.Builtins.ByteOps.InducedFrom) ); - ExtendClass(typeof(System.Int16), def45, LoadSystem__Int16_Instance, LoadSystem__Int16_Class, null, IronRuby.Builtins.RubyModule.EmptyArray, + ExtendClass(typeof(System.Int16), def46, LoadSystem__Int16_Instance, LoadSystem__Int16_Class, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, System.Int32, System.Int16>(IronRuby.Builtins.Int16Ops.InducedFrom), new System.Func<IronRuby.Builtins.RubyClass, Microsoft.Scripting.Math.BigInteger, System.Int16>(IronRuby.Builtins.Int16Ops.InducedFrom), new System.Func<IronRuby.Builtins.RubyClass, System.Double, System.Int16>(IronRuby.Builtins.Int16Ops.InducedFrom) ); - ExtendClass(typeof(System.Int64), def45, LoadSystem__Int64_Instance, LoadSystem__Int64_Class, null, IronRuby.Builtins.RubyModule.EmptyArray, + ExtendClass(typeof(System.Int64), def46, LoadSystem__Int64_Instance, LoadSystem__Int64_Class, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, System.Int32, System.Int64>(IronRuby.Builtins.Int64Ops.InducedFrom), new System.Func<IronRuby.Builtins.RubyClass, Microsoft.Scripting.Math.BigInteger, System.Int64>(IronRuby.Builtins.Int64Ops.InducedFrom), new System.Func<IronRuby.Builtins.RubyClass, System.Double, System.Int64>(IronRuby.Builtins.Int64Ops.InducedFrom) ); - ExtendClass(typeof(System.SByte), def45, LoadSystem__SByte_Instance, LoadSystem__SByte_Class, null, IronRuby.Builtins.RubyModule.EmptyArray, + ExtendClass(typeof(System.SByte), def46, LoadSystem__SByte_Instance, LoadSystem__SByte_Class, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, System.Int32, System.SByte>(IronRuby.Builtins.SByteOps.InducedFrom), new System.Func<IronRuby.Builtins.RubyClass, Microsoft.Scripting.Math.BigInteger, System.SByte>(IronRuby.Builtins.SByteOps.InducedFrom), new System.Func<IronRuby.Builtins.RubyClass, System.Double, System.SByte>(IronRuby.Builtins.SByteOps.InducedFrom) ); - ExtendClass(typeof(System.UInt16), def45, LoadSystem__UInt16_Instance, LoadSystem__UInt16_Class, null, IronRuby.Builtins.RubyModule.EmptyArray, + ExtendClass(typeof(System.UInt16), def46, LoadSystem__UInt16_Instance, LoadSystem__UInt16_Class, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, System.Int32, System.UInt16>(IronRuby.Builtins.UInt16Ops.InducedFrom), new System.Func<IronRuby.Builtins.RubyClass, Microsoft.Scripting.Math.BigInteger, System.UInt16>(IronRuby.Builtins.UInt16Ops.InducedFrom), new System.Func<IronRuby.Builtins.RubyClass, System.Double, System.UInt16>(IronRuby.Builtins.UInt16Ops.InducedFrom) ); - ExtendClass(typeof(System.UInt32), def45, LoadSystem__UInt32_Instance, LoadSystem__UInt32_Class, null, IronRuby.Builtins.RubyModule.EmptyArray, + ExtendClass(typeof(System.UInt32), def46, LoadSystem__UInt32_Instance, LoadSystem__UInt32_Class, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, System.Int32, System.UInt32>(IronRuby.Builtins.UInt32Ops.InducedFrom), new System.Func<IronRuby.Builtins.RubyClass, Microsoft.Scripting.Math.BigInteger, System.UInt32>(IronRuby.Builtins.UInt32Ops.InducedFrom), new System.Func<IronRuby.Builtins.RubyClass, System.Double, System.UInt32>(IronRuby.Builtins.UInt32Ops.InducedFrom) ); - ExtendClass(typeof(System.UInt64), def45, LoadSystem__UInt64_Instance, LoadSystem__UInt64_Class, null, IronRuby.Builtins.RubyModule.EmptyArray, + ExtendClass(typeof(System.UInt64), def46, LoadSystem__UInt64_Instance, LoadSystem__UInt64_Class, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, System.Int32, System.UInt64>(IronRuby.Builtins.UInt64Ops.InducedFrom), new System.Func<IronRuby.Builtins.RubyClass, Microsoft.Scripting.Math.BigInteger, System.UInt64>(IronRuby.Builtins.UInt64Ops.InducedFrom), new System.Func<IronRuby.Builtins.RubyClass, System.Double, System.UInt64>(IronRuby.Builtins.UInt64Ops.InducedFrom) ); - IronRuby.Builtins.RubyClass def36 = DefineGlobalClass("SystemCallError", typeof(System.Runtime.InteropServices.ExternalException), 0x00000003, def34, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + IronRuby.Builtins.RubyClass def37 = DefineGlobalClass("SystemCallError", typeof(System.Runtime.InteropServices.ExternalException), 0x00000003, def35, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString, System.Runtime.InteropServices.ExternalException>(IronRuby.Builtins.SystemCallErrorOps.Factory), new System.Func<IronRuby.Builtins.RubyClass, System.Int32, System.Runtime.InteropServices.ExternalException>(IronRuby.Builtins.SystemCallErrorOps.Factory) ); - DefineGlobalClass("SystemStackError", typeof(IronRuby.Builtins.SystemStackError), 0x00000003, def34, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("SystemStackError", typeof(IronRuby.Builtins.SystemStackError), 0x00000003, def35, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__SystemStackError)); - DefineGlobalClass("ThreadError", typeof(IronRuby.Builtins.ThreadError), 0x00000103, def34, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("ThreadError", typeof(IronRuby.Builtins.ThreadError), 0x00000103, def35, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__ThreadError)); - DefineGlobalClass("TypeError", typeof(System.InvalidOperationException), 0x00000003, def34, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("TypeError", typeof(System.InvalidOperationException), 0x00000003, def35, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__TypeError)); - DefineGlobalClass("ZeroDivisionError", typeof(System.DivideByZeroException), 0x00000003, def34, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("ZeroDivisionError", typeof(System.DivideByZeroException), 0x00000003, def35, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__ZeroDivisionError)); - DefineGlobalClass("EOFError", typeof(IronRuby.Builtins.EOFError), 0x00000103, def35, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("EOFError", typeof(IronRuby.Builtins.EOFError), 0x00000103, def36, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__EOFError)); - IronRuby.Builtins.RubyClass def32 = DefineClass("Errno::EACCES", typeof(System.UnauthorizedAccessException), 0x00000003, def36, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + IronRuby.Builtins.RubyClass def33 = DefineClass("Errno::EACCES", typeof(System.UnauthorizedAccessException), 0x00000003, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString, System.UnauthorizedAccessException>(IronRuby.Builtins.Errno.UnauthorizedAccessExceptionOps.Create) ); - IronRuby.Builtins.RubyClass def9 = DefineClass("Errno::EADDRINUSE", typeof(IronRuby.Builtins.Errno.AddressInUseError), 0x00000103, def36, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); - IronRuby.Builtins.RubyClass def10 = DefineClass("Errno::EBADF", typeof(IronRuby.Builtins.Errno.BadFileDescriptorError), 0x00000103, def36, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); - IronRuby.Builtins.RubyClass def11 = DefineClass("Errno::ECHILD", typeof(IronRuby.Builtins.Errno.ChildError), 0x00000103, def36, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); - IronRuby.Builtins.RubyClass def12 = DefineClass("Errno::ECONNABORTED", typeof(IronRuby.Builtins.Errno.ConnectionAbortError), 0x00000103, def36, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); - IronRuby.Builtins.RubyClass def13 = DefineClass("Errno::ECONNREFUSED", typeof(IronRuby.Builtins.Errno.ConnectionRefusedError), 0x00000103, def36, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); - IronRuby.Builtins.RubyClass def14 = DefineClass("Errno::ECONNRESET", typeof(IronRuby.Builtins.Errno.ConnectionResetError), 0x00000103, def36, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); - IronRuby.Builtins.RubyClass def15 = DefineClass("Errno::EDOM", typeof(IronRuby.Builtins.Errno.DomainError), 0x00000103, def36, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); - IronRuby.Builtins.RubyClass def19 = DefineClass("Errno::EEXIST", typeof(IronRuby.Builtins.ExistError), 0x00000003, def36, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + IronRuby.Builtins.RubyClass def9 = DefineClass("Errno::EADDRINUSE", typeof(IronRuby.Builtins.Errno.AddressInUseError), 0x00000103, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); + IronRuby.Builtins.RubyClass def10 = DefineClass("Errno::EBADF", typeof(IronRuby.Builtins.Errno.BadFileDescriptorError), 0x00000103, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); + IronRuby.Builtins.RubyClass def11 = DefineClass("Errno::ECHILD", typeof(IronRuby.Builtins.Errno.ChildError), 0x00000103, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); + IronRuby.Builtins.RubyClass def12 = DefineClass("Errno::ECONNABORTED", typeof(IronRuby.Builtins.Errno.ConnectionAbortError), 0x00000103, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); + IronRuby.Builtins.RubyClass def13 = DefineClass("Errno::ECONNREFUSED", typeof(IronRuby.Builtins.Errno.ConnectionRefusedError), 0x00000103, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); + IronRuby.Builtins.RubyClass def14 = DefineClass("Errno::ECONNRESET", typeof(IronRuby.Builtins.Errno.ConnectionResetError), 0x00000103, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); + IronRuby.Builtins.RubyClass def15 = DefineClass("Errno::EDOM", typeof(IronRuby.Builtins.Errno.DomainError), 0x00000103, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); + IronRuby.Builtins.RubyClass def19 = DefineClass("Errno::EEXIST", typeof(IronRuby.Builtins.ExistError), 0x00000003, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString, IronRuby.Builtins.ExistError>(IronRuby.Builtins.Errno.ExistErrorOps.Create) ); - IronRuby.Builtins.RubyClass def21 = DefineClass("Errno::EINVAL", typeof(IronRuby.Builtins.InvalidError), 0x00000003, def36, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + IronRuby.Builtins.RubyClass def21 = DefineClass("Errno::EINVAL", typeof(IronRuby.Builtins.InvalidError), 0x00000003, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString, IronRuby.Builtins.InvalidError>(IronRuby.Builtins.Errno.InvalidErrorOps.Create) ); - IronRuby.Builtins.RubyClass def30 = DefineClass("Errno::ENOENT", typeof(System.IO.FileNotFoundException), 0x00000003, def36, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + IronRuby.Builtins.RubyClass def31 = DefineClass("Errno::ENOENT", typeof(System.IO.FileNotFoundException), 0x00000003, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString, System.IO.FileNotFoundException>(IronRuby.Builtins.Errno.FileNotFoundExceptionOps.Create) ); - IronRuby.Builtins.RubyClass def17 = DefineClass("Errno::ENOTCONN", typeof(IronRuby.Builtins.Errno.NotConnectedError), 0x00000103, def36, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); - IronRuby.Builtins.RubyClass def29 = DefineClass("Errno::ENOTDIR", typeof(System.IO.DirectoryNotFoundException), 0x00000003, def36, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + IronRuby.Builtins.RubyClass def17 = DefineClass("Errno::ENOTCONN", typeof(IronRuby.Builtins.Errno.NotConnectedError), 0x00000103, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); + IronRuby.Builtins.RubyClass def30 = DefineClass("Errno::ENOTDIR", typeof(System.IO.DirectoryNotFoundException), 0x00000003, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, IronRuby.Builtins.MutableString, System.IO.DirectoryNotFoundException>(IronRuby.Builtins.Errno.DirectoryNotFoundExceptionOps.Create) ); - IronRuby.Builtins.RubyClass def18 = DefineClass("Errno::EPIPE", typeof(IronRuby.Builtins.Errno.PipeError), 0x00000103, def36, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); - IronRuby.Builtins.RubyClass def16 = DefineClass("Errno::EXDEV", typeof(IronRuby.Builtins.Errno.ImproperLinkError), 0x00000103, def36, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); - DefineGlobalClass("ESPIPE", typeof(IronRuby.Builtins.InvalidSeekError), 0x00000103, def36, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); - DefineGlobalClass("FloatDomainError", typeof(IronRuby.Builtins.FloatDomainError), 0x00000103, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + IronRuby.Builtins.RubyClass def18 = DefineClass("Errno::EPIPE", typeof(IronRuby.Builtins.Errno.PipeError), 0x00000103, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); + IronRuby.Builtins.RubyClass def16 = DefineClass("Errno::EXDEV", typeof(IronRuby.Builtins.Errno.ImproperLinkError), 0x00000103, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); + DefineGlobalClass("ESPIPE", typeof(IronRuby.Builtins.InvalidSeekError), 0x00000103, def37, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray); + DefineGlobalClass("FloatDomainError", typeof(IronRuby.Builtins.FloatDomainError), 0x00000103, def38, null, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__FloatDomainError)); - DefineGlobalClass("NoMethodError", typeof(System.MissingMethodException), 0x00000003, def46, LoadNoMethodError_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray, + DefineGlobalClass("NoMethodError", typeof(System.MissingMethodException), 0x00000003, def47, LoadNoMethodError_Instance, null, null, IronRuby.Builtins.RubyModule.EmptyArray, new System.Func<IronRuby.Builtins.RubyClass, System.Object, System.Exception>(BuiltinsLibraryInitializer.ExceptionFactory__NoMethodError)); def24.SetBuiltinConstant("Constants", def25); def22.SetBuiltinConstant("Clr", def2); @@ -308,13 +309,14 @@ namespace IronRuby.Builtins { #endif Context.ObjectClass.SetBuiltinConstant("ENV", def7); #if !SILVERLIGHT - def24.SetBuiltinConstant("Stat", def31); + def24.SetBuiltinConstant("Stat", def32); #endif def2.SetBuiltinConstant("Name", def28); + def2.SetBuiltinConstant("Scope", def29); #if !SILVERLIGHT && !SILVERLIGHT def26.SetBuiltinConstant("Status", def27); #endif - def8.SetBuiltinConstant("EACCES", def32); + def8.SetBuiltinConstant("EACCES", def33); def8.SetBuiltinConstant("EADDRINUSE", def9); def8.SetBuiltinConstant("EBADF", def10); def8.SetBuiltinConstant("ECHILD", def11); @@ -324,9 +326,9 @@ namespace IronRuby.Builtins { def8.SetBuiltinConstant("EDOM", def15); def8.SetBuiltinConstant("EEXIST", def19); def8.SetBuiltinConstant("EINVAL", def21); - def8.SetBuiltinConstant("ENOENT", def30); + def8.SetBuiltinConstant("ENOENT", def31); def8.SetBuiltinConstant("ENOTCONN", def17); - def8.SetBuiltinConstant("ENOTDIR", def29); + def8.SetBuiltinConstant("ENOTDIR", def30); def8.SetBuiltinConstant("EPIPE", def18); def8.SetBuiltinConstant("EXDEV", def16); } @@ -1859,8 +1861,28 @@ namespace IronRuby.Builtins { } private static void LoadIronRuby_Class(IronRuby.Builtins.RubyModule/*!*/ module) { - module.DefineLibraryMethod("dlr_config", 0x61, - new System.Func<IronRuby.Runtime.RubyContext, System.Object, Microsoft.Scripting.Runtime.DlrConfiguration>(IronRuby.Builtins.IronRubyOps.GetCurrentRuntimeConfiguration) + module.DefineLibraryMethod("configuration", 0x61, + new System.Func<IronRuby.Runtime.RubyContext, IronRuby.Builtins.RubyModule, Microsoft.Scripting.Runtime.DlrConfiguration>(IronRuby.Builtins.IronRubyOps.GetConfiguration) + ); + + module.DefineLibraryMethod("globals", 0x61, + new System.Func<IronRuby.Runtime.RubyContext, IronRuby.Builtins.RubyModule, Microsoft.Scripting.Runtime.Scope>(IronRuby.Builtins.IronRubyOps.GetGlobalScope) + ); + + module.DefineLibraryMethod("load", 0x61, + new System.Func<IronRuby.Runtime.RubyScope, IronRuby.Builtins.RubyModule, IronRuby.Builtins.MutableString, System.Object>(IronRuby.Builtins.IronRubyOps.Load) + ); + + module.DefineLibraryMethod("loaded_assemblies", 0x61, + new System.Func<IronRuby.Runtime.RubyContext, IronRuby.Builtins.RubyModule, IronRuby.Builtins.RubyArray>(IronRuby.Builtins.IronRubyOps.GetLoadedAssemblies) + ); + + module.DefineLibraryMethod("loaded_scripts", 0x61, + new System.Func<IronRuby.Runtime.RubyContext, IronRuby.Builtins.RubyModule, System.Collections.Generic.IDictionary<System.String, Microsoft.Scripting.Runtime.Scope>>(IronRuby.Builtins.IronRubyOps.GetLoadedScripts) + ); + + module.DefineLibraryMethod("require", 0x61, + new System.Func<IronRuby.Runtime.RubyScope, IronRuby.Builtins.RubyModule, IronRuby.Builtins.MutableString, System.Object>(IronRuby.Builtins.IronRubyOps.Require) ); } @@ -1882,6 +1904,7 @@ namespace IronRuby.Builtins { module.DefineLibraryMethod("%", 0x51, new System.Func<Microsoft.Scripting.Math.BigInteger, Microsoft.Scripting.Math.BigInteger, System.Object>(IronRuby.Builtins.ClrBigInteger.Modulo), + new System.Func<Microsoft.Scripting.Math.BigInteger, System.Double, System.Object>(IronRuby.Builtins.ClrBigInteger.Modulo), new System.Func<IronRuby.Runtime.BinaryOpStorage, IronRuby.Runtime.BinaryOpStorage, System.Object, System.Object, System.Object>(IronRuby.Builtins.ClrBigInteger.ModuloOp) ); @@ -1906,7 +1929,7 @@ namespace IronRuby.Builtins { module.DefineLibraryMethod("/", 0x51, new System.Func<Microsoft.Scripting.Math.BigInteger, Microsoft.Scripting.Math.BigInteger, System.Object>(IronRuby.Builtins.ClrBigInteger.Divide), - new System.Func<Microsoft.Scripting.Math.BigInteger, System.Double, System.Object>(IronRuby.Builtins.ClrBigInteger.Divide), + new System.Func<Microsoft.Scripting.Math.BigInteger, System.Double, System.Object>(IronRuby.Builtins.ClrBigInteger.DivideOp), new System.Func<IronRuby.Runtime.BinaryOpStorage, IronRuby.Runtime.BinaryOpStorage, System.Object, System.Object, System.Object>(IronRuby.Builtins.ClrBigInteger.Divide) ); @@ -1982,6 +2005,7 @@ namespace IronRuby.Builtins { module.DefineLibraryMethod("divmod", 0x51, new System.Func<Microsoft.Scripting.Math.BigInteger, Microsoft.Scripting.Math.BigInteger, IronRuby.Builtins.RubyArray>(IronRuby.Builtins.ClrBigInteger.DivMod), + new System.Func<Microsoft.Scripting.Math.BigInteger, System.Double, IronRuby.Builtins.RubyArray>(IronRuby.Builtins.ClrBigInteger.DivMod), new System.Func<IronRuby.Runtime.BinaryOpStorage, IronRuby.Runtime.BinaryOpStorage, System.Object, System.Object, System.Object>(IronRuby.Builtins.ClrBigInteger.DivMod) ); @@ -1997,6 +2021,7 @@ namespace IronRuby.Builtins { module.DefineLibraryMethod("modulo", 0x51, new System.Func<Microsoft.Scripting.Math.BigInteger, Microsoft.Scripting.Math.BigInteger, System.Object>(IronRuby.Builtins.ClrBigInteger.Modulo), + new System.Func<Microsoft.Scripting.Math.BigInteger, System.Double, System.Object>(IronRuby.Builtins.ClrBigInteger.Modulo), new System.Func<IronRuby.Runtime.BinaryOpStorage, IronRuby.Runtime.BinaryOpStorage, System.Object, System.Object, System.Object>(IronRuby.Builtins.ClrBigInteger.Modulo) ); @@ -2008,6 +2033,7 @@ namespace IronRuby.Builtins { module.DefineLibraryMethod("remainder", 0x51, new System.Func<Microsoft.Scripting.Math.BigInteger, Microsoft.Scripting.Math.BigInteger, System.Object>(IronRuby.Builtins.ClrBigInteger.Remainder), + new System.Func<Microsoft.Scripting.Math.BigInteger, System.Double, System.Double>(IronRuby.Builtins.ClrBigInteger.Remainder), new System.Func<IronRuby.Runtime.BinaryOpStorage, IronRuby.Runtime.BinaryOpStorage, System.Object, System.Object, System.Object>(IronRuby.Builtins.ClrBigInteger.Remainder) ); @@ -2017,7 +2043,7 @@ namespace IronRuby.Builtins { module.DefineLibraryMethod("to_s", 0x51, new System.Func<Microsoft.Scripting.Math.BigInteger, IronRuby.Builtins.MutableString>(IronRuby.Builtins.ClrBigInteger.ToString), - new System.Func<Microsoft.Scripting.Math.BigInteger, System.UInt32, IronRuby.Builtins.MutableString>(IronRuby.Builtins.ClrBigInteger.ToString) + new System.Func<Microsoft.Scripting.Math.BigInteger, System.Int32, IronRuby.Builtins.MutableString>(IronRuby.Builtins.ClrBigInteger.ToString) ); } @@ -2417,6 +2443,32 @@ namespace IronRuby.Builtins { } + private static void LoadIronRuby__Clr__Name_Class(IronRuby.Builtins.RubyModule/*!*/ module) { + module.DefineLibraryMethod("clr_to_ruby", 0x61, + new System.Func<IronRuby.Builtins.RubyClass, System.String, IronRuby.Builtins.MutableString>(IronRuby.Builtins.ClrNameOps.Mangle) + ); + + module.DefineLibraryMethod("mangle", 0x61, + new System.Func<IronRuby.Builtins.RubyClass, System.String, IronRuby.Builtins.MutableString>(IronRuby.Builtins.ClrNameOps.Mangle) + ); + + module.DefineLibraryMethod("ruby_to_clr", 0x61, + new System.Func<IronRuby.Builtins.RubyClass, System.String, IronRuby.Builtins.MutableString>(IronRuby.Builtins.ClrNameOps.Unmangle) + ); + + module.DefineLibraryMethod("unmangle", 0x61, + new System.Func<IronRuby.Builtins.RubyClass, System.String, IronRuby.Builtins.MutableString>(IronRuby.Builtins.ClrNameOps.Unmangle) + ); + + } + + private static void LoadIronRuby__Clr__Scope_Instance(IronRuby.Builtins.RubyModule/*!*/ module) { + module.DefineLibraryMethod("method_missing", 0x52, + new System.Func<IronRuby.Runtime.RubyScope, IronRuby.Runtime.BlockParam, Microsoft.Scripting.Runtime.Scope, Microsoft.Scripting.SymbolId, System.Object[], System.Object>(IronRuby.Builtins.ScopeOps.MethodMissing) + ); + + } + private static void LoadIronRuby__Clr__String_Instance(IronRuby.Builtins.RubyModule/*!*/ module) { module.DefineLibraryMethod("%", 0x51, new System.Func<IronRuby.Builtins.StringFormatterSiteStorage, System.String, System.Object, System.String>(IronRuby.Builtins.ClrString.Format) @@ -2944,8 +2996,8 @@ namespace IronRuby.Builtins { #if !SILVERLIGHT module.DefineLibraryMethod("trap", 0x52, - new System.Func<IronRuby.Runtime.RubyContext, System.Object, System.Object, IronRuby.Builtins.Proc, System.Object>(IronRuby.Builtins.KernelOps.Trap), - new System.Func<IronRuby.Runtime.RubyContext, IronRuby.Runtime.BlockParam, System.Object, System.Object, System.Object>(IronRuby.Builtins.KernelOps.Trap) + new System.Func<IronRuby.Runtime.RubyContext, IronRuby.Runtime.BlockParam, System.Object, System.Object, System.Object>(IronRuby.Builtins.KernelOps.Trap), + new System.Func<IronRuby.Runtime.RubyContext, System.Object, System.Object, IronRuby.Builtins.Proc, System.Object>(IronRuby.Builtins.KernelOps.Trap) ); #endif @@ -3179,8 +3231,8 @@ namespace IronRuby.Builtins { #if !SILVERLIGHT module.DefineLibraryMethod("trap", 0x61, - new System.Func<IronRuby.Runtime.RubyContext, System.Object, System.Object, IronRuby.Builtins.Proc, System.Object>(IronRuby.Builtins.KernelOps.Trap), - new System.Func<IronRuby.Runtime.RubyContext, IronRuby.Runtime.BlockParam, System.Object, System.Object, System.Object>(IronRuby.Builtins.KernelOps.Trap) + new System.Func<IronRuby.Runtime.RubyContext, IronRuby.Runtime.BlockParam, System.Object, System.Object, System.Object>(IronRuby.Builtins.KernelOps.Trap), + new System.Func<IronRuby.Runtime.RubyContext, System.Object, System.Object, IronRuby.Builtins.Proc, System.Object>(IronRuby.Builtins.KernelOps.Trap) ); #endif @@ -5419,6 +5471,10 @@ namespace IronRuby.Builtins { new System.Func<IronRuby.Runtime.ConversionStorage<System.Int32>, IronRuby.Runtime.CallSiteStorage<System.Func<System.Runtime.CompilerServices.CallSite, IronRuby.Builtins.RubyClass, System.Object>>, System.Collections.IList, System.Object[], IronRuby.Builtins.RubyArray>(IronRuby.Builtins.IListOps.ValuesAt) ); + module.DefineLibraryMethod("zip", 0x51, + new System.Func<IronRuby.Runtime.CallSiteStorage<System.Func<System.Runtime.CompilerServices.CallSite, System.Object, IronRuby.Builtins.Proc, System.Object>>, IronRuby.Runtime.ConversionStorage<System.Collections.IList>, IronRuby.Runtime.BlockParam, System.Object, System.Collections.IList[], System.Collections.IList>(IronRuby.Builtins.IListOps.Zip) + ); + } private static void LoadSystem__IComparable_Instance(IronRuby.Builtins.RubyModule/*!*/ module) { Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Initializers.Generated.cs Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/IronRuby.Libraries.Build.csproj @@ -2,7 +2,7 @@ <PropertyGroup> <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> - <ProductVersion>9.0.21022</ProductVersion> + <ProductVersion>9.0.30729</ProductVersion> <SchemaVersion>2.0</SchemaVersion> <ProjectGuid>{77323B06-15A2-4CF4-8A7A-86EAA2B66498}</ProjectGuid> <OutputType>Library</OutputType> @@ -132,6 +132,7 @@ <Compile Include="Extensions\IListOps.cs" /> <Compile Include="Extensions\IronRubyOps.cs" /> <Compile Include="Extensions\MultiDimensionalArrayOps.cs" /> + <Compile Include="Extensions\ScopeOps.cs" /> <Compile Include="Extensions\SingleOps.cs" /> <Compile Include="Extensions\TypeGroupOps.cs" /> <Compile Include="Extensions\TypeOps.cs" /> Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/IronRuby.Libraries.csproj @@ -122,17 +122,11 @@ namespace IronRuby.StandardLibrary.OpenSsl { return MutableString.Create(""); } - var result = new StringBuilder(length); - byte[] data = new byte[length]; var generator = new Crypto.RNGCryptoServiceProvider(); generator.GetBytes(data); - for (int i = 0; i < length; i++) { - result.Append(Convert.ToChar(data[i])); - } - - return MutableString.Create(result.ToString()); + return MutableString.CreateBinary(data); } // add(str, entropy) -> self Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/OpenSSL/OpenSSL.cs @@ -107,7 +107,7 @@ namespace IronRuby.StandardLibrary.StringIO { return; } - self.Data.String.SetByte((int)(offset - 1), (byte)ch); + self.Data.String.SetByte((int)(offset - 1), unchecked((byte)ch)); self.Data.Seek(-1, System.IO.SeekOrigin.Current); } Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/StringIO/StringIO.cs @@ -49,10 +49,15 @@ namespace IronRuby.StandardLibrary.Sockets { } public override void Flush() { + if (_internalWriteBuffer.Count == 0) { + return; + } + byte[] bufferedData = _internalWriteBuffer.ToArray(); int bytesSent = _socket.Send(bufferedData); if (bytesSent < bufferedData.Length) { // TODO: Resend the rest + System.Diagnostics.Debug.Assert(false, "Partial data sent"); } _internalWriteBuffer.Clear(); } @@ -119,6 +124,7 @@ namespace IronRuby.StandardLibrary.Sockets { Flush(); } } + Flush(); } } } Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/socket/SocketStream.cs @@ -17,28 +17,24 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "IronRuby.Libraries", "Libra EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.Scripting", "..\..\Runtime\Microsoft.Scripting\Microsoft.Scripting.csproj", "{EB66B766-6354-4208-A3D4-AACBDCB5C3B3}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "IronRuby.Libraries.Yaml", "..\..\..\External.LCA_RESTRICTED\Languages\IronRuby\Yaml\IronRuby.Libraries.Yaml\IronRuby.Libraries.Yaml.csproj", "{AA18A245-E342-4368-A474-83178311A742}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "IronRuby.Libraries.Yaml", "..\..\..\External.LCA_RESTRICTED\Languages\IronRuby\yaml\IronRuby.Libraries.Yaml\IronRuby.Libraries.Yaml.csproj", "{AA18A245-E342-4368-A474-83178311A742}" EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.Scripting.ExtensionAttribute", "..\..\..\..\ndp\fx\src\Core\Microsoft\Scripting\Microsoft.Scripting.ExtensionAttribute.csproj", "{8B0F1074-750E-4D64-BF23-A1E0F54261E5}" EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{A6B6A5B5-335A-4515-8535-954DE8A953EF}" ProjectSection(SolutionItems) = preProject Scripts\CodeGenerator.rb = Scripts\CodeGenerator.rb - RubyCodeCoverage.testrunconfig = RubyCodeCoverage.testrunconfig - RubyCodeCoverage.vsmdi = RubyCodeCoverage.vsmdi EndProjectSection EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "RubySpec", "Tests\RubySpec\RubySpec.csproj", "{534A82C6-3EB0-4888-ABD2-A15284683E8D}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "IronRuby.Tests.VS", "IronRuby.Tests.VS\IronRuby.Tests.VS.csproj", "{7FE874FB-A5C8-4EE6-A725-472CFA16BE7E}" -EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Ruby.ConsoleAny", "Console\Ruby.ConsoleAny.csproj", "{6EE7A428-D803-41BC-8248-1297C3ACE369}" EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.Scripting.Debugging", "..\..\Debugging\Microsoft.Scripting.Debugging\Microsoft.Scripting.Debugging.csproj", "{ED82A346-1CD9-4CB0-9C00-4CDD4CF577CF}" EndProject Global GlobalSection(TeamFoundationVersionControl) = preSolution - SccNumberOfProjects = 15 + SccNumberOfProjects = 14 SccEnterpriseProvider = {4CA58AB2-18FA-4F8D-95D4-32DDF27D184C} SccTeamFoundationServer = http://vstfdevdiv:8080/ SccLocalPath0 = . @@ -75,18 +71,12 @@ Global SccProjectUniqueName11 = ..\\..\\..\\..\\ndp\\fx\\src\\Dynamic\\System\\Dynamic\\Microsoft.Dynamic.csproj SccProjectName11 = ../../../../ndp/fx/src/Dynamic/System/Dynamic SccLocalPath11 = ..\\..\\..\\..\\ndp\\fx\\src\\Dynamic\\System\\Dynamic - SccProjectUniqueName12 = IronRuby.Tests.VS\\IronRuby.Tests.VS.csproj - SccProjectName12 = IronRuby.Tests.VS - SccLocalPath12 = IronRuby.Tests.VS - SccProjectUniqueName13 = Console\\Ruby.ConsoleAny.csproj - SccProjectName13 = Console - SccLocalPath13 = Console - SccProjectUniqueName14 = ..\\..\\Debugging\\Microsoft.Scripting.Debugging\\Microsoft.Scripting.Debugging.csproj - SccProjectName14 = ../../Debugging/Microsoft.Scripting.Debugging - SccLocalPath14 = ..\\..\\Debugging\\Microsoft.Scripting.Debugging - EndGlobalSection - GlobalSection(TestCaseManagementSettings) = postSolution - CategoryFile = RubyCodeCoverage.vsmdi + SccProjectUniqueName12 = Console\\Ruby.ConsoleAny.csproj + SccProjectName12 = Console + SccLocalPath12 = Console + SccProjectUniqueName13 = ..\\..\\Debugging\\Microsoft.Scripting.Debugging\\Microsoft.Scripting.Debugging.csproj + SccProjectName13 = ../../Debugging/Microsoft.Scripting.Debugging + SccLocalPath13 = ..\\..\\Debugging\\Microsoft.Scripting.Debugging EndGlobalSection GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -191,14 +181,6 @@ Global {534A82C6-3EB0-4888-ABD2-A15284683E8D}.Release|Any CPU.ActiveCfg = Release|Any CPU {534A82C6-3EB0-4888-ABD2-A15284683E8D}.Silverlight Debug|Any CPU.ActiveCfg = Debug|Any CPU {534A82C6-3EB0-4888-ABD2-A15284683E8D}.Silverlight Release|Any CPU.ActiveCfg = Release|Any CPU - {7FE874FB-A5C8-4EE6-A725-472CFA16BE7E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {7FE874FB-A5C8-4EE6-A725-472CFA16BE7E}.Debug|Any CPU.Build.0 = Debug|Any CPU - {7FE874FB-A5C8-4EE6-A725-472CFA16BE7E}.FxCop|Any CPU.ActiveCfg = Release|Any CPU - {7FE874FB-A5C8-4EE6-A725-472CFA16BE7E}.FxCop|Any CPU.Build.0 = Release|Any CPU - {7FE874FB-A5C8-4EE6-A725-472CFA16BE7E}.Release|Any CPU.ActiveCfg = Release|Any CPU - {7FE874FB-A5C8-4EE6-A725-472CFA16BE7E}.Release|Any CPU.Build.0 = Release|Any CPU - {7FE874FB-A5C8-4EE6-A725-472CFA16BE7E}.Silverlight Debug|Any CPU.ActiveCfg = Debug|Any CPU - {7FE874FB-A5C8-4EE6-A725-472CFA16BE7E}.Silverlight Release|Any CPU.ActiveCfg = Release|Any CPU {6EE7A428-D803-41BC-8248-1297C3ACE369}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {6EE7A428-D803-41BC-8248-1297C3ACE369}.Debug|Any CPU.Build.0 = Debug|Any CPU {6EE7A428-D803-41BC-8248-1297C3ACE369}.FxCop|Any CPU.ActiveCfg = Release|Any CPU Merlin/Main/Languages/Ruby/Ruby.sln @@ -35,11 +35,6 @@ using Microsoft.Scripting.Generation; namespace IronRuby.Builtins { public sealed partial class RubyClass : RubyModule, IDuplicable { - /// <summary> - /// Visibility context within which all methods are visible. - /// </summary> - public const RubyClass IgnoreVisibility = null; - public const string/*!*/ ClassSingletonName = "__ClassSingleton"; public const string/*!*/ ClassSingletonSingletonName = "__ClassSingletonSingleton"; public const string/*!*/ MainSingletonName = "__MainSingleton"; @@ -641,7 +636,7 @@ namespace IronRuby.Builtins { internal RubyMemberInfo ResolveMethodMissingForSite(string/*!*/ name, RubyMethodVisibility incompatibleVisibility) { Context.RequiresClassHierarchyLock(); - var methodMissing = ResolveMethodForSiteNoLock(Symbols.MethodMissing, null); + var methodMissing = ResolveMethodForSiteNoLock(Symbols.MethodMissing, VisibilityContext.AllVisible); if (incompatibleVisibility == RubyMethodVisibility.None) { methodMissing.InvalidateSitesOnMissingMethodAddition(name, Context); } @@ -1158,7 +1153,6 @@ namespace IronRuby.Builtins { #endregion - #region Dynamic operations /// <summary> @@ -1208,7 +1202,7 @@ namespace IronRuby.Builtins { // check version of the class so that we invalidate the rule whenever the initializer changes: metaBuilder.AddVersionTest(this); - initializer = ResolveMethodForSiteNoLock(Symbols.Initialize, IgnoreVisibility).Info; + initializer = ResolveMethodForSiteNoLock(Symbols.Initialize, VisibilityContext.AllVisible).Info; // Initializer resolves to Object#initializer unless overridden in a derived class. // We ensure that this method cannot be removed. @@ -1293,8 +1287,11 @@ namespace IronRuby.Builtins { } else { // TODO: we need more refactoring of RubyMethodGroupInfo.BuildCall to be able to inline this: metaBuilder.Result = Ast.Dynamic( - RubyCallAction.Make(args.RubyContext, "initialize", - new RubyCallSignature(args.Signature.ArgumentCount, args.Signature.Flags | RubyCallFlags.HasImplicitSelf) + RubyCallAction.Make(args.RubyContext, "initialize", + new RubyCallSignature( + args.Signature.ArgumentCount, + (args.Signature.Flags & ~RubyCallFlags.IsInteropCall) | RubyCallFlags.HasImplicitSelf + ) ), typeof(object), args.GetCallSiteArguments(instanceVariable) Merlin/Main/Languages/Ruby/Ruby/Builtins/RubyClass.cs @@ -382,7 +382,7 @@ namespace IronRuby.Builtins { ContractUtils.RequiresNotNull(encoding, "encoding"); if (encoding == BinaryEncoding.Instance) { return Binary; - } else if (encoding.ToString() == Encoding.UTF8.ToString()) { + } else if (encoding.ToString() == Encoding.UTF8.ToString()) { return UTF8; } else { throw new ArgumentException(String.Format("Unknown encoding: '{0}'", encoding)); Merlin/Main/Languages/Ruby/Ruby/Builtins/RubyEncoding.cs @@ -72,6 +72,7 @@ namespace IronRuby.Builtins { #if DEBUG [DebuggerDisplay("{DebugName}")] #endif + [DebuggerTypeProxy(typeof(RubyModule.DebugView))] public partial class RubyModule : IDuplicable, IRubyObject { [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2105:ArrayFieldsShouldNotBeReadOnly")] public static readonly RubyModule[]/*!*/ EmptyArray = new RubyModule[0]; @@ -1109,8 +1110,8 @@ namespace IronRuby.Builtins { SymbolId symbol = SymbolTable.StringToId(name); using (Context.ClassHierarchyUnlocker()) { - return _context.TopGlobalScope.TryGetName(symbol, out value) - && _context.TopGlobalScope.TryRemoveName(symbol); + return _context.TopGlobalScope.TryGetVariable(symbol, out value) + && _context.TopGlobalScope.TryRemoveVariable(symbol); } } @@ -1215,7 +1216,7 @@ namespace IronRuby.Builtins { RubyMemberInfo method; using (Context.ClassHierarchyLocker()) { // MRI: aliases a super-forwarder not the real method. - method = ResolveMethodNoLock(oldName, RubyClass.IgnoreVisibility, MethodLookup.FallbackToObject | MethodLookup.ReturnForwarder).Info; + method = ResolveMethodNoLock(oldName, VisibilityContext.AllVisible, MethodLookup.FallbackToObject | MethodLookup.ReturnForwarder).Info; if (method == null) { throw RubyExceptions.CreateUndefinedMethodError(this, oldName); } @@ -1496,32 +1497,32 @@ namespace IronRuby.Builtins { } // thread-safe: - public MethodResolutionResult ResolveMethodForSite(string/*!*/ name, RubyClass visibilityContext) { + public MethodResolutionResult ResolveMethodForSite(string/*!*/ name, VisibilityContext visibility) { using (Context.ClassHierarchyLocker()) { - return ResolveMethodForSiteNoLock(name, visibilityContext); + return ResolveMethodForSiteNoLock(name, visibility); } } // thread-safe: - public MethodResolutionResult ResolveMethod(string/*!*/ name, RubyClass visibilityContext) { + public MethodResolutionResult ResolveMethod(string/*!*/ name, VisibilityContext visibility) { using (Context.ClassHierarchyLocker()) { - return ResolveMethodNoLock(name, visibilityContext); + return ResolveMethodNoLock(name, visibility); } } - public MethodResolutionResult ResolveMethodForSiteNoLock(string/*!*/ name, RubyClass visibilityContext) { - return ResolveMethodForSiteNoLock(name, visibilityContext, MethodLookup.Default); + public MethodResolutionResult ResolveMethodForSiteNoLock(string/*!*/ name, VisibilityContext visibility) { + return ResolveMethodForSiteNoLock(name, visibility, MethodLookup.Default); } - internal MethodResolutionResult ResolveMethodForSiteNoLock(string/*!*/ name, RubyClass visibilityContext, MethodLookup options) { - return ResolveMethodNoLock(name, visibilityContext, options).InvalidateSitesOnOverride(); + internal MethodResolutionResult ResolveMethodForSiteNoLock(string/*!*/ name, VisibilityContext visibility, MethodLookup options) { + return ResolveMethodNoLock(name, visibility, options).InvalidateSitesOnOverride(); } - public MethodResolutionResult ResolveMethodNoLock(string/*!*/ name, RubyClass visibilityContext) { - return ResolveMethodNoLock(name, visibilityContext, MethodLookup.Default); + public MethodResolutionResult ResolveMethodNoLock(string/*!*/ name, VisibilityContext visibility) { + return ResolveMethodNoLock(name, visibility, MethodLookup.Default); } - public MethodResolutionResult ResolveMethodNoLock(string/*!*/ name, RubyClass visibilityContext, MethodLookup options) { + public MethodResolutionResult ResolveMethodNoLock(string/*!*/ name, VisibilityContext visibility, MethodLookup options) { Context.RequiresClassHierarchyLock(); Assert.NotNull(name); @@ -1534,12 +1535,12 @@ namespace IronRuby.Builtins { if (ForEachAncestor((module) => { owner = module; - foundCallerSelf |= module == visibilityContext; + foundCallerSelf |= module == visibility.Class; return module.TryGetMethod(name, ref skipHidden, (options & MethodLookup.Virtual) != 0, out info); })) { if (info == null || info.IsUndefined) { result = MethodResolutionResult.NotFound; - } else if (!IsMethodVisible(info, owner, visibilityContext, foundCallerSelf)) { + } else if (!IsMethodVisible(info, owner, visibility, foundCallerSelf)) { result = new MethodResolutionResult(info, owner, false); } else if (info.IsSuperForwarder) { if ((options & MethodLookup.ReturnForwarder) != 0) { @@ -1557,16 +1558,18 @@ namespace IronRuby.Builtins { // Note: all classes include Object in ancestors, so we don't need to search it again: if (!result.Found && (options & MethodLookup.FallbackToObject) != 0 && !IsClass) { - return _context.ObjectClass.ResolveMethodNoLock(name, visibilityContext, options & ~MethodLookup.FallbackToObject); + return _context.ObjectClass.ResolveMethodNoLock(name, visibility, options & ~MethodLookup.FallbackToObject); } return result; } - private bool IsMethodVisible(RubyMemberInfo/*!*/ method, RubyModule/*!*/ owner, RubyClass visibilityContext, bool foundCallerSelf) { - // call with implicit self => all methods are visible - if (visibilityContext == RubyClass.IgnoreVisibility) { - return true; + private bool IsMethodVisible(RubyMemberInfo/*!*/ method, RubyModule/*!*/ owner, VisibilityContext visibility, bool foundCallerSelf) { + // Visibility not constrained by a class: + // - call with implicit self => all methods are visible. + // - interop call => only public methods are visible. + if (visibility.Class == null) { + return visibility.IsVisible(method.Visibility); } if (method.Visibility == RubyMethodVisibility.Protected) { @@ -1576,7 +1579,7 @@ namespace IronRuby.Builtins { } // walk ancestors from caller's self class (visibilityContext) // until the method owner is found or this module is found (this module is a descendant of the owner): - return visibilityContext.ForEachAncestor((module) => module == owner || module == this); + return visibility.Class.ForEachAncestor((module) => module == owner || module == this); } return method.Visibility == RubyMethodVisibility.Public; @@ -1639,7 +1642,7 @@ namespace IronRuby.Builtins { if (virtualLookup) { string mangled; - if ((mangled = RubyUtils.MangleName(name)) != name && TryGetDefinedMethod(mangled, ref skipHidden, out method) + if ((mangled = RubyUtils.TryMangleName(name)) != null && TryGetDefinedMethod(mangled, ref skipHidden, out method) && method.IsRubyMember) { return true; } @@ -2111,5 +2114,103 @@ namespace IronRuby.Builtins { } #endregion + + #region Debug View + + // see: RubyObject.DebuggerDisplayValue + internal string/*!*/ GetDebuggerDisplayValue(object obj) { + return Context.Inspect(obj).ConvertToString(); + } + + // see: RubyObject.DebuggerDisplayType + internal string/*!*/ GetDebuggerDisplayType() { + return Name; + } + + internal sealed class DebugView { + private readonly RubyModule/*!*/ _obj; + + public DebugView(RubyModule/*!*/ obj) { + Assert.NotNull(obj); + _obj = obj; + } + + #region RubyObjectDebugView + + [DebuggerDisplay("{GetModuleName(A),nq}", Name = "{GetClassKind(),nq}", Type = "")] + public object A { + get { return _obj.ImmediateClass; } + } + + [DebuggerDisplay("{B}", Name = "tainted?", Type = "")] + public bool B { + get { return _obj.IsTainted; } + set { _obj.IsTainted = value; } + } + + [DebuggerDisplay("{C}", Name = "frozen?", Type = "")] + public bool C { + get { return _obj.IsFrozen; } + set { if (value) { _obj.Freeze(); } } + } + + [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)] + public object D { + get { + var instanceData = _obj.TryGetInstanceData(); + if (instanceData == null) { + return new RubyInstanceData.VariableDebugView[0]; + } + + return instanceData.GetInstanceVariablesDebugView(_obj.ImmediateClass.Context); + } + } + + private string GetClassKind() { + return _obj.ImmediateClass.IsSingletonClass ? "singleton class" : "class"; + } + + private static string GetModuleName(object module) { + var m = (RubyModule)module; + return m != null ? m.GetDisplayName(m.Context, false).ToString() : String.Empty; + } + + #endregion + + [DebuggerDisplay("{GetModuleName(E),nq}", Name = "super", Type = "")] + public object E { + get { return _obj.GetSuperClass(); } + } + + [DebuggerDisplay("", Name = "mixins", Type = "")] + public object F { + get { return _obj.GetMixins(); } + } + + [DebuggerDisplay("", Name = "instance methods", Type = "")] + public object G { + get { return GetMethods(RubyMethodAttributes.Instance); } + } + + [DebuggerDisplay("", Name = "singleton methods", Type = "")] + public object H { + get { return GetMethods(RubyMethodAttributes.Singleton); } + } + + private Dictionary<string, RubyMemberInfo> GetMethods(RubyMethodAttributes attributes) { + // TODO: custom view for methods, sorted + var result = new Dictionary<string, RubyMemberInfo>(); + using (_obj.Context.ClassHierarchyLocker()) { + _obj.ForEachMember(false, attributes | RubyMethodAttributes.VisibilityMask, (name, _, info) => { + result[name] = info; + }); + } + return result; + } + + // TODO: class variables + } + + #endregion } } Merlin/Main/Languages/Ruby/Ruby/Builtins/RubyModule.cs @@ -13,15 +13,13 @@ * * ***************************************************************************/ +using System.Diagnostics; using System.Runtime.Serialization; -using Microsoft.Scripting.Actions; -using Microsoft.Scripting.Runtime; -using Microsoft.Scripting.Utils; -using IronRuby.Runtime; -using IronRuby.Runtime.Calls; using System.Security.Permissions; using IronRuby.Compiler.Generation; -using System.Diagnostics; +using IronRuby.Runtime; +using IronRuby.Runtime.Calls; +using Microsoft.Scripting.Utils; namespace IronRuby.Builtins { /// <summary> @@ -29,8 +27,14 @@ namespace IronRuby.Builtins { /// /// Note that for classes that inherit from some other class, RubyTypeDispenser gets used /// </summary> - [DebuggerDisplay("{Inspect().ConvertToString()}")] + [DebuggerTypeProxy(typeof(RubyObjectDebugView))] + [DebuggerDisplay(RubyObject.DebuggerDisplayValue, Type = RubyObject.DebuggerDisplayType)] public partial class RubyObject : IRubyObject, IDuplicable, ISerializable { + internal const string ImmediateClassFieldName = "_immediateClass"; + internal const string InstanceDataFieldName = "_instanceData"; + internal const string DebuggerDisplayValue = "{" + ImmediateClassFieldName + ".GetDebuggerDisplayValue(this),nq}"; + internal const string DebuggerDisplayType = "{" + ImmediateClassFieldName + ".GetDebuggerDisplayType(),nq}"; + private RubyInstanceData _instanceData; private RubyClass/*!*/ _immediateClass; @@ -93,17 +97,6 @@ namespace IronRuby.Builtins { return _immediateClass.Context.Inspect(this); } -#if !SILVERLIGHT - protected RubyObject(SerializationInfo/*!*/ info, StreamingContext context) { - RubyOps.DeserializeObject(out _instanceData, out _immediateClass, info); - } - - [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.SerializationFormatter)] - public virtual void GetObjectData(SerializationInfo/*!*/ info, StreamingContext context) { - RubyOps.SerializeObject(_instanceData, _immediateClass, info); - } -#endif - protected virtual RubyObject/*!*/ CreateInstance() { return new RubyObject(_immediateClass.NominalClass); } @@ -144,5 +137,16 @@ namespace IronRuby.Builtins { } #endregion + +#if !SILVERLIGHT + protected RubyObject(SerializationInfo/*!*/ info, StreamingContext context) { + RubyOps.DeserializeObject(out _instanceData, out _immediateClass, info); + } + + [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.SerializationFormatter)] + public virtual void GetObjectData(SerializationInfo/*!*/ info, StreamingContext context) { + RubyOps.SerializeObject(_instanceData, _immediateClass, info); + } +#endif } } Merlin/Main/Languages/Ruby/Ruby/Builtins/RubyObject.cs @@ -34,6 +34,8 @@ namespace IronRuby.Builtins { end #else public partial class /*$Class{*/Hash/*}*/ { + [DebuggerTypeProxy(typeof(RubyObjectDebugView))] + [DebuggerDisplay(RubyObject.DebuggerDisplayValue, Type = RubyObject.DebuggerDisplayType)] public sealed partial class Subclass : /*$Class{*/Hash/*}*/, IRubyObject { private RubyInstanceData _instanceData; private RubyClass/*!*/ _immediateClass; @@ -83,6 +85,8 @@ namespace IronRuby.Builtins { #endif #region Generated by Subclasses.Generator.rb public partial class MatchData { + [DebuggerTypeProxy(typeof(RubyObjectDebugView))] + [DebuggerDisplay(RubyObject.DebuggerDisplayValue, Type = RubyObject.DebuggerDisplayType)] public sealed partial class Subclass : MatchData, IRubyObject { private RubyInstanceData _instanceData; private RubyClass/*!*/ _immediateClass; @@ -130,6 +134,8 @@ namespace IronRuby.Builtins { } } public partial class Proc { + [DebuggerTypeProxy(typeof(RubyObjectDebugView))] + [DebuggerDisplay(RubyObject.DebuggerDisplayValue, Type = RubyObject.DebuggerDisplayType)] public sealed partial class Subclass : Proc, IRubyObject { private RubyInstanceData _instanceData; private RubyClass/*!*/ _immediateClass; @@ -177,6 +183,8 @@ namespace IronRuby.Builtins { } } public partial class Range { + [DebuggerTypeProxy(typeof(RubyObjectDebugView))] + [DebuggerDisplay(RubyObject.DebuggerDisplayValue, Type = RubyObject.DebuggerDisplayType)] public sealed partial class Subclass : Range, IRubyObject { private RubyInstanceData _instanceData; private RubyClass/*!*/ _immediateClass; @@ -224,6 +232,8 @@ namespace IronRuby.Builtins { } } public partial class RubyRegex { + [DebuggerTypeProxy(typeof(RubyObjectDebugView))] + [DebuggerDisplay(RubyObject.DebuggerDisplayValue, Type = RubyObject.DebuggerDisplayType)] public sealed partial class Subclass : RubyRegex, IRubyObject { private RubyInstanceData _instanceData; private RubyClass/*!*/ _immediateClass; @@ -287,6 +297,8 @@ namespace IronRuby.Builtins { end #else public partial class /*$Class{*/MutableString/*}*/ { + [DebuggerTypeProxy(typeof(RubyObjectDebugView))] + [DebuggerDisplay(RubyObject.DebuggerDisplayValue, Type = RubyObject.DebuggerDisplayType)] public sealed partial class Subclass : /*$Class{*/MutableString/*}*/, IRubyObject { private RubyInstanceData _instanceData; private RubyClass/*!*/ _immediateClass; @@ -323,6 +335,8 @@ namespace IronRuby.Builtins { #endif #region Generated by Subclasses.Generator.rb public partial class RubyArray { + [DebuggerTypeProxy(typeof(RubyObjectDebugView))] + [DebuggerDisplay(RubyObject.DebuggerDisplayValue, Type = RubyObject.DebuggerDisplayType)] public sealed partial class Subclass : RubyArray, IRubyObject { private RubyInstanceData _instanceData; private RubyClass/*!*/ _immediateClass; Merlin/Main/Languages/Ruby/Ruby/Builtins/Subclasses.Generated.cs @@ -69,8 +69,8 @@ namespace IronRuby.Compiler.Generation { internal RubyTypeBuilder(TypeBuilder/*!*/ tb) { _tb = tb; - _immediateClassField = _tb.DefineField("_immediateClass", typeof(RubyClass), FieldAttributes.Private); - _instanceDataField = _tb.DefineField("_instanceData", typeof(RubyInstanceData), FieldAttributes.Private); + _immediateClassField = _tb.DefineField(RubyObject.ImmediateClassFieldName, typeof(RubyClass), FieldAttributes.Private); + _instanceDataField = _tb.DefineField(RubyObject.InstanceDataFieldName, typeof(RubyInstanceData), FieldAttributes.Private); } public void Implement(ClsTypeEmitter/*!*/ emitter) { @@ -286,6 +286,18 @@ namespace IronRuby.Compiler.Generation { private void DefineRubyObjectImplementation() { _tb.AddInterfaceImplementation(typeof(IRubyObject)); + _tb.SetCustomAttribute(new CustomAttributeBuilder( + typeof(DebuggerTypeProxyAttribute).GetConstructor(new[] { typeof(Type) }), + new[] { typeof(RubyObjectDebugView) } + )); + + _tb.SetCustomAttribute(new CustomAttributeBuilder( + typeof(DebuggerDisplayAttribute).GetConstructor(new[] { typeof(string) }), + new[] { RubyObject.DebuggerDisplayValue }, + new[] { typeof(DebuggerDisplayAttribute).GetProperty("Type") }, + new[] { RubyObject.DebuggerDisplayType } + )); + ILGen il; // RubyClass! IRubyObject.ImmediateClass { get { return _immediateClassField; } } Merlin/Main/Languages/Ruby/Ruby/Compiler/Generation/RubyTypeBuilder.cs @@ -508,7 +508,7 @@ namespace IronRuby.Compiler { public static string/*!*/ TerminalToString(int terminal) { Debug.Assert(terminal >= 0); if (((Tokens)terminal).ToString() != terminal.ToString()) { - return IronRuby.Runtime.RubyUtils.MangleName(((Tokens)terminal).ToString()).ToUpper(); + return IronRuby.Runtime.RubyUtils.TryMangleName(((Tokens)terminal).ToString()).ToUpper(); } else { return CharToString((char)terminal); } Merlin/Main/Languages/Ruby/Ruby/Compiler/Parser/Parser.cs @@ -67,7 +67,7 @@ namespace IronRuby.Hosting { protected override Scope/*!*/ CreateScope() { Scope scope = base.CreateScope(); - scope.SetName(SymbolTable.StringToId("iron_ruby"), Engine); + scope.SetVariable(SymbolTable.StringToId("iron_ruby"), Engine); return scope; } Merlin/Main/Languages/Ruby/Ruby/Hosting/RubyCommandLine.cs Merlin/Main/Languages/Ruby/Ruby/Ruby.Build.csproj @@ -2,7 +2,7 @@ <PropertyGroup> <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> - <ProductVersion>9.0.21022</ProductVersion> + <ProductVersion>9.0.30729</ProductVersion> <SchemaVersion>2.0</SchemaVersion> <ProjectGuid>{7F6984B4-EE6D-4E6F-ABB1-E210D7DC4FDD}</ProjectGuid> <OutputType>Library</OutputType> @@ -131,6 +131,7 @@ <Compile Include="Builtins\RubyArray.Subclass.cs" /> <Compile Include="Builtins\RubyEvent.cs" /> <Compile Include="Builtins\RubyIO.cs" /> + <Compile Include="Builtins\RubyObjectDebugView.cs" /> <Compile Include="Builtins\RubyRegex.Subclass.cs" /> <Compile Include="Builtins\MutableString.Content.cs"> <SubType>Code</SubType> @@ -192,6 +193,7 @@ <Compile Include="Runtime\Calls\RubyOverloadResolver.cs" /> <Compile Include="Runtime\Calls\SuperForwarderInfo.cs" /> <Compile Include="Runtime\Calls\VersionHandle.cs" /> + <Compile Include="Runtime\Calls\VisibilityContext.cs" /> <Compile Include="Runtime\CheckedMonitor.cs" /> <Compile Include="Runtime\ClrName.cs" /> <Compile Include="Runtime\CustomTypeDescHelpers.cs" /> Merlin/Main/Languages/Ruby/Ruby/Ruby.csproj @@ -78,7 +78,7 @@ namespace IronRuby.Runtime.Calls { new[] { ToS, Symbols.MethodMissing } ); - conversionMethod = targetClass.ResolveMethodForSiteNoLock(ToS, RubyClass.IgnoreVisibility).Info; + conversionMethod = targetClass.ResolveMethodForSiteNoLock(ToS, VisibilityContext.AllVisible).Info; // find method_missing - we need to add "to_xxx" methods to the missing methods table: if (conversionMethod == null) { Merlin/Main/Languages/Ruby/Ruby/Runtime/Calls/ConvertToSAction.cs @@ -248,7 +248,7 @@ namespace IronRuby.Runtime.Calls { Func<DynamicMetaObject, DynamicMetaObject[], DynamicMetaObject>/*!*/ fallback) { Debug.Assert(fallback != null); - var callArgs = new CallArguments(context, target, args, RubyCallSignature.WithImplicitSelf(callInfo.ArgumentCount)); + var callArgs = new CallArguments(context, target, args, RubyCallSignature.Interop(callInfo.ArgumentCount)); var metaBuilder = new MetaObjectBuilder(target, args); if (!RubyCallAction.BuildCall(metaBuilder, methodName, callArgs, false, false)) { @@ -301,7 +301,7 @@ namespace IronRuby.Runtime.Calls { Func<DynamicMetaObject, DynamicMetaObject>/*!*/ fallback) { Debug.Assert(fallback != null); - var callArgs = new CallArguments(context, target, DynamicMetaObject.EmptyMetaObjects, RubyCallSignature.WithImplicitSelf(0)); + var callArgs = new CallArguments(context, target, DynamicMetaObject.EmptyMetaObjects, RubyCallSignature.Interop(0)); var metaBuilder = new MetaObjectBuilder(target); if (!RubyCallAction.BuildAccess(metaBuilder, binder.Name, callArgs, false, false)) { @@ -357,7 +357,7 @@ namespace IronRuby.Runtime.Calls { Debug.Assert(fallback != null); var args = new[] { value }; - var callArgs = new CallArguments(context, target, args, RubyCallSignature.WithImplicitSelf(1)); + var callArgs = new CallArguments(context, target, args, RubyCallSignature.Interop(1)); var metaBuilder = new MetaObjectBuilder(target, args); if (!RubyCallAction.BuildCall(metaBuilder, binder.Name + "=", callArgs, false, false)) { @@ -414,7 +414,7 @@ namespace IronRuby.Runtime.Calls { Func<DynamicMetaObject, DynamicMetaObject[], DynamicMetaObject>/*!*/ fallback) { Debug.Assert(fallback != null); - var callArgs = new CallArguments(context, target, indexes, RubyCallSignature.WithImplicitSelf(indexes.Length)); + var callArgs = new CallArguments(context, target, indexes, RubyCallSignature.Interop(indexes.Length)); var metaBuilder = new MetaObjectBuilder(target, indexes); if (!RubyCallAction.BuildCall(metaBuilder, "[]", callArgs, false, false)) { @@ -472,7 +472,7 @@ namespace IronRuby.Runtime.Calls { var args = ArrayUtils.Append(indexes, value); var callArgs = new CallArguments(context, target, args, - new RubyCallSignature(indexes.Length, RubyCallFlags.HasImplicitSelf | RubyCallFlags.HasRhsArgument) + new RubyCallSignature(indexes.Length, RubyCallFlags.IsInteropCall | RubyCallFlags.HasRhsArgument) ); var metaBuilder = new MetaObjectBuilder(target, args); Merlin/Main/Languages/Ruby/Ruby/Runtime/Calls/InteropBinder.cs @@ -27,6 +27,7 @@ using Microsoft.Scripting.Utils; using Ast = System.Linq.Expressions.Expression; using AstUtils = Microsoft.Scripting.Ast.Utils; using System.Collections; +using Microsoft.Scripting.Generation; namespace IronRuby.Runtime.Calls { public sealed class MetaObjectBuilder { @@ -210,10 +211,37 @@ namespace IronRuby.Runtime.Calls { if (value == null) { return Ast.Equal(expression, AstUtils.Constant(null)); } else { - return RuleBuilder.MakeTypeTestExpression(value.GetType(), expression); + return MakeTypeTestExpression(value.GetType(), expression); } } + public static Expression MakeTypeTestExpression(Type t, Expression expr) { + // we must always check for non-sealed types explicitly - otherwise we end up + // doing fast-path behavior on a subtype which overrides behavior that wasn't + // present for the base type. + //TODO there's a question about nulls here + if (CompilerHelpers.IsSealed(t) && t == expr.Type) { + if (t.IsValueType) { + return AstUtils.Constant(true); + } + return Ast.NotEqual(expr, AstUtils.Constant(null)); + } + + return Ast.AndAlso( + Ast.NotEqual( + expr, + AstUtils.Constant(null)), + Ast.Equal( + Ast.Call( + AstUtils.Convert(expr, typeof(object)), + typeof(object).GetMethod("GetType") + ), + AstUtils.Constant(t) + ) + ); + } + + public void AddObjectTypeCondition(object value, Expression/*!*/ expression) { AddCondition(GetObjectTypeTestExpression(value, expression)); } Merlin/Main/Languages/Ruby/Ruby/Runtime/Calls/MetaObjectBuilder.cs @@ -193,20 +193,20 @@ namespace IronRuby.Runtime.Calls { ); // we can optimize if Kernel#respond_to? method is not overridden: - respondToMethod = targetClass.ResolveMethodForSiteNoLock(Symbols.RespondTo, RubyClass.IgnoreVisibility); + respondToMethod = targetClass.ResolveMethodForSiteNoLock(Symbols.RespondTo, VisibilityContext.AllVisible); if (respondToMethod.Found && respondToMethod.Info.DeclaringModule == targetClass.Context.KernelModule && respondToMethod.Info is RubyLibraryMethodInfo) { // TODO: better override detection respondToMethod = MethodResolutionResult.NotFound; // get the first applicable conversion: foreach (var conversion in conversions) { selectedConversion = conversion; - conversionMethod = targetClass.ResolveMethodForSiteNoLock(conversion.ToMethodName, RubyClass.IgnoreVisibility).Info; + conversionMethod = targetClass.ResolveMethodForSiteNoLock(conversion.ToMethodName, VisibilityContext.AllVisible).Info; if (conversionMethod != null) { break; } else { // find method_missing - we need to add "to_xxx" methods to the missing methods table: if (!methodMissing.Found) { - methodMissing = targetClass.ResolveMethodNoLock(Symbols.MethodMissing, RubyClass.IgnoreVisibility); + methodMissing = targetClass.ResolveMethodNoLock(Symbols.MethodMissing, VisibilityContext.AllVisible); } methodMissing.InvalidateSitesOnMissingMethodAddition(conversion.ToMethodName, targetClass.Context); } Merlin/Main/Languages/Ruby/Ruby/Runtime/Calls/ProtocolConversionAction.cs @@ -41,7 +41,7 @@ namespace IronRuby.Runtime.Calls { #region Conversions - public override Expression ConvertExpression(Expression expr, Type toType, ConversionResultKind kind, Expression context) { + public override Expression ConvertExpression(Expression expr, Type toType, ConversionResultKind kind, OverloadResolverFactory context) { throw new InvalidOperationException("OBSOLETE"); } Merlin/Main/Languages/Ruby/Ruby/Runtime/Calls/RubyBinder.cs @@ -187,23 +187,25 @@ namespace IronRuby.Runtime.Calls { } } - private static RubyClass GetVisibilityContext(RubyCallSignature callSignature, RubyScope scope) { - // TODO: All sites should have either implicit-self or has-scope flag set? - return callSignature.HasImplicitSelf || !callSignature.HasScope ? RubyClass.IgnoreVisibility : scope.SelfImmediateClass; + private static VisibilityContext GetVisibilityContext(RubyCallSignature callSignature, RubyScope scope) { + return callSignature.HasImplicitSelf || !callSignature.HasScope ? + new VisibilityContext(callSignature.IsInteropCall ? RubyMethodAttributes.Public : RubyMethodAttributes.VisibilityMask) : + new VisibilityContext(scope.SelfImmediateClass); } internal static MethodResolutionResult Resolve(MetaObjectBuilder/*!*/ metaBuilder, string/*!*/ methodName, CallArguments/*!*/ args, out RubyMemberInfo methodMissing) { MethodResolutionResult method; - RubyClass targetClass = args.TargetClass; + var targetClass = args.TargetClass; + var visibilityContext = GetVisibilityContext(args.Signature, args.Scope); using (targetClass.Context.ClassHierarchyLocker()) { metaBuilder.AddTargetTypeTest(args.Target, targetClass, args.TargetExpression, args.MetaContext, new[] { methodName, Symbols.MethodMissing } ); var options = args.Signature.IsVirtualCall ? MethodLookup.Virtual : MethodLookup.Default; - method = targetClass.ResolveMethodForSiteNoLock(methodName, GetVisibilityContext(args.Signature, args.Scope), options); + method = targetClass.ResolveMethodForSiteNoLock(methodName, visibilityContext, options); if (!method.Found) { methodMissing = targetClass.ResolveMethodMissingForSite(methodName, method.IncompatibleVisibility); } else { @@ -212,12 +214,12 @@ namespace IronRuby.Runtime.Calls { } // Whenever the current self's class changes we need to invalidate the rule, if a protected method is being called. - if (method.Info != null && method.Info.IsProtected && !args.Signature.HasImplicitSelf) { + if (method.Info != null && method.Info.IsProtected && visibilityContext.Class != null) { // We don't need to compare versions, just the class objects (super-class relationship cannot be changed). // Since we don't want to hold on a class object (to make it collectible) we compare references to the version handlers. metaBuilder.AddCondition(Ast.Equal( Methods.GetSelfClassVersionHandle.OpCall(AstUtils.Convert(args.MetaScope.Expression, typeof(RubyScope))), - Ast.Constant(args.Scope.SelfImmediateClass.Version) + Ast.Constant(visibilityContext.Class.Version) )); } Merlin/Main/Languages/Ruby/Ruby/Runtime/Calls/RubyCallAction.cs @@ -35,16 +35,19 @@ namespace IronRuby.Runtime.Calls { // Used for private visibility check. By default method call sites have explicit self, so private methods are not visible. HasImplicitSelf = 16, + // Interop calls can only see Ruby-public members. + IsInteropCall = 32, + // If the resolved method is a Ruby method call it otherwise invoke #base# method on target's type. // Used in method overrides defined in types emitted for Ruby classes that derive from CLR type. - IsVirtualCall = 32, + IsVirtualCall = 64, } /// <summary> /// RubyScope/RubyContext, (self), (argument){ArgumentCount}, (splatted-argument)?, (block)? /// </summary> public struct RubyCallSignature : IEquatable<RubyCallSignature> { - private const int FlagsCount = 6; + private const int FlagsCount = 7; private const int MaxArgumentCount = (int)(UInt32.MaxValue >> FlagsCount); private const RubyCallFlags FlagsMask = (RubyCallFlags)(1 << FlagsCount) - 1; @@ -55,6 +58,7 @@ namespace IronRuby.Runtime.Calls { public bool HasBlock { get { return ((RubyCallFlags)_countAndFlags & RubyCallFlags.HasBlock) != 0; } } public bool HasSplattedArgument { get { return ((RubyCallFlags)_countAndFlags & RubyCallFlags.HasSplattedArgument) != 0; } } public bool HasRhsArgument { get { return ((RubyCallFlags)_countAndFlags & RubyCallFlags.HasRhsArgument) != 0; } } + public bool IsInteropCall { get { return ((RubyCallFlags)_countAndFlags & RubyCallFlags.IsInteropCall) != 0; } } public bool IsVirtualCall { get { return ((RubyCallFlags)_countAndFlags & RubyCallFlags.IsVirtualCall) != 0; } } public int ArgumentCount { get { return (int)_countAndFlags >> FlagsCount; } } @@ -97,7 +101,7 @@ namespace IronRuby.Runtime.Calls { } internal static bool TryCreate(CallInfo callInfo, out RubyCallSignature callSignature) { - callSignature = Simple(callInfo.ArgumentCount); + callSignature = RubyCallSignature.Interop(callInfo.ArgumentCount); return callInfo.ArgumentNames.Count != 0; } @@ -109,6 +113,10 @@ namespace IronRuby.Runtime.Calls { return new RubyCallSignature(argumentCount, RubyCallFlags.None); } + public static RubyCallSignature Interop(int argumentCount) { + return new RubyCallSignature(argumentCount, RubyCallFlags.IsInteropCall); + } + public static RubyCallSignature WithBlock(int argumentCount) { return new RubyCallSignature(argumentCount, RubyCallFlags.HasBlock); } Merlin/Main/Languages/Ruby/Ruby/Runtime/Calls/RubyCallSignature.cs @@ -35,12 +35,16 @@ namespace IronRuby.Runtime { public string/*!*/ MangledName { get { if (_mangled == null) { - _mangled = RubyUtils.MangleName(_actual); + _mangled = RubyUtils.TryMangleName(_actual) ?? _actual; } return _mangled; } } + public bool HasMangledName { + get { return !ReferenceEquals(_actual, MangledName); } + } + public ClrName(string/*!*/ actualName) { ContractUtils.RequiresNotNull(actualName, "actualName"); _actual = actualName; Merlin/Main/Languages/Ruby/Ruby/Runtime/ClrName.cs @@ -26,6 +26,7 @@ namespace IronRuby.Runtime { } } + [Serializable] public class Key<T0, T1> : IEquatable<Key<T0, T1>> { public readonly T0/*!*/ First; public readonly T1/*!*/ Second; @@ -57,6 +58,7 @@ namespace IronRuby.Runtime { } } + [Serializable] public sealed class Key<T0, T1, T2> : Key<T0, T1>, IEquatable<Key<T0, T1, T2>> { public readonly T2/*!*/ Third; Merlin/Main/Languages/Ruby/Ruby/Runtime/Key.cs @@ -36,6 +36,7 @@ namespace IronRuby.Runtime { LoadOnce = 1, LoadIsolated = 2, AppendExtensions = 4, + ResolveLoaded = 8 } // TODO: thread safety @@ -58,7 +59,10 @@ namespace IronRuby.Runtime { private readonly RubyArray/*!*/ _loadedFiles; // files that were required but their execution haven't completed yet: - private readonly Stack<string>/*!*/ _unfinishedFiles; + private readonly Stack<string>/*!*/ _unfinishedFiles; + + // lazy init + private SynchronizedDictionary<string, Scope> _loadedScripts; // TODO: static // maps full normalized path to compiled code: @@ -97,6 +101,21 @@ namespace IronRuby.Runtime { get { return _loadedFiles; } } + /// <summary> + /// Contains all loaded foreign language scripts. Maps path to scope created for each loaded script. + /// A script is published here as soon as its scopr is created just before it is executed. + /// </summary> + public IDictionary<string, Scope>/*!*/ LoadedScripts { + get { + if (_loadedScripts == null) { + Interlocked.CompareExchange(ref _loadedScripts, + new SynchronizedDictionary<string, Scope>(new Dictionary<string, Scope>(DomainManager.Platform.PathComparer)), null + ); + } + return _loadedScripts; + } + } + private PlatformAdaptationLayer/*!*/ Platform { get { return DomainManager.Platform; } } @@ -104,7 +123,7 @@ namespace IronRuby.Runtime { private ScriptDomainManager/*!*/ DomainManager { get { return _context.DomainManager; } } - + internal Loader(RubyContext/*!*/ context) { Assert.NotNull(context); _context = context; @@ -231,10 +250,19 @@ namespace IronRuby.Runtime { } } + public bool LoadFile(Scope globalScope, object self, MutableString/*!*/ path, LoadFlags flags) { + object loaded; + return LoadFile(globalScope, self, path, flags, out loaded); + } + /// <summary> /// Returns <b>true</b> if a Ruby file is successfully loaded, <b>false</b> if it is already loaded. /// </summary> - public bool LoadFile(Scope globalScope, object self, MutableString/*!*/ path, LoadFlags flags) { + /// <param name="globalScope"> + /// A scope against which the file should be executed or null to create a new scope. + /// </param> + /// <returns>True if the file was loaded/executed by this call.</returns> + public bool LoadFile(Scope globalScope, object self, MutableString/*!*/ path, LoadFlags flags, out object loaded) { Assert.NotNull(path); string assemblyName, typeName; @@ -243,46 +271,69 @@ namespace IronRuby.Runtime { if (TryParseAssemblyName(strPath, out typeName, out assemblyName)) { if (AlreadyLoaded(path, flags)) { + loaded = ((flags & LoadFlags.ResolveLoaded) != 0) ? GetAssembly(assemblyName, true, false) : null; return false; } - if (LoadAssembly(assemblyName, typeName, false, false)) { + Assembly assembly = LoadAssembly(assemblyName, typeName, false, false); + if (assembly != null) { FileLoaded(path, flags); + loaded = assembly; return true; } } - return LoadFromPath(globalScope, self, strPath, flags); + return LoadFromPath(globalScope, self, strPath, flags, out loaded); } #region Assemblies + public Assembly LoadAssembly(string/*!*/ assemblyName, string typeName, bool throwOnError, bool tryPartialName) { + Assembly assembly = GetAssembly(assemblyName, throwOnError, tryPartialName); + return (assembly != null && LoadAssembly(assembly, typeName, throwOnError)) ? assembly : null; + } + [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2001:AvoidCallingProblematicMethods", MessageId = "System.Reflection.Assembly.LoadWithPartialName")] - public bool LoadAssembly(string/*!*/ assemblyName, string typeName, bool throwOnError, bool tryPartialName) { - Utils.Log(String.Format("Loading assembly '{0}' and type '{1}'", assemblyName, typeName), "LOADER"); - - Assembly assembly; - try { - try { - assembly = Platform.LoadAssembly(assemblyName); - } catch (FileNotFoundException) { + private Assembly GetAssembly(string/*!*/ assemblyName, bool throwOnError, bool tryPartialName) { #if SILVERLIGHT - throw; -#else - if (tryPartialName) { -#pragma warning disable 618,612 // csc, gmcs - assembly = Assembly.LoadWithPartialName(assemblyName); -#pragma warning restore 618,612 + tryPartialName = false; +#endif + try { + return Platform.LoadAssembly(assemblyName); + } catch (Exception e) { + if (!tryPartialName || !(e is FileNotFoundException)) { + if (throwOnError) { + throw new LoadError(e.Message, e); } else { - throw; + return null; } -#endif } - } catch (Exception e) { - if (throwOnError) throw new LoadError(e.Message, e); - return false; } +#if SILVERLIGHT + throw Assert.Unreachable; +#else +#pragma warning disable 618,612 // csc, gmcs + Assembly assembly; + try { + assembly = Assembly.LoadWithPartialName(assemblyName); + } catch (Exception e) { + if (throwOnError) { + throw new LoadError(e.Message, e); + } else { + return null; + } + } + if (assembly == null && throwOnError) { + throw new LoadError(String.Format("Assembly '{0}' not found", assemblyName)); + } +#pragma warning restore 618,612 + return assembly; +#endif + } + + private bool LoadAssembly(Assembly/*!*/ assembly, string typeName, bool throwOnError) { + Utils.Log(String.Format("Loading assembly '{0}' and type '{1}'", assembly, typeName), "LOADER"); Type initializerType; if (typeName != null) { // load Ruby library: @@ -411,7 +462,7 @@ namespace IronRuby.Runtime { } } - private bool LoadFromPath(Scope globalScope, object self, string/*!*/ path, LoadFlags flags) { + private bool LoadFromPath(Scope globalScope, object self, string/*!*/ path, LoadFlags flags, out object loaded) { Assert.NotNull(path); string[] sourceFileExtensions = DomainManager.Configuration.GetFileExtensions(); @@ -426,6 +477,20 @@ namespace IronRuby.Runtime { } if (AlreadyLoaded(pathWithExtension, flags) || _unfinishedFiles.Contains(pathWithExtension.ToString())) { + if ((flags & LoadFlags.ResolveLoaded) != 0) { + var fullPath = Platform.GetFullPath(file.Path); + if (file.SourceUnit != null) { + Scope loadedScope; + if (!LoadedScripts.TryGetValue(fullPath, out loadedScope)) { + throw new LoadError(String.Format("no such file to load -- {0}", file.Path)); + } + loaded = loadedScope; + } else { + loaded = Platform.LoadAssemblyFromPath(fullPath); + } + } else { + loaded = null; + } return false; } @@ -434,18 +499,19 @@ namespace IronRuby.Runtime { _unfinishedFiles.Push(pathWithExtension.ToString()); if (file.SourceUnit != null) { - - RubyContext rubySource = file.SourceUnit.LanguageContext as RubyContext; - if (rubySource != null) { - ExecuteRubySourceUnit(file.SourceUnit, globalScope, flags); + ScriptCode compiledCode; + if (file.SourceUnit.LanguageContext == _context) { + compiledCode = CompileRubySource(file.SourceUnit, flags); } else { - file.SourceUnit.Execute(); + compiledCode = file.SourceUnit.Compile(); } + loaded = Execute(globalScope, compiledCode); } else { Debug.Assert(file.Path != null); try { - Assembly asm = Platform.LoadAssemblyFromPath(Platform.GetFullPath(file.Path)); - DomainManager.LoadAssembly(asm); + Assembly assembly = Platform.LoadAssemblyFromPath(Platform.GetFullPath(file.Path)); + DomainManager.LoadAssembly(assembly); + loaded = assembly; } catch (Exception e) { throw new LoadError(e.Message, e); } @@ -459,7 +525,7 @@ namespace IronRuby.Runtime { return true; } - private void ExecuteRubySourceUnit(SourceUnit/*!*/ sourceUnit, Scope globalScope, LoadFlags flags) { + private ScriptCode/*!*/ CompileRubySource(SourceUnit/*!*/ sourceUnit, LoadFlags flags) { Assert.NotNull(sourceUnit); // TODO: check file timestamp @@ -467,11 +533,8 @@ namespace IronRuby.Runtime { CompiledFile compiledFile; if (TryGetCompiledFile(fullPath, out compiledFile)) { Utils.Log(String.Format("{0}: {1}", ++_cacheHitCount, sourceUnit.Path), "LOAD_CACHED"); - if (globalScope != null) { - compiledFile.CompiledCode.Run(globalScope); - } else { - compiledFile.CompiledCode.Run(); - } + + return compiledFile.CompiledCode; } else { Utils.Log(String.Format("{0}: {1}", ++_compiledFileCount, sourceUnit.Path), "LOAD_COMPILED"); @@ -486,12 +549,22 @@ namespace IronRuby.Runtime { AddCompiledFile(fullPath, compiledCode); - CompileAndRun(globalScope, compiledCode); + return compiledCode; } } - internal object CompileAndRun(Scope globalScope, ScriptCode/*!*/ code) { - return globalScope != null ? code.Run(globalScope) : code.Run(); + internal Scope Execute(Scope globalScope, ScriptCode/*!*/ code) { + if (globalScope == null || code.LanguageContext != _context) { + globalScope = code.CreateScope(); + if (code.SourceUnit.Path != null) { + LoadedScripts[Platform.GetFullPath(code.SourceUnit.Path)] = globalScope; + } + code.Run(globalScope); + return globalScope; + } else { + code.Run(globalScope); + return null; + } } private ResolvedFile FindFile(string/*!*/ path, bool appendExtensions, string[] sourceFileExtensions) { Merlin/Main/Languages/Ruby/Ruby/Runtime/Loader.cs @@ -47,8 +47,8 @@ namespace IronRuby.Runtime { public static readonly string/*!*/ MriReleaseDate = "2008-05-28"; // IronRuby: - public const string/*!*/ IronRubyVersionString = "0.6.0.0"; - public static readonly Version IronRubyVersion = new Version(0, 6, 0, 0); + public const string/*!*/ IronRubyVersionString = "0.9.0.0"; + public static readonly Version IronRubyVersion = new Version(0, 9, 0, 0); internal const string/*!*/ IronRubyDisplayName = "IronRuby"; internal const string/*!*/ IronRubyNames = "IronRuby;Ruby;rb"; internal const string/*!*/ IronRubyFileExtensions = ".rb"; @@ -535,11 +535,11 @@ namespace IronRuby.Runtime { } internal void SetGlobalConstant(string/*!*/ name, object value) { - _globalScope.SetName(SymbolTable.StringToId(name), value); + _globalScope.SetVariable(SymbolTable.StringToId(name), value); } internal bool TryGetGlobalConstant(string/*!*/ name, out object value) { - return _globalScope.TryGetName(SymbolTable.StringToId(name), out value); + return _globalScope.TryGetVariable(SymbolTable.StringToId(name), out value); } private void InitializeFileDescriptors(SharedIO/*!*/ io) { @@ -1237,12 +1237,12 @@ namespace IronRuby.Runtime { // thread-safe: public MethodResolutionResult ResolveMethod(object target, string/*!*/ name, bool includePrivate) { var owner = GetImmediateClassOf(target); - return owner.ResolveMethod(name, includePrivate ? RubyClass.IgnoreVisibility : owner); + return owner.ResolveMethod(name, includePrivate ? VisibilityContext.AllVisible : new VisibilityContext(owner)); } // thread-safe: - public MethodResolutionResult ResolveMethod(object target, string/*!*/ name, RubyClass visibilityContext) { - return GetImmediateClassOf(target).ResolveMethod(name, visibilityContext); + public MethodResolutionResult ResolveMethod(object target, string/*!*/ name, VisibilityContext visibility) { + return GetImmediateClassOf(target).ResolveMethod(name, visibility); } // thread-safe: Merlin/Main/Languages/Ruby/Ruby/Runtime/RubyContext.cs @@ -18,6 +18,8 @@ using Microsoft.Scripting; using System.Threading; using IronRuby.Builtins; using Microsoft.Scripting.Utils; +using System.Diagnostics; +using System; namespace IronRuby.Runtime { /// <summary> @@ -97,7 +99,7 @@ namespace IronRuby.Runtime { return _instanceVars; } - #region instance variable support + #region Instance Variables internal bool HasInstanceVariables { get { @@ -184,6 +186,62 @@ namespace IronRuby.Runtime { } } + internal VariableDebugView[]/*!*/ GetInstanceVariablesDebugView(RubyContext/*!*/ context) { + if (_instanceVars == null) { + return new RubyInstanceData.VariableDebugView[0]; + } + + var result = new List<VariableDebugView>(); + lock (_instanceVars) { + foreach (var var in _instanceVars) { + result.Add(new VariableDebugView(context, this, var.Key)); + } + } + + result.Sort((var1, var2) => var1._name.CompareTo(var2._name)); + return result.ToArray(); + } + + [DebuggerDisplay("{GetValue()}", Name = "{_name,nq}", Type = "{GetClassName(),nq}")] + public sealed class VariableDebugView { + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private readonly RubyContext/*!*/ _context; + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private readonly RubyInstanceData/*!*/ _data; + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + internal readonly string/*!*/ _name; + + [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)] + public object A { + get { return GetValue(); } + } + + [DebuggerDisplay("{B}", Name = "Raw Value", Type = "{GetClrType()}")] + public object B { + get { return GetValue(); } + set { _data.SetInstanceVariable(_name, value); } + } + + private object GetValue() { + return _data.GetInstanceVariable(_name); + } + + private Type GetClrType() { + var value = GetValue(); + return value != null ? value.GetType() : null; + } + + private string/*!*/ GetClassName() { + return _context.GetClassDisplayName(GetValue()); + } + + internal VariableDebugView(RubyContext/*!*/ context, RubyInstanceData/*!*/ data, string/*!*/ name) { + _context = context; + _data = data; + _name = name; + } + } + #endregion } } Merlin/Main/Languages/Ruby/Ruby/Runtime/RubyInstanceData.cs @@ -537,7 +537,7 @@ namespace IronRuby.Runtime { // expose RubyMethod in the scope (the method is bound to the main singleton instance): if (owner.GlobalScope != null) { - owner.GlobalScope.Scope.SetName( + owner.GlobalScope.Scope.SetVariable( SymbolTable.StringToId(method.DefinitionName), new RubyMethod(owner.GlobalScope.MainObject, method, method.DefinitionName) ); @@ -553,7 +553,7 @@ namespace IronRuby.Runtime { public static void UndefineMethod(RubyScope/*!*/ scope, string/*!*/ name) { RubyModule owner = scope.GetInnerMostModuleForMethodLookup(); - if (!owner.ResolveMethod(name, RubyClass.IgnoreVisibility).Found) { + if (!owner.ResolveMethod(name, VisibilityContext.AllVisible).Found) { throw RubyExceptions.CreateUndefinedMethodError(owner, name); } owner.UndefineMethod(name); @@ -563,7 +563,7 @@ namespace IronRuby.Runtime { public static bool IsDefinedMethod(object self, RubyScope/*!*/ scope, string/*!*/ name) { // MRI: this is different from UndefineMethod, it behaves like Kernel#method (i.e. doesn't use lexical scope): // TODO: visibility - return scope.RubyContext.ResolveMethod(self, name, RubyClass.IgnoreVisibility).Found; + return scope.RubyContext.ResolveMethod(self, name, VisibilityContext.AllVisible).Found; } #endregion Merlin/Main/Languages/Ruby/Ruby/Runtime/RubyOps.cs @@ -65,9 +65,7 @@ namespace IronRuby.Runtime { } } -#if !SILVERLIGHT [DebuggerTypeProxy(typeof(RubyScope.DebugView))] -#endif public abstract class RubyScope : RuntimeFlowControl { internal bool InLoop; internal bool InRescue; @@ -526,7 +524,6 @@ namespace IronRuby.Runtime { #endif } -#if !SILVERLIGHT internal sealed class DebugView { private readonly RubyScope/*!*/ _scope; [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields")] @@ -546,7 +543,7 @@ namespace IronRuby.Runtime { while (true) { foreach (var variable in scope.GetDeclaredLocalVariables()) { string name = SymbolTable.IdToString(variable.Key); - string className = _scope.RubyContext.GetImmediateClassOf(variable.Value).GetDisplayName(_scope.RubyContext, true).ConvertToString(); + string className = _scope.RubyContext.GetClassDisplayName(variable.Value); if (scope != _scope) { name += " (outer)"; } @@ -568,19 +565,19 @@ namespace IronRuby.Runtime { } [DebuggerDisplay("{B}", Name = "MethodAttributes", Type = "")] - public RubyMethodAttributes B { + public object B { get { return _scope._methodAttributes; } } [DebuggerDisplay("{C}", Name = "ParentScope", Type = "")] - public RubyScope C { + public object C { get { return (RubyScope)_scope.Parent; } } - [DebuggerDisplay("", Name = "RawVariables", Type = "")] - public System.Collections.Hashtable/*!*/ D { + [DebuggerDisplay("", Name = "Raw Variables", Type = "")] + public object D { get { - System.Collections.Hashtable result = new System.Collections.Hashtable(); + var result = new Dictionary<SymbolId, object>(); foreach (var variable in _scope.GetDeclaredLocalVariables()) { result.Add(variable.Key, variable.Value); } @@ -604,7 +601,6 @@ namespace IronRuby.Runtime { } } } -#endif #endregion } @@ -916,39 +912,58 @@ var closureScope = scope as RubyClosureScope; // "method_missing" on main singleton in DLR Scope bound code. // Might be called via a site -> needs to be public in partial trust. public static object TopMethodMissing(RubyScope/*!*/ localScope, BlockParam block, object/*!*/ self, SymbolId name, [NotNull]params object[]/*!*/ args) { - Assert.NotNull(localScope, self); - Debug.Assert(!localScope.IsEmpty); - Scope globalScope = localScope.GlobalScope.Scope; - Debug.Assert(globalScope != null); + return ScopeMethodMissing(localScope.RubyContext, localScope.GlobalScope.Scope, block, self, name, args); + } + + public static object ScopeMethodMissing(RubyContext/*!*/ context, Scope/*!*/ globalScope, BlockParam block, object self, SymbolId name, object[]/*!*/ args) { + Assert.NotNull(context, globalScope); + + string str = SymbolTable.IdToString(name); + if (str.LastCharacter() == '=') { + if (args.Length != 1) { + throw RubyOps.MakeWrongNumberOfArgumentsError(args.Length, 1); + } + + // Consider this case: + // There is {"Foo" -> 1} in the scope. + // x.foo += 1 + // Without name mangling this would result to {"Foo" -> 1, "foo" -> 2} while the expected result is {"Foo" -> 2}. - // TODO: error when arguments non-empty, block != null, ... + str = str.Substring(0, str.Length - 1); + name = SymbolTable.StringToId(str); + + if (!globalScope.ContainsVariable(name)) { + var unmangled = SymbolTable.StringToId(RubyUtils.TryUnmangleName(str)); + if (!unmangled.IsEmpty && globalScope.ContainsVariable(unmangled)) { + name = unmangled; + } + } + + var value = args[0]; + globalScope.SetVariable(name, value); + return value; + } else { + if (args.Length != 0) { + throw RubyOps.MakeWrongNumberOfArgumentsError(args.Length, 0); + } - if (args.Length == 0) { object value; - if (globalScope.TryGetName(name, out value)) { + if (globalScope.TryGetVariable(name, out value)) { return value; } - string str = SymbolTable.IdToString(name); string unmangled = RubyUtils.TryUnmangleName(str); - if (unmangled != null && globalScope.TryGetName(SymbolTable.StringToId(unmangled), out value)) { + if (unmangled != null && globalScope.TryGetVariable(SymbolTable.StringToId(unmangled), out value)) { return value; } - if (str == "scope") { + if (self != null && str == "scope") { return self; } - } else if (args.Length == 1) { - string str = SymbolTable.IdToString(name); - if (str.LastCharacter() == '=') { - SymbolId plainName = SymbolTable.StringToId(str.Substring(0, str.Length - 1)); - globalScope.SetName(plainName, args[0]); - return args[0]; - } } // TODO: call super - throw RubyExceptions.CreateMethodMissing(localScope.RubyContext, self, SymbolTable.IdToString(name)); + throw RubyExceptions.CreateMethodMissing(context, self, SymbolTable.IdToString(name)); } #endregion Merlin/Main/Languages/Ruby/Ruby/Runtime/RubyScope.cs @@ -16,6 +16,7 @@ using System; using System.Collections.Generic; using System.Diagnostics; +using System.IO; using System.Linq.Expressions; using System.Reflection; using System.Runtime.CompilerServices; @@ -188,67 +189,165 @@ namespace IronRuby.Runtime { #region Names - // Unmangles a method name. Not all names can be unmangled. - // For a name to be unmangle-able, it must be lower_case_with_underscores. - // If a name can't be unmangled, this function returns null + /// <summary> + /// Converts a Ruby name to PascalCase name (foo_bar -> FooBar). + /// Returns null if the name is not a well-formed Ruby name (it contains upper-case latter or subsequent underscores). + /// Characters that are not upper case letters are treated as lower-case letters. + /// </summary> public static string TryUnmangleName(string/*!*/ name) { - if (name.ToUpper().Equals("INITIALIZE")) { - // Special case for compatibility with CLR - return name; + ContractUtils.RequiresNotNull(name, "name"); + if (name.Length == 0) { + return null; } - StringBuilder sb = new StringBuilder(name.Length); - bool upcase = true; - foreach (char c in name) { - if (char.IsUpper(c)) { - // can't unmangle a name with uppercase letters + StringBuilder mangled = new StringBuilder(); + + bool lastWasSpecial = false; + int i = 0, j = 0; + while (i < name.Length) { + char c; + while (j < name.Length && (c = name[j]) != '_') { + if (Char.IsUpper(c)) { + return null; + } + j++; + } + + if (j == i || j == name.Length - 1) { return null; } - if (c == '_') { - if (upcase) { - // can't unmangle a name with consecutive or leading underscores + if (j - i == 1) { + // "ip_f_xxx" -/-> "IPFXxx" + if (lastWasSpecial) { return null; } - upcase = true; + mangled.Append(name[i].ToUpperInvariant()); + lastWasSpecial = false; } else { - if (upcase) { - sb.Append(char.ToUpper(c)); - upcase = false; + string special = MapSpecialWord(name, i, j - i); + if (special != null) { + // "ip_ip" -/-> "IPIP" + if (lastWasSpecial) { + return null; + } + mangled.Append(special.ToUpperInvariant()); + lastWasSpecial = true; } else { - sb.Append(c); + mangled.Append(name[i].ToUpperInvariant()); + mangled.Append(name, i + 1, j - i - 1); + lastWasSpecial = false; } } + + i = ++j; } - if (upcase) { - // string was empty or ended with an underscore, can't unmangle - return null; - } - return sb.ToString(); + + return mangled.ToString(); } - public static string/*!*/ MangleName(string/*!*/ name) { - Assert.NotNull(name); + /// <summary> + /// Converts a camelCase or PascalCase name to a Ruby name (FooBar -> foo_bar). + /// Returns null if the name is not in camelCase or PascalCase (FooBAR, foo, etc.). + /// Characters that are not upper case letters are treated as lower-case letters. + /// </summary> + public static string TryMangleName(string/*!*/ name) { + ContractUtils.RequiresNotNull(name, "name"); + StringBuilder mangled = null; + int i = 0; + while (i < name.Length) { + char c = name[i]; + if (Char.IsUpper(c)) { + int j = i + 1; + while (j < name.Length && Char.IsUpper(name, j)) { + j++; + } - if (name.ToUpper().Equals("INITIALIZE")) { - // Special case for compatibility with CLR - return name; - } + if (j < name.Length) { + j--; + } - StringBuilder result = new StringBuilder(name.Length); + if (mangled == null) { + mangled = new StringBuilder(); + mangled.Append(name, 0, i); + } - for (int i = 0; i < name.Length; i++) { - if (Char.IsUpper(name[i])) { - if (!(i == 0 || i + 1 < name.Length && Char.IsUpper(name[i + 1]) || i + 1 == name.Length && Char.IsUpper(name[i - 1]))) { - result.Append('_'); + if (i > 0) { + mangled.Append('_'); + } + + int count = j - i; + if (count == 0) { + // NaN{end}, NaNXxx + if (i + 2 < name.Length && + Char.IsUpper(name[i + 2]) && + (i + 3 == name.Length || Char.IsUpper(name[i + 3]) && + (i + 4 < name.Length && !Char.IsUpper(name[i + 4])))) { + return null; + } else { + // X{end}, In, NaN, Xml, Html, ... + mangled.Append(c.ToLowerInvariant()); + i++; + } + } else if (count == 1) { + // FXx + mangled.Append(c.ToLowerInvariant()); + i++; + } else { + // FOXxx, FOOXxx, FOOOXxx, ... + string special = MapSpecialWord(name, i, count); + if (special != null) { + mangled.Append(special.ToLowerInvariant()); + i = j; + } else { + return null; + } } - result.Append(Char.ToLower(name[i])); } else { - result.Append(name[i]); + if (mangled != null) { + mangled.Append(c); + } + i++; } } - return result.ToString(); + return mangled != null ? mangled.ToString() : null; + } + + private static string MapSpecialWord(string/*!*/ name, int start, int count) { + if (count == 2) { + return IsTwoLetterWord(name, start) ? null : name.Substring(start, count); + } + + return null; + } + + private static bool IsTwoLetterWord(string/*!*/ str, int index) { + int c = LetterPair(str, index); + switch (c) { + case ('a' << 8) | 't': + case ('a' << 8) | 's': + case ('b' << 8) | 'y': + case ('d' << 8) | 'o': + case ('i' << 8) | 'd': + case ('i' << 8) | 't': + case ('i' << 8) | 'f': + case ('i' << 8) | 'n': + case ('i' << 8) | 's': + case ('g' << 8) | 'o': + case ('m' << 8) | 'y': + case ('o' << 8) | 'f': + case ('o' << 8) | 'k': + case ('o' << 8) | 'n': + case ('t' << 8) | 'o': + case ('u' << 8) | 'p': + return true; + } + return false; + } + + private static int LetterPair(string/*!*/ str, int index) { + return (str[index + 1] & 0xff00) == 0 ? (str[index].ToLowerInvariant() << 8) | str[index + 1].ToLowerInvariant() : -1; } #endregion @@ -899,7 +998,7 @@ namespace IronRuby.Runtime { basePath + "/" + path; } - public static bool FileSystemUsesDriveLetters { get { return System.IO.Path.DirectorySeparatorChar == '\\'; } } + public static bool FileSystemUsesDriveLetters { get { return Path.DirectorySeparatorChar == '\\'; } } // Is path something like "/foo/bar" (or "c:/foo/bar" on Windows) // We need this instead of Path.IsPathRooted since we need to be able to deal with Unix-style path names even on Windows @@ -929,7 +1028,7 @@ namespace IronRuby.Runtime { } // returns "/" or something like "c:/" - public static string GetPathRoot(RubyContext/*!*/ context, string path, out string pathAfterRoot) { + public static string GetPathRoot(PlatformAdaptationLayer/*!*/ platform, string path, out string pathAfterRoot) { Debug.Assert(IsAbsolutePath(path)); if (IsAbsoluteDriveLetterPath(path)) { pathAfterRoot = path.Substring(3); @@ -946,10 +1045,10 @@ namespace IronRuby.Runtime { if (!FileSystemUsesDriveLetters || initialSlashesCount > 1) { return initialSlashes; } else { - string currentDirectory = RubyUtils.CanonicalizePath(context.DomainManager.Platform.CurrentDirectory); + string currentDirectory = RubyUtils.CanonicalizePath(platform.CurrentDirectory); Debug.Assert(IsAbsoluteDriveLetterPath(currentDirectory)); string temp; - return GetPathRoot(context, currentDirectory, out temp); + return GetPathRoot(platform, currentDirectory, out temp); } } } @@ -976,6 +1075,205 @@ namespace IronRuby.Runtime { } } + #region expand_path + +#if !SILVERLIGHT + // Algorithm to find HOME equivalents under Windows. This is equivalent to Ruby 1.9 behavior: + // + // 1. Try get HOME + // 2. Try to generate HOME equivalent using HOMEDRIVE + HOMEPATH + // 3. Try to generate HOME equivalent from USERPROFILE + // 4. Try to generate HOME equivalent from Personal special folder + + public static string/*!*/ GetHomeDirectory(PlatformAdaptationLayer/*!*/ platform) { + PlatformAdaptationLayer pal = platform; + string result = pal.GetEnvironmentVariable("HOME"); + + if (result != null) { + return result; + } + + string homeDrive = pal.GetEnvironmentVariable("HOMEDRIVE"); + string homePath = pal.GetEnvironmentVariable("HOMEPATH"); + if (homeDrive == null && homePath == null) { + string userEnvironment = pal.GetEnvironmentVariable("USERPROFILE"); + if (userEnvironment == null) { + // This will always succeed with a non-null string, but it can fail + // if the Personal folder was renamed or deleted. In this case it returns + // an empty string. + result = Environment.GetFolderPath(Environment.SpecialFolder.Personal); + } else { + result = userEnvironment; + } + } else if (homeDrive == null) { + result = homePath; + } else if (homePath == null) { + result = homeDrive + Path.DirectorySeparatorChar; + } else { + result = homeDrive + homePath; + } + + if (result != null) { + result = ExpandPath(platform, result); + } + + return result; + } + + class PathExpander { + List<string> _pathComponents = new List<string>(); // does not include the root + string _root; // Typically "c:/" on Windows, and "/" on Unix + + internal PathExpander(PlatformAdaptationLayer/*!*/ platform, string absoluteBasePath) { + Debug.Assert(RubyUtils.IsAbsolutePath(absoluteBasePath)); + + string basePathAfterRoot = null; + _root = RubyUtils.GetPathRoot(platform, absoluteBasePath, out basePathAfterRoot); + + // Normally, basePathAfterRoot[0] will not be '/', but here we deal with cases like "c:////foo" + basePathAfterRoot = basePathAfterRoot.TrimStart('/'); + + AddRelativePath(basePathAfterRoot); + } + + internal void AddRelativePath(string relPath) { + Debug.Assert(!RubyUtils.IsAbsolutePath(relPath)); + + string[] relPathComponents = relPath.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries); + + foreach (string pathComponent in relPathComponents) { + if (pathComponent == "..") { + if (_pathComponents.Count == 0) { + // MRI allows more pops than the base path components + continue; + } + _pathComponents.RemoveAt(_pathComponents.Count - 1); + } else if (pathComponent == ".") { + continue; + } else { + _pathComponents.Add(pathComponent); + } + } + } + + internal string/*!*/ GetResult() { + StringBuilder result = new StringBuilder(_root); + + if (_pathComponents.Count >= 1) { + // Here we make this work: + // File.expand_path("c:/..a..") -> "c:/..a" + string lastComponent = _pathComponents[_pathComponents.Count - 1]; + if (RubyUtils.FileSystemUsesDriveLetters && !String.IsNullOrEmpty(lastComponent.TrimEnd('.'))) { + _pathComponents[_pathComponents.Count - 1] = lastComponent.TrimEnd('.'); + } + } + + for (int i = 0; i < _pathComponents.Count; i++) { + result.Append(_pathComponents[i]); + if (i < (_pathComponents.Count - 1)) { + result.Append('/'); + } + } +#if DEBUG + _pathComponents = null; + _root = null; +#endif + return result.ToString(); + } + } + + // Expand directory path - these cases exist: + // + // 1. Empty string or nil means return current directory + // 2. ~ with non-existent HOME directory throws exception + // 3. ~, ~/ or ~\ which expands to HOME + // 4. ~foo is left unexpanded + // 5. Expand to full path if path is a relative path + // + // No attempt is made to determine whether the path is valid or not + // Returned path is always canonicalized to forward slashes + + public static string/*!*/ ExpandPath(PlatformAdaptationLayer/*!*/ platform, string/*!*/ path) { + if (String.IsNullOrEmpty(path)) { + return RubyUtils.CanonicalizePath(platform.CurrentDirectory); + } + + int length = path.Length; + + if (path[0] == '~') { + if (length == 1 || (path[1] == '/')) { + + string homeDirectory = platform.GetEnvironmentVariable("HOME"); + if (homeDirectory == null) { + throw RubyExceptions.CreateArgumentError("couldn't find HOME environment -- expanding `~'"); + } + + if (length <= 2) { + path = homeDirectory; + } else { + path = Path.Combine(homeDirectory, path.Substring(2)); + } + return RubyUtils.CanonicalizePath(path); + } else { + return path; + } + } else { + string currentDirectory = ExpandPath(platform, null); + return ExpandPath(platform, path, currentDirectory); + } + } + + public static string/*!*/ ExpandPath( + PlatformAdaptationLayer/*!*/ platform, + string/*!*/ path, + string basePath) { + + // We ignore basePath parameter if first string starts with a ~ + if (basePath == null || (path.Length > 0 && path[0] == '~')) { + return ExpandPath(platform, path); + } + + path = RubyUtils.CanonicalizePath(path); + basePath = RubyUtils.CanonicalizePath(basePath); + char partialDriveLetter; + string relativePath; + + if (RubyUtils.IsAbsolutePath(path)) { + // "basePath" can be ignored is "path" is an absolute path + PathExpander pathExpander = new PathExpander(platform, path); + return pathExpander.GetResult(); + } else if (RubyUtils.HasPartialDriveLetter(path, out partialDriveLetter, out relativePath)) { + string currentDirectory = partialDriveLetter.ToString() + ":/"; + if (platform.DirectoryExists(currentDirectory)) { + // File.expand_path("c:foo") returns "c:/current_folder_for_c_drive/foo" + currentDirectory = Path.GetFullPath(partialDriveLetter.ToString() + ":"); + } + + return ExpandPath( + platform, + relativePath, + currentDirectory); + } else if (RubyUtils.IsAbsolutePath(basePath)) { + PathExpander pathExpander = new PathExpander(platform, basePath); + pathExpander.AddRelativePath(path); + return pathExpander.GetResult(); + } else if (RubyUtils.HasPartialDriveLetter(basePath, out partialDriveLetter, out relativePath)) { + // First expand basePath + string expandedBasePath = ExpandPath(platform, basePath); + + return ExpandPath(platform, path, expandedBasePath); + } else { + // First expand basePath + string expandedBasePath = ExpandPath(platform, basePath); + Debug.Assert(RubyUtils.IsAbsolutePath(expandedBasePath)); + + return ExpandPath(platform, path, expandedBasePath); + } + } +#endif + + #endregion + #endregion } } Merlin/Main/Languages/Ruby/Ruby/Runtime/RubyUtils.cs @@ -21,6 +21,7 @@ using System.Reflection; using System.Collections; using System.Collections.Generic; using IronRuby.Builtins; +using System.Globalization; namespace IronRuby.Runtime { public static class Utils { @@ -327,6 +328,19 @@ namespace IronRuby.Runtime { return defaultResult; } + internal static bool SubstringEquals(string/*!*/ name, int start, int count, string/*!*/ other) { + if (count != other.Length) { + return false; + } + + for (int i = 0; i < count; i++) { + if (name[start + i] != other[i]) { + return false; + } + } + return true; + } + public static TOutput[]/*!*/ ConvertAll<TInput, TOutput>(this TInput[]/*!*/ array, Converter<TInput, TOutput>/*!*/ converter) { var result = new TOutput[array.Length]; for (int i = 0; i < array.Length; i++) { @@ -375,6 +389,24 @@ namespace IronRuby.Runtime { public static char ToUpperHexDigit(this int digit) { return (char)((digit < 10) ? '0' + digit : 'A' + digit - 10); } + + public static char ToUpperInvariant(this char c) { + return Char.ToUpper(c, CultureInfo.InvariantCulture); + } + + public static char ToLowerInvariant(this char c) { + return Char.ToLower(c, CultureInfo.InvariantCulture); + } + +#if SILVERLIGHT + public static string/*!*/ ToUpperInvariant(this string/*!*/ str) { + return str.ToUpper(CultureInfo.InvariantCulture); + } + + public static string/*!*/ ToLowerInvariant(this string/*!*/ str) { + return str.ToLower(CultureInfo.InvariantCulture); + } +#endif } } Merlin/Main/Languages/Ruby/Ruby/Runtime/Utils.cs @@ -1,15 +1,15 @@ -html, body { - height: 99%; - overflow: auto; -} -body { - padding: 0; - margin: 0; -} -#silverlightControlHost { - height: 100%; -} -#errorLocation { - font-size: small; - color: Gray; -} +html, body { + height: 99%; + overflow: auto; +} +body { + padding: 0; + margin: 0; +} +#silverlightControlHost { + height: 100%; +} +#errorLocation { + font-size: small; + color: Gray; +} Merlin/Main/Languages/Ruby/Samples/Tutorial/css/screen.css @@ -1,17 +1,17 @@ - -Microsoft Visual Studio Solution File, Format Version 10.00 -# Visual Studio 2008 -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TutorialSL", "TutorialSL\TutorialSL.csproj", "{102A0325-55BF-475B-8536-018F7D913B83}" -EndProject -Global - GlobalSection(SolutionConfigurationPlatforms) = preSolution - Debug|Any CPU = Debug|Any CPU - Release|Any CPU = Release|Any CPU - EndGlobalSection - GlobalSection(ProjectConfigurationPlatforms) = postSolution - {102A0325-55BF-475B-8536-018F7D913B83}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {102A0325-55BF-475B-8536-018F7D913B83}.Debug|Any CPU.Build.0 = Debug|Any CPU - {102A0325-55BF-475B-8536-018F7D913B83}.Release|Any CPU.ActiveCfg = Release|Any CPU - {102A0325-55BF-475B-8536-018F7D913B83}.Release|Any CPU.Build.0 = Release|Any CPU - EndGlobalSection -EndGlobal + +Microsoft Visual Studio Solution File, Format Version 10.00 +# Visual Studio 2008 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TutorialSL", "TutorialSL\TutorialSL.csproj", "{102A0325-55BF-475B-8536-018F7D913B83}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {102A0325-55BF-475B-8536-018F7D913B83}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {102A0325-55BF-475B-8536-018F7D913B83}.Debug|Any CPU.Build.0 = Debug|Any CPU + {102A0325-55BF-475B-8536-018F7D913B83}.Release|Any CPU.ActiveCfg = Release|Any CPU + {102A0325-55BF-475B-8536-018F7D913B83}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection +EndGlobal Merlin/Main/Languages/Ruby/Samples/Tutorial/design/TutorialSL.sln @@ -1,8 +1,8 @@ -<Application - xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" - xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" - x:Class="TutorialSL.App"> - <Application.Resources> - <!-- Resources scoped at the Application level should be defined here. --> - </Application.Resources> -</Application> +<Application + xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" + xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" + x:Class="TutorialSL.App"> + <Application.Resources> + <!-- Resources scoped at the Application level should be defined here. --> + </Application.Resources> +</Application> Merlin/Main/Languages/Ruby/Samples/Tutorial/design/TutorialSL/App.xaml @@ -1,65 +1,65 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Net; -using System.Windows; -using System.Windows.Controls; -using System.Windows.Input; -using System.Windows.Media; -using System.Windows.Media.Animation; -using System.Windows.Shapes; - -namespace TutorialSL -{ - public partial class App : Application - { - public App() - { - this.Startup += this.Application_Startup; - this.Exit += this.Application_Exit; - this.UnhandledException += this.Application_UnhandledException; - - InitializeComponent(); - } - - private void Application_Startup(object sender, StartupEventArgs e) - { - this.RootVisual = new MainPage(); - } - - private void Application_Exit(object sender, EventArgs e) - { - } - - private void Application_UnhandledException(object sender, ApplicationUnhandledExceptionEventArgs e) - { - // If the app is running outside of the debugger then report the exception using - // the browser's exception mechanism. On IE this will display it a yellow alert - // icon in the status bar and Firefox will display a script error. - if (!System.Diagnostics.Debugger.IsAttached) - { - - // NOTE: This will allow the application to continue running after an exception has been thrown - // but not handled. - // For production applications this error handling should be replaced with something that will - // report the error to the website and stop the application. - e.Handled = true; - Deployment.Current.Dispatcher.BeginInvoke(delegate { ReportErrorToDOM(e); }); - } - } - - private void ReportErrorToDOM(ApplicationUnhandledExceptionEventArgs e) - { - try - { - string errorMsg = e.ExceptionObject.Message + e.ExceptionObject.StackTrace; - errorMsg = errorMsg.Replace('"', '\'').Replace("\r\n", @"\n"); - - System.Windows.Browser.HtmlPage.Window.Eval("throw new Error(\"Unhandled Error in Silverlight Application " + errorMsg + "\");"); - } - catch (Exception) - { - } - } - } -} +using System; +using System.Collections.Generic; +using System.Linq; +using System.Net; +using System.Windows; +using System.Windows.Controls; +using System.Windows.Input; +using System.Windows.Media; +using System.Windows.Media.Animation; +using System.Windows.Shapes; + +namespace TutorialSL +{ + public partial class App : Application + { + public App() + { + this.Startup += this.Application_Startup; + this.Exit += this.Application_Exit; + this.UnhandledException += this.Application_UnhandledException; + + InitializeComponent(); + } + + private void Application_Startup(object sender, StartupEventArgs e) + { + this.RootVisual = new MainPage(); + } + + private void Application_Exit(object sender, EventArgs e) + { + } + + private void Application_UnhandledException(object sender, ApplicationUnhandledExceptionEventArgs e) + { + // If the app is running outside of the debugger then report the exception using + // the browser's exception mechanism. On IE this will display it a yellow alert + // icon in the status bar and Firefox will display a script error. + if (!System.Diagnostics.Debugger.IsAttached) + { + + // NOTE: This will allow the application to continue running after an exception has been thrown + // but not handled. + // For production applications this error handling should be replaced with something that will + // report the error to the website and stop the application. + e.Handled = true; + Deployment.Current.Dispatcher.BeginInvoke(delegate { ReportErrorToDOM(e); }); + } + } + + private void ReportErrorToDOM(ApplicationUnhandledExceptionEventArgs e) + { + try + { + string errorMsg = e.ExceptionObject.Message + e.ExceptionObject.StackTrace; + errorMsg = errorMsg.Replace('"', '\'').Replace("\r\n", @"\n"); + + System.Windows.Browser.HtmlPage.Window.Eval("throw new Error(\"Unhandled Error in Silverlight Application " + errorMsg + "\");"); + } + catch (Exception) + { + } + } + } +} Merlin/Main/Languages/Ruby/Samples/Tutorial/design/TutorialSL/App.xaml.cs @@ -1,42 +1,42 @@ -/* **************************************************************************** - * - * 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; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Windows; -using System.Windows.Controls; -using System.Windows.Data; -using System.Windows.Input; -using System.Windows.Media; -using System.Windows.Media.Imaging; -using System.Windows.Shapes; - -namespace TutorialSL -{ - /// <summary> - /// Interaction logic for MainWindow.xaml - /// </summary> - public partial class MainPage : UserControl - { - public MainPage() - { - this.InitializeComponent(); - - // Insert code required on object creation below this point. - } - } -} +/* **************************************************************************** + * + * 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; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Windows; +using System.Windows.Controls; +using System.Windows.Data; +using System.Windows.Input; +using System.Windows.Media; +using System.Windows.Media.Imaging; +using System.Windows.Shapes; + +namespace TutorialSL +{ + /// <summary> + /// Interaction logic for MainWindow.xaml + /// </summary> + public partial class MainPage : UserControl + { + public MainPage() + { + this.InitializeComponent(); + + // Insert code required on object creation below this point. + } + } +} Merlin/Main/Languages/Ruby/Samples/Tutorial/design/TutorialSL/MainPage.xaml.cs @@ -1,5 +1,5 @@ -<Deployment xmlns="http://schemas.microsoft.com/client/2007/deployment" - xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"> - <Deployment.Parts> - </Deployment.Parts> +<Deployment xmlns="http://schemas.microsoft.com/client/2007/deployment" + xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"> + <Deployment.Parts> + </Deployment.Parts> </Deployment> \ No newline at end of file Merlin/Main/Languages/Ruby/Samples/Tutorial/design/TutorialSL/Properties/AppManifest.xml @@ -1,37 +1,37 @@ -using System.Reflection; -using System.Runtime.CompilerServices; -using System.Runtime.InteropServices; - -// General Information about an assembly is controlled through the following -// set of attributes. Change these attribute values to modify the information -// associated with an assembly. -[assembly: AssemblyTitle("TutorialSL")] -[assembly: AssemblyDescription("")] -[assembly: AssemblyConfiguration("")] -[assembly: AssemblyCompany("")] -[assembly: AssemblyProduct("TutorialSL")] -[assembly: AssemblyCopyright("Copyright © 2009")] -[assembly: AssemblyTrademark("")] -[assembly: AssemblyCulture("")] - -// Setting ComVisible to false makes the types in this assembly not visible -// to COM components. If you need to access a type in this assembly from -// COM, set the ComVisible attribute to true on that type. -[assembly: ComVisible(false)] - -// The following GUID is for the ID of the typelib if this project is exposed to COM -[assembly: Guid("102a0325-55bf-475b-8536-018f7d913b83")] - -// Version information for an assembly consists of the following four values: -// -// Major Version -// Minor Version -// Build Number -// Revision -// -// You can specify all the values or you can default the Revision and Build Numbers -// by using the '*' as shown below: -// [assembly: AssemblyVersion("1.0.*")] - -[assembly: AssemblyVersion("1.0.0.0")] +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("TutorialSL")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("TutorialSL")] +[assembly: AssemblyCopyright("Copyright © 2009")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("102a0325-55bf-475b-8536-018f7d913b83")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Revision and Build Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] + +[assembly: AssemblyVersion("1.0.0.0")] [assembly: AssemblyFileVersion("1.0.0.0")] \ No newline at end of file Merlin/Main/Languages/Ruby/Samples/Tutorial/design/TutorialSL/Properties/AssemblyInfo.cs @@ -1,39 +1,39 @@ -/* **************************************************************************** - * - * 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; -using System.Collections.Generic; -using System.Text; -using System.Windows; -using System.Windows.Controls; -using System.Windows.Data; -using System.Windows.Input; -using System.Windows.Media; -using System.Windows.Media.Imaging; -using System.Windows.Shapes; - -namespace TutorialSL -{ - /// <summary> - /// Interaction logic for StepControl.xaml - /// </summary> - public partial class StepControl : UserControl - { - public StepControl() - { - this.InitializeComponent(); - } - } -} +/* **************************************************************************** + * + * 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; +using System.Collections.Generic; +using System.Text; +using System.Windows; +using System.Windows.Controls; +using System.Windows.Data; +using System.Windows.Input; +using System.Windows.Media; +using System.Windows.Media.Imaging; +using System.Windows.Shapes; + +namespace TutorialSL +{ + /// <summary> + /// Interaction logic for StepControl.xaml + /// </summary> + public partial class StepControl : UserControl + { + public StepControl() + { + this.InitializeComponent(); + } + } +} Merlin/Main/Languages/Ruby/Samples/Tutorial/design/TutorialSL/StepControl.xaml.cs @@ -17,7 +17,7 @@ <SplineColorKeyFrame KeyTime="00:00:00.0610000" Value="#FFC8C8C8"/> </ColorAnimationUsingKeyFrames> </Storyboard> - </UserControl.Resources> + </UserControl.Resources> <StackPanel Margin="0,0,0,15"> <Border x:Name="tutorial_id" BorderBrush="#FFC8C8C8" BorderThickness="5" CornerRadius="10" Padding="0" Margin="0" Background="White" OpacityMask="{x:Null}" d:LayoutOverrides="Width" Cursor="Hand"> Merlin/Main/Languages/Ruby/Samples/Tutorial/design/TutorialSL/TutorialControl.xaml @@ -1,39 +1,39 @@ -/* **************************************************************************** - * - * 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; -using System.Collections.Generic; -using System.Text; -using System.Windows; -using System.Windows.Controls; -using System.Windows.Data; -using System.Windows.Input; -using System.Windows.Media; -using System.Windows.Media.Imaging; -using System.Windows.Shapes; - -namespace TutorialSL -{ - /// <summary> - /// Interaction logic for TutorialControl.xaml - /// </summary> - public partial class TutorialControl : UserControl - { - public TutorialControl() - { - this.InitializeComponent(); - } - } -} +/* **************************************************************************** + * + * 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; +using System.Collections.Generic; +using System.Text; +using System.Windows; +using System.Windows.Controls; +using System.Windows.Data; +using System.Windows.Input; +using System.Windows.Media; +using System.Windows.Media.Imaging; +using System.Windows.Shapes; + +namespace TutorialSL +{ + /// <summary> + /// Interaction logic for TutorialControl.xaml + /// </summary> + public partial class TutorialControl : UserControl + { + public TutorialControl() + { + this.InitializeComponent(); + } + } +} Merlin/Main/Languages/Ruby/Samples/Tutorial/design/TutorialSL/TutorialControl.xaml.cs @@ -22,7 +22,7 @@ <TextBlock x:Name="complete_title" Text="Section complete!" TextWrapping="Wrap" Margin="13,0,13,8" FontSize="16" FontWeight="Bold" FontFamily="Segoe UI"/> <Border x:Name="complete_wrapper" BorderBrush="#FFC8C8C8" BorderThickness="5" CornerRadius="10" Margin="8,0,8,8" Canvas.ZIndex="10"> <StackPanel Margin="0"> - <TextBlock x:Name="complete_body" VerticalAlignment="Top" FontSize="16" Padding="7,6,7,0" HorizontalAlignment="Left" FontFamily="Segoe UI"> + <TextBlock x:Name="complete_body" VerticalAlignment="Top" FontSize="16" Padding="7,6,7,0" HorizontalAlignment="Left" FontFamily="Segoe UI"> <Run>Section complete!"</Run> </TextBlock> <StackPanel Margin="8" Orientation="Horizontal" d:LayoutOverrides="HorizontalAlignment"> Merlin/Main/Languages/Ruby/Samples/Tutorial/design/TutorialSL/TutorialPage.xaml @@ -1,24 +1,24 @@ -using System; -using System.Collections.Generic; -using System.Text; -using System.Windows; -using System.Windows.Controls; -using System.Windows.Data; -using System.Windows.Input; -using System.Windows.Media; -using System.Windows.Media.Imaging; -using System.Windows.Shapes; - -namespace TutorialSL -{ - /// <summary> - /// Interaction logic for TutorialPage.xaml - /// </summary> - public partial class TutorialPage : UserControl - { - public TutorialPage() - { - this.InitializeComponent(); - } - } -} +using System; +using System.Collections.Generic; +using System.Text; +using System.Windows; +using System.Windows.Controls; +using System.Windows.Data; +using System.Windows.Input; +using System.Windows.Media; +using System.Windows.Media.Imaging; +using System.Windows.Shapes; + +namespace TutorialSL +{ + /// <summary> + /// Interaction logic for TutorialPage.xaml + /// </summary> + public partial class TutorialPage : UserControl + { + public TutorialPage() + { + this.InitializeComponent(); + } + } +} Merlin/Main/Languages/Ruby/Samples/Tutorial/design/TutorialSL/TutorialPage.xaml.cs @@ -1,107 +1,107 @@ -<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> - <PropertyGroup> - <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> - <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> - <ExpressionBlendVersion>3.0.1921.0</ExpressionBlendVersion> - <ProjectGuid>{102a0325-55bf-475b-8536-018f7d913b83}</ProjectGuid> - <ProjectTypeGuids>{A1591282-1198-4647-A2B1-27E5FF5F6F3B};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> - <OutputType>Library</OutputType> - <AppDesignerFolder>Properties</AppDesignerFolder> - <DefaultClrNameSpace>TutorialSL</DefaultClrNameSpace> - <RootNamespace>TutorialSL</RootNamespace> - <AssemblyName>TutorialSL</AssemblyName> - <ApplicationVersion>1.0.0.*</ApplicationVersion> - <ApplicationRevision>0</ApplicationRevision> - <AlwaysCompileMarkupFilesInSeparateDomain>false</AlwaysCompileMarkupFilesInSeparateDomain> - <TargetFrameworkVersion>v3.5</TargetFrameworkVersion> - <SilverlightApplication>true</SilverlightApplication> - <XapOutputs>true</XapOutputs> - <XapFilename>TutorialSL.xap</XapFilename> - <GenerateSilverlightManifest>true</GenerateSilverlightManifest> - <SilverlightManifestTemplate>Properties\AppManifest.xml</SilverlightManifestTemplate> - <SilverlightAppEntry>TutorialSL.App</SilverlightAppEntry> - <CreateTestPage>true</CreateTestPage> - <ValidateXaml>true</ValidateXaml> - <UsePlatformExtensions>false</UsePlatformExtensions> - <ThrowErrorsInValidation>true</ThrowErrorsInValidation> - <TestPageFileName>TestPage.html</TestPageFileName> - </PropertyGroup> - <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> - <DebugSymbols>true</DebugSymbols> - <DebugType>full</DebugType> - <Optimize>false</Optimize> - <OutputPath>Bin\Debug</OutputPath> - <DefineConstants>DEBUG;TRACE;SILVERLIGHT</DefineConstants> - <NoStdLib>true</NoStdLib> - <NoConfig>true</NoConfig> - <ErrorReport>prompt</ErrorReport> - <WarningLevel>4</WarningLevel> - </PropertyGroup> - <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> - <DebugType>pdbonly</DebugType> - <Optimize>true</Optimize> - <OutputPath>Bin\Release</OutputPath> - <DefineConstants>TRACE;SILVERLIGHT</DefineConstants> - <NoStdLib>true</NoStdLib> - <NoConfig>true</NoConfig> - <ErrorReport>prompt</ErrorReport> - <WarningLevel>4</WarningLevel> - </PropertyGroup> - <ItemGroup> - <Reference Include="Microsoft.Expression.Interactions, Version=2.0.5.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" /> - <Reference Include="System.Windows" /> - <Reference Include="mscorlib" /> - <Reference Include="system" /> - <Reference Include="System.Core" /> - <Reference Include="System.Net" /> - <Reference Include="System.Windows.Interactivity, Version=2.0.5.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" /> - <Reference Include="System.Xml" /> - <Reference Include="System.Windows.Browser" /> - </ItemGroup> - <ItemGroup> - <ApplicationDefinition Include="App.xaml"> - <Generator>MSBuild:MarkupCompilePass1</Generator> - <SubType>Designer</SubType> - </ApplicationDefinition> - <Compile Include="App.xaml.cs"> - <DependentUpon>App.xaml</DependentUpon> - </Compile> - <Compile Include="MainPage.xaml.cs"> - <DependentUpon>MainPage.xaml</DependentUpon> - </Compile> - <Page Include="MainPage.xaml"> - <Generator>MSBuild:MarkupCompilePass1</Generator> - <SubType>Designer</SubType> - </Page> - <Page Include="StepControl.xaml"> - <Generator>MSBuild:MarkupCompilePass1</Generator> - <SubType>Designer</SubType> - </Page> - <Page Include="TutorialControl.xaml"> - <Generator>MSBuild:MarkupCompilePass1</Generator> - <SubType>Designer</SubType> - </Page> - <Page Include="TutorialPage.xaml"> - <Generator>MSBuild:MarkupCompilePass1</Generator> - <SubType>Designer</SubType> - </Page> - <None Include="favicon.ico"> - <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory> - <Visible>false</Visible> - </None> - <Compile Include="Properties\AssemblyInfo.cs" /> - <Compile Include="StepControl.xaml.cs"> - <DependentUpon>StepControl.xaml</DependentUpon> - </Compile> - <Compile Include="TutorialControl.xaml.cs"> - <DependentUpon>TutorialControl.xaml</DependentUpon> - </Compile> - <Compile Include="TutorialPage.xaml.cs"> - <DependentUpon>TutorialPage.xaml</DependentUpon> - </Compile> - </ItemGroup> - <ItemGroup> - <Resource Include="Properties\AppManifest.xml" /> - </ItemGroup> - <Import Project="$(MSBuildExtensionsPath)\Microsoft\Silverlight\V3.0\Microsoft.Silverlight.CSharp.targets" /> +<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <ExpressionBlendVersion>3.0.1921.0</ExpressionBlendVersion> + <ProjectGuid>{102a0325-55bf-475b-8536-018f7d913b83}</ProjectGuid> + <ProjectTypeGuids>{A1591282-1198-4647-A2B1-27E5FF5F6F3B};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <OutputType>Library</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <DefaultClrNameSpace>TutorialSL</DefaultClrNameSpace> + <RootNamespace>TutorialSL</RootNamespace> + <AssemblyName>TutorialSL</AssemblyName> + <ApplicationVersion>1.0.0.*</ApplicationVersion> + <ApplicationRevision>0</ApplicationRevision> + <AlwaysCompileMarkupFilesInSeparateDomain>false</AlwaysCompileMarkupFilesInSeparateDomain> + <TargetFrameworkVersion>v3.5</TargetFrameworkVersion> + <SilverlightApplication>true</SilverlightApplication> + <XapOutputs>true</XapOutputs> + <XapFilename>TutorialSL.xap</XapFilename> + <GenerateSilverlightManifest>true</GenerateSilverlightManifest> + <SilverlightManifestTemplate>Properties\AppManifest.xml</SilverlightManifestTemplate> + <SilverlightAppEntry>TutorialSL.App</SilverlightAppEntry> + <CreateTestPage>true</CreateTestPage> + <ValidateXaml>true</ValidateXaml> + <UsePlatformExtensions>false</UsePlatformExtensions> + <ThrowErrorsInValidation>true</ThrowErrorsInValidation> + <TestPageFileName>TestPage.html</TestPageFileName> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + <DebugSymbols>true</DebugSymbols> + <DebugType>full</DebugType> + <Optimize>false</Optimize> + <OutputPath>Bin\Debug</OutputPath> + <DefineConstants>DEBUG;TRACE;SILVERLIGHT</DefineConstants> + <NoStdLib>true</NoStdLib> + <NoConfig>true</NoConfig> + <ErrorReport>prompt</ErrorReport> + <WarningLevel>4</WarningLevel> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + <DebugType>pdbonly</DebugType> + <Optimize>true</Optimize> + <OutputPath>Bin\Release</OutputPath> + <DefineConstants>TRACE;SILVERLIGHT</DefineConstants> + <NoStdLib>true</NoStdLib> + <NoConfig>true</NoConfig> + <ErrorReport>prompt</ErrorReport> + <WarningLevel>4</WarningLevel> + </PropertyGroup> + <ItemGroup> + <Reference Include="Microsoft.Expression.Interactions, Version=2.0.5.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" /> + <Reference Include="System.Windows" /> + <Reference Include="mscorlib" /> + <Reference Include="system" /> + <Reference Include="System.Core" /> + <Reference Include="System.Net" /> + <Reference Include="System.Windows.Interactivity, Version=2.0.5.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" /> + <Reference Include="System.Xml" /> + <Reference Include="System.Windows.Browser" /> + </ItemGroup> + <ItemGroup> + <ApplicationDefinition Include="App.xaml"> + <Generator>MSBuild:MarkupCompilePass1</Generator> + <SubType>Designer</SubType> + </ApplicationDefinition> + <Compile Include="App.xaml.cs"> + <DependentUpon>App.xaml</DependentUpon> + </Compile> + <Compile Include="MainPage.xaml.cs"> + <DependentUpon>MainPage.xaml</DependentUpon> + </Compile> + <Page Include="MainPage.xaml"> + <Generator>MSBuild:MarkupCompilePass1</Generator> + <SubType>Designer</SubType> + </Page> + <Page Include="StepControl.xaml"> + <Generator>MSBuild:MarkupCompilePass1</Generator> + <SubType>Designer</SubType> + </Page> + <Page Include="TutorialControl.xaml"> + <Generator>MSBuild:MarkupCompilePass1</Generator> + <SubType>Designer</SubType> + </Page> + <Page Include="TutorialPage.xaml"> + <Generator>MSBuild:MarkupCompilePass1</Generator> + <SubType>Designer</SubType> + </Page> + <None Include="favicon.ico"> + <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory> + <Visible>false</Visible> + </None> + <Compile Include="Properties\AssemblyInfo.cs" /> + <Compile Include="StepControl.xaml.cs"> + <DependentUpon>StepControl.xaml</DependentUpon> + </Compile> + <Compile Include="TutorialControl.xaml.cs"> + <DependentUpon>TutorialControl.xaml</DependentUpon> + </Compile> + <Compile Include="TutorialPage.xaml.cs"> + <DependentUpon>TutorialPage.xaml</DependentUpon> + </Compile> + </ItemGroup> + <ItemGroup> + <Resource Include="Properties\AppManifest.xml" /> + </ItemGroup> + <Import Project="$(MSBuildExtensionsPath)\Microsoft\Silverlight\V3.0\Microsoft.Silverlight.CSharp.targets" /> </Project> \ No newline at end of file Merlin/Main/Languages/Ruby/Samples/Tutorial/design/TutorialSL/TutorialSL.csproj @@ -1,455 +1,453 @@ -$:.unshift File.dirname(__FILE__) + "/Libs" - -require File.dirname(__FILE__) + '/wpf' -include Wpf - -require 'tutorial' - -module GuiTutorial - - class Tutorial - attr_reader :tasks, :task, :chapter, :current_tutorial - - # TODO: Figure out how to remove this condition: - # - # When the "next_chapter" button is focused and the enter-button is pressed, - # somewhere along that process the "repl_input" TextBox gets focus, but - # then the "repl_input.key_up" fires from the previous enter-button press, - # causing two extra lines in the repl history. - # - # This flag shunts the first key_up event, and then is set back to false. - # This ignores all first-keypresses that are "enter", hackily removing the - # issue, since "enter" should never really be the first key pressed. - # Definitely not a perfect solution. - attr_accessor :handling_next_chapter - - def initialize(t, window) - @current_tutorial ||= ::Tutorial.get_tutorial(t) - @window = GuiTutorial::Window.current - end - - def self.all - @tutorials ||= ::Tutorial.all - end - - def reset - @chapter = nil - @tasks = nil - @window.tutorial_body.children.clear - end - - def start - reset - Window.show_tutorial - - unless SILVERLIGHT - @window.chapters.items_source = @current_tutorial.sections - @window.chapters.mouse_left_button_up do |t, e| - select_section_or_chapter t.selected_item - end - end - - @window.next_chapter.click do |t, e| - @handling_next_chapter = true - select_section_or_chapter @chapter.next_item if @chapter - end - - select_chapter(@current_tutorial.first_chapter, @current_tutorial.first_section) - end - - def select_section_or_chapter(item) - return unless item - case item - when ::Tutorial::Section: select_section item - when ::Tutorial::Chapter: select_chapter item - else - raise "Unknown selection type: #{item}" - end - end - - def select_chapter(chapter, section = nil) - if section - @window.set_or_collapse(:pre_exercise, section.introduction) do |obj, value| - obj.document = value - end - else - @window.pre_exercise.collapse! - end - @chapter = chapter - @window.set_or_collapse(:exercise, @chapter.introduction) do |obj, value| - obj.document = value - end - - @window.tutorial_body.children.clear - @tasks = @chapter.tasks.clone - select_next_task - end - - def select_section(section) - reset - @window.set_or_collapse(:exercise, section.introduction) do |obj, value| - obj.document = value - end - @window.pre_exercise.collapse! - end - - def select_next_task - unless @tasks.empty? - @task = @tasks.shift - @window.next_step - if @task.description - fd = FlowDocument.from_simple_markup @task.description - fd << "Full path: #{@task.source_files.tr('/', '\\')}" if @task.source_files - return select_next_task if not @task.should_run? Window.repl.context.bind - @task.setup.call(Window.repl.context.bind) if @task.setup - if @task.code - unless SILVERLIGHT - p = Paragraph.new Run.new(@task.code_string) - p.font_family = FontFamily.new "Consolas" - p.font_weight = FontWeights.Bold - fd.Blocks.Add p - else - fd += "\n\n#{@task.code_string}" - end - end - end - @window.set_or_collapse(:step_title, @task.title) do |obj, value| - obj.text = value - end - - @window.step_description.document = fd - @window.tutorial_scroll.scroll_to_bottom - else - if @chapter.next_item - @window.complete.show! - @window.tutorial_scroll.scroll_to_bottom - if @window.current_step? - @window.repl_input.collapse! - @window.repl_input_arrow.collapse! - end - @window.set_or_collapse(:complete_title, @chapter.summary.title) do |obj, value| - obj.text = value - end if @chapter.summary - @window.set_or_collapse(:complete_body, @chapter.summary.body) do |obj, value| - obj.document = FlowDocument.from_simple_markup value - end if @chapter.summary - @window.next_chapter.focus - else - if @current_tutorial.summary && @current_tutorial.summary.body - @window.exercise.document = FlowDocument.from_simple_markup(@current_tutorial.summary.body) - else - @window.exercise.document = FlowDocument.from_simple_markup("Tutorial complete!") - end - @window.exercise.show! - @window.tutorial_body.children.clear - @window.tutorial_scroll.scroll_to_top - end - end - end - - def process_result(result) - if @task and @task.success?(result) - select_next_task - end - end - end - - class Window - module Accessors - def current_step - @current_step ||= Step.new(Window.tutorial.task, current_step_id, Window.current) - end - - def current_step_id - @current_step_id || 0 - end - - def current_step? - respond_to?(:"step_#{current_step_id}") - end - - def current_step_object - current_step.object - end - - def next_step - complete.collapse! - if current_step? - repl_input.collapse! - repl_input_arrow.collapse! - end - - @current_step = nil - @current_step_id ||= -1 - @current_step_id += 1 - - current_step.show - end - - def reset_step - @current_step_id = 0 - @current_step = nil - end - - def cache_step(name, object) - instance_variable_set(:"@#{name}", object) - self.class.class_eval { attr_reader :"#{name}" } - end - - delegate_methods [:step_title, :step_description], :to => :current_step_object, :append => :current_step_id - - delegate_methods [:repl_input, :repl_input_arrow, :repl_history], - :to => :current_step_object, :prepend => 'step', :append => :current_step_id - end - - class << self - attr_reader :step_xaml, :tut_xaml - attr_reader :repl, :tutorial - - def current - @window ||= create - end - - def create - win = XamlReader.load xaml do |win| - win.main.children.clear - - GuiTutorial::Tutorial.all.each_with_index do |(path,tutorial), index| - tutorial_id, tutorial_title_id, tutorial_desc_id = "tutorial_#{index}", "tutorial_title_#{index}", "tutorial_desc_#{index}" - tutorial_id_OnMouseLeave_BeginStoryboard = "tutorial_#{index}_OnMouseLeave_BeginStoryboard" - - XamlReader.erb_load(@tut_xaml, binding) do |obj| - obj.send(tutorial_title_id).text = tutorial.name - - obj.send(tutorial_desc_id).document = tutorial.introduction - win.main.children.add obj - - obj.mouse_left_button_up do |t, e| - @tutorial = GuiTutorial::Tutorial.new(path, Window.current) - @tutorial.start - end - - obj.show! - end - end - show_main(win) - @repl = Repl.new - end - class << win - include Accessors - end - win - end - - def show_main(win = current) - win.header_name.text = 'Pick a tutorial' - win.main_scroll.show! - win.tutorial_scroll.collapse! - win.tutorial_nav.collapse! - win.complete.collapse! - if @tutorial - win.header_navigation.show! - win.header_navigation.action.text = "Resume tutorial" - win.header_navigation.action.mouse_left_button_up {|t,e| show_tutorial} - else - win.header_navigation.collapse! - end - end - - def show_tutorial - current.main_scroll.collapse! - current.tutorial_scroll.show! - current.tutorial_nav.show! unless SILVERLIGHT - current.complete.collapse! - current.header_name.text = @tutorial.current_tutorial.name - current.header_navigation.show! - current.header_navigation.action.text = "Back" - current.header_navigation.action.mouse_left_button_up {|t,e| show_main} - end - - def xaml - design = File.dirname(__FILE__) + '/design/' + (SILVERLIGHT ? 'TutorialSL' : 'Tutorial') - @step_xaml, @tut_xaml = ['Step', 'Tutorial'].map do |i| - sx = sanitize_xaml(File.open(design + "/#{i}Control.xaml"){|f| f.read}) - sx.sub!(/<UserControl.*?>(.*?)<\/UserControl>/, '\1') if i == 'Step' - sx.gsub!(/("|\{StaticResource )(\S*?)_id(\S*?)("|\})/, '\1<%= \2_id %>\3\4') - sx.strip - end - - sanitize_xaml( - File.open(design + "/Main#{SILVERLIGHT ? 'Page' : 'Window'}.xaml"){|f| f.read}. - gsub( - /<local:TutorialPage.*?\/>/, - File.open(design + "/TutorialPage.xaml"){|f| f.read}. - gsub(/<local:StepControl.*?\/>/, '')). - gsub(/<local:TutorialControl.*?\/>/, '') - ) - end - - private - def sanitize_xaml(xaml) - { - /x:Class=".*?"/ => '', - /xmlns:local=".*?"/ => '', - /mc:Ignorable=".*?"/ => '', - /xmlns:mc=".*?"/ => '', - /xmlns:d=".*?"/ => '', - 'Loaded="Window_Loaded"' => '', - '<TreeView ' => '<TreeView ItemTemplate="{StaticResource SectionTemplate}" ', - /\357\273\277/ => '', - /d:.*?=".*?"/ => '' - }.inject(xaml) do |_xaml,(k,v)| - _xaml.gsub(k, v) - end.gsub(/(\n|\t)/, ' ').squeeze(' ') - end - end - end - - class Step - @@vars = :step_id, - :step_title_id, :step_description_id, - :step_wrapper_id, :step_repl_id, - :step_repl_history_id, :step_repl_input_id, :step_repl_input_arrow_id - - attr_reader *@@vars - - attr_reader :object - - def initialize(task, element_id, window) - @task = task - @element_id = "step_#{element_id}" - @window = window - raise "Element #{@element_id} already exists" if @window.respond_to? @element_id - init_vars - end - - def show - @object = XamlReader.erb_load(Window.step_xaml, binding) do |obj| - @window.tutorial_body.children.add obj - @window.cache_step(@element_id, obj) - obj.show! - end - - Window.repl.prev_newline = nil - @window.repl_history.text = '' - - @window.repl_input.show! - Window.repl.set_prompt - Window.repl.context.reset_input - - # TODO - Should use TextChanged here - @window.repl_input.key_up do |target, event_args| - if event_args.key == Key.enter && !Window.tutorial.handling_next_chapter - Window.tutorial.process_result Window.repl.on_repl_input - elsif event_args.Key == (!SILVERLIGHT ? Key.System : Key.alt) - # This allows hitting Alt-Enter to automatically enter the code - # It is useful during manual testing of a tutorial's content - if @task.code.respond_to? :to_ary - @task.code.to_ary.each do |code| - Window.current.repl_input.text = code - Window.tutorial.process_result Window.repl.on_repl_input - end - else - Window.current.repl_input.text = @task.code - Window.tutorial.process_result Window.repl.on_repl_input - end - end - Window.tutorial.handling_next_chapter = false - end - - @window.repl_input_arrow.show! - @window.repl_input.focus - end - - private - def init_vars - @@vars.each do |v| - instance_variable_set( - :"@#{v}", - "#{v.to_s.split('_id').first}_#{@window.current_step_id}" - ) - end - end - end - - class Repl - attr_accessor :prev_newline - attr_accessor :context - - def self.repl_puts *a - repl_visible = Window.complete.visibility == System::Windows::Visibility.visible rescue false - if Thread.current[:evaluating_tutorial_input] or not repl_visible - # This is a synchronous "puts" being executed when the user has pressed "Enter" to execute - # a command. In this case, we do the default processing. This ensures that the output - # will get captured in Tutorial::InteractionResult.output, along with any "puts" executed - # by any Ruby files that run - ::Kernel.puts *a - else - # This is an async "puts". It does not make sense to capture this into Tutorial::InteractionResult.output. - # We just ensure that it gets printed in the REPL - a.each { |i| WpfTutorial.tutorial.print_to_repl i.to_s, true } - nil - end - end - - def initialize - @context = ::Tutorial::ReplContext.new - @prev_newline = nil - - # Hook-up "puts" so that we can redirect asynchronous "puts" (typically called from event-handlers) - atleast - # the ones that are entered into the REPL - class << @context.scope - def puts *a - Repl.repl_puts *a - end - end - end - - def history - Window.current.repl_history - end - - def input - Window.current.repl_input - end - - def print(s, new_line = true) - history.text += s - history.text += "\n" if new_line - end - - def set_prompt p = ">>>" - @prompt = p - Window.current.repl_input_arrow.content = p - end - - def on_repl_input - puts "in on_repl_input" - print '' if @prev_newline - history.show! - - input = self.input.text - print "#{@prompt} #{input}" - set_prompt - self.input.text = '' - - result = @context.interact input - print result.output, false unless result.output.empty? - if result.partial_input? - set_prompt "..." - elsif result.error - print result.error.to_s - else - print "=> #{result.result.inspect}" - end - - if history.text.size > 1 - # TODO should be able to do str[-1] on a clrstring - @prev_newline = history.text.to_s[-1] == 10 # '\n' - history.text = history.text.to_s[0..-2].to_clr_string - end - result - end - end - -end +$:.unshift File.dirname(__FILE__) + "/Libs" + +require File.dirname(__FILE__) + '/wpf' +include Wpf + +require 'tutorial' + +module GuiTutorial + + class Tutorial + attr_reader :tasks, :task, :chapter, :current_tutorial + + # TODO: Figure out how to remove this condition: + # + # When the "next_chapter" button is focused and the enter-button is pressed, + # somewhere along that process the "repl_input" TextBox gets focus, but + # then the "repl_input.key_up" fires from the previous enter-button press, + # causing two extra lines in the repl history. + # + # This flag shunts the first key_up event, and then is set back to false. + # This ignores all first-keypresses that are "enter", hackily removing the + # issue, since "enter" should never really be the first key pressed. + # Definitely not a perfect solution. + attr_accessor :handling_next_chapter + + def initialize(t, window) + @current_tutorial ||= ::Tutorial.get_tutorial(t) + @window = GuiTutorial::Window.current + end + + def self.all + @tutorials ||= ::Tutorial.all + end + + def reset + @chapter = nil + @tasks = nil + @window.tutorial_body.children.clear + end + + def start + reset + Window.show_tutorial + + unless SILVERLIGHT + @window.chapters.items_source = @current_tutorial.sections + @window.chapters.mouse_left_button_up do |t, e| + select_section_or_chapter t.selected_item + end + end + + @window.next_chapter.click do |t, e| + @handling_next_chapter = true + select_section_or_chapter @chapter.next_item if @chapter + end + + select_chapter(@current_tutorial.first_chapter, @current_tutorial.first_section) + end + + def select_section_or_chapter(item) + return unless item + case item + when ::Tutorial::Section: select_section item + when ::Tutorial::Chapter: select_chapter item + else + raise "Unknown selection type: #{item}" + end + end + + def select_chapter(chapter, section = nil) + if section + @window.set_or_collapse(:pre_exercise, section.introduction) do |obj, value| + obj.document = value + end + else + @window.pre_exercise.collapse! + end + @chapter = chapter + @window.set_or_collapse(:exercise, @chapter.introduction) do |obj, value| + obj.document = value + end + + @window.tutorial_body.children.clear + @tasks = @chapter.tasks.clone + select_next_task + end + + def select_section(section) + reset + @window.set_or_collapse(:exercise, section.introduction) do |obj, value| + obj.document = value + end + @window.pre_exercise.collapse! + end + + def select_next_task + unless @tasks.empty? + begin @task = @tasks.shift end until @task.should_run? Window.repl.context.bind + @window.next_step + if @task.description + fd = FlowDocument.from_simple_markup @task.description + fd << "Full path: #{@task.source_files.tr('/', '\\')}" if @task.source_files + @task.setup.call(Window.repl.context.bind) if @task.setup + if @task.code + unless SILVERLIGHT + p = Paragraph.new Run.new(@task.code_string) + p.font_family = FontFamily.new "Consolas" + p.font_weight = FontWeights.Bold + fd.Blocks.Add p + else + fd += "\n\n#{@task.code_string}" + end + end + end + @window.set_or_collapse(:step_title, @task.title) do |obj, value| + obj.text = value + end + + @window.step_description.document = fd + @window.tutorial_scroll.scroll_to_bottom + else + if @chapter.next_item + @window.complete.show! + @window.tutorial_scroll.scroll_to_bottom + if @window.current_step? + @window.repl_input.collapse! + @window.repl_input_arrow.collapse! + end + @window.set_or_collapse(:complete_title, @chapter.summary.title) do |obj, value| + obj.text = value + end if @chapter.summary + @window.set_or_collapse(:complete_body, @chapter.summary.body) do |obj, value| + obj.document = FlowDocument.from_simple_markup value + end if @chapter.summary + @window.next_chapter.focus + else + if @current_tutorial.summary && @current_tutorial.summary.body + @window.exercise.document = FlowDocument.from_simple_markup(@current_tutorial.summary.body) + else + @window.exercise.document = FlowDocument.from_simple_markup("Tutorial complete!") + end + @window.exercise.show! + @window.tutorial_body.children.clear + @window.tutorial_scroll.scroll_to_top + end + end + end + + def process_result(result) + if @task and @task.success?(result) + select_next_task + end + end + end + + class Window + module Accessors + def current_step + @current_step ||= Step.new(Window.tutorial.task, current_step_id, Window.current) + end + + def current_step_id + @current_step_id || 0 + end + + def current_step? + respond_to?(:"step_#{current_step_id}") + end + + def current_step_object + current_step.object + end + + def next_step + complete.collapse! + if current_step? + repl_input.collapse! + repl_input_arrow.collapse! + end + + @current_step = nil + @current_step_id ||= -1 + @current_step_id += 1 + + current_step.show + end + + def reset_step + @current_step_id = 0 + @current_step = nil + end + + def cache_step(name, object) + instance_variable_set(:"@#{name}", object) + self.class.class_eval { attr_reader :"#{name}" } + end + + delegate_methods [:step_title, :step_description], :to => :current_step_object, :append => :current_step_id + + delegate_methods [:repl_input, :repl_input_arrow, :repl_history], + :to => :current_step_object, :prepend => 'step', :append => :current_step_id + end + + class << self + attr_reader :step_xaml, :tut_xaml + attr_reader :repl, :tutorial + + def current + @window ||= create + end + + def create + win = XamlReader.load xaml do |win| + win.main.children.clear + + GuiTutorial::Tutorial.all.each_with_index do |(path,tutorial), index| + tutorial_id, tutorial_title_id, tutorial_desc_id = "tutorial_#{index}", "tutorial_title_#{index}", "tutorial_desc_#{index}" + tutorial_id_OnMouseLeave_BeginStoryboard = "tutorial_#{index}_OnMouseLeave_BeginStoryboard" + + XamlReader.erb_load(@tut_xaml, binding) do |obj| + obj.send(tutorial_title_id).text = tutorial.name + + obj.send(tutorial_desc_id).document = tutorial.introduction + win.main.children.add obj + + obj.mouse_left_button_up do |t, e| + @tutorial = GuiTutorial::Tutorial.new(path, Window.current) + @tutorial.start + end + + obj.show! + end + end + show_main(win) + @repl = Repl.new + end + class << win + include Accessors + end + win + end + + def show_main(win = current) + win.header_name.text = 'Pick a tutorial' + win.main_scroll.show! + win.tutorial_scroll.collapse! + win.tutorial_nav.collapse! + win.complete.collapse! + if @tutorial + win.header_navigation.show! + win.header_navigation.action.text = "Resume tutorial" + win.header_navigation.action.mouse_left_button_up {|t,e| show_tutorial} + else + win.header_navigation.collapse! + end + end + + def show_tutorial + current.main_scroll.collapse! + current.tutorial_scroll.show! + current.tutorial_nav.show! unless SILVERLIGHT + current.complete.collapse! + current.header_name.text = @tutorial.current_tutorial.name + current.header_navigation.show! + current.header_navigation.action.text = "Back" + current.header_navigation.action.mouse_left_button_up {|t,e| show_main} + end + + def xaml + design = File.dirname(__FILE__) + '/design/' + (SILVERLIGHT ? 'TutorialSL' : 'Tutorial') + @step_xaml, @tut_xaml = ['Step', 'Tutorial'].map do |i| + sx = sanitize_xaml(File.open(design + "/#{i}Control.xaml"){|f| f.read}) + sx.sub!(/<UserControl.*?>(.*?)<\/UserControl>/, '\1') if i == 'Step' + sx.gsub!(/("|\{StaticResource )(\S*?)_id(\S*?)("|\})/, '\1<%= \2_id %>\3\4') + sx.strip + end + + sanitize_xaml( + File.open(design + "/Main#{SILVERLIGHT ? 'Page' : 'Window'}.xaml"){|f| f.read}. + gsub( + /<local:TutorialPage.*?\/>/, + File.open(design + "/TutorialPage.xaml"){|f| f.read}. + gsub(/<local:StepControl.*?\/>/, '')). + gsub(/<local:TutorialControl.*?\/>/, '') + ) + end + + private + def sanitize_xaml(xaml) + { + /x:Class=".*?"/ => '', + /xmlns:local=".*?"/ => '', + /mc:Ignorable=".*?"/ => '', + /xmlns:mc=".*?"/ => '', + /xmlns:d=".*?"/ => '', + 'Loaded="Window_Loaded"' => '', + '<TreeView ' => '<TreeView ItemTemplate="{StaticResource SectionTemplate}" ', + /\357\273\277/ => '', + /d:.*?=".*?"/ => '' + }.inject(xaml) do |_xaml,(k,v)| + _xaml.gsub(k, v) + end.gsub(/(\n|\t)/, ' ').squeeze(' ') + end + end + end + + class Step + @@vars = :step_id, + :step_title_id, :step_description_id, + :step_wrapper_id, :step_repl_id, + :step_repl_history_id, :step_repl_input_id, :step_repl_input_arrow_id + + attr_reader *@@vars + + attr_reader :object + + def initialize(task, element_id, window) + @task = task + @element_id = "step_#{element_id}" + @window = window + raise "Element #{@element_id} already exists" if @window.respond_to? @element_id + init_vars + end + + def show + @object = XamlReader.erb_load(Window.step_xaml, binding) do |obj| + @window.tutorial_body.children.add obj + @window.cache_step(@element_id, obj) + obj.show! + end + + Window.repl.prev_newline = nil + @window.repl_history.text = '' + + @window.repl_input.show! + Window.repl.set_prompt + Window.repl.context.reset_input + + # TODO - Should use TextChanged here + @window.repl_input.key_up do |target, event_args| + if event_args.key == Key.enter && !Window.tutorial.handling_next_chapter + Window.tutorial.process_result Window.repl.on_repl_input + elsif event_args.Key == (!SILVERLIGHT ? Key.System : Key.alt) + # This allows hitting Alt-Enter to automatically enter the code + # It is useful during manual testing of a tutorial's content + if @task.code.respond_to? :to_ary + @task.code.to_ary.each do |code| + Window.current.repl_input.text = code + Window.tutorial.process_result Window.repl.on_repl_input + end + else + Window.current.repl_input.text = @task.code + Window.tutorial.process_result Window.repl.on_repl_input + end + end + Window.tutorial.handling_next_chapter = false + end + + @window.repl_input_arrow.show! + @window.repl_input.focus + end + + private + def init_vars + @@vars.each do |v| + instance_variable_set( + :"@#{v}", + "#{v.to_s.split('_id').first}_#{@window.current_step_id}" + ) + end + end + end + + class Repl + attr_accessor :prev_newline + attr_accessor :context + + def self.repl_puts *a + repl_visible = Window.complete.visibility == System::Windows::Visibility.visible rescue false + if Thread.current[:evaluating_tutorial_input] or not repl_visible + # This is a synchronous "puts" being executed when the user has pressed "Enter" to execute + # a command. In this case, we do the default processing. This ensures that the output + # will get captured in Tutorial::InteractionResult.output, along with any "puts" executed + # by any Ruby files that run + ::Kernel.puts *a + else + # This is an async "puts". It does not make sense to capture this into Tutorial::InteractionResult.output. + # We just ensure that it gets printed in the REPL + a.each { |i| WpfTutorial.tutorial.print_to_repl i.to_s, true } + nil + end + end + + def initialize + @context = ::Tutorial::ReplContext.new + @prev_newline = nil + + # Hook-up "puts" so that we can redirect asynchronous "puts" (typically called from event-handlers) - atleast + # the ones that are entered into the REPL + class << @context.scope + def puts *a + Repl.repl_puts *a + end + end + end + + def history + Window.current.repl_history + end + + def input + Window.current.repl_input + end + + def print(s, new_line = true) + history.text += s + history.text += "\n" if new_line + end + + def set_prompt p = ">>>" + @prompt = p + Window.current.repl_input_arrow.content = p + end + + def on_repl_input + print '' if @prev_newline + history.show! + + input = self.input.text + print "#{@prompt} #{input}" + set_prompt + self.input.text = '' + + result = @context.interact input + print result.output, false unless result.output.empty? + if result.partial_input? + set_prompt "..." + elsif result.error + print result.error.to_s + else + print "=> #{result.result.inspect}" + end + + if history.text.size > 1 + # TODO should be able to do str[-1] on a clrstring + @prev_newline = history.text.to_s[-1] == 10 # '\n' + history.text = history.text.to_s[0..-2].to_clr_string + end + result + end + end + +end Merlin/Main/Languages/Ruby/Samples/Tutorial/gui_tutorial.rb @@ -1,114 +1,114 @@ -<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> -<html xmlns="http://www.w3.org/1999/xhtml" > -<head> - <title>Silverlight Template</title> - - <!-- Basic stylesheet for application --> - <link type="text/css" rel="stylesheet" href="css/screen.css" /> - - <!-- Defines "onSilverlightError" function for Silverlight plugin --> - <script type="text/javascript" src="js/error.js"></script> -</head> - -<body> - <!-- - Runtime errors from Silverlight will be displayed here. - This will contain debugging information and should be - removed or hidden when debugging is completed - --> - <div id='errorLocation'></div> - - <div id="silverlightControlHost"> - - <!-- - Silverlight plug-in control - http://msdn.microsoft.com/en-us/library/cc189089(VS.95).aspx#silverlight_plug_in_configuring - --> - <object data="data:application/x-silverlight," type="application/x-silverlight-2" width="100%" height="100%"> - - <!-- - "source" points to the actual Silverlight application - If using "Chiron /w", value should be the "<your app folder>.xap" - --> - <param name="source" value="../Tutorial.xap"/> - - <!-- - "initParams" is a comma-seperated way to pass key=value pair arguments - into your Silverlight application. Dynamic Languages use special - arguments to configure the application: - - * start = app.(rb|py|js) - - this is the entry-point file to the application. - - By default, it will look for any file named "app", regardless of - the extension. The extension will be used to figure out the language. - - This option can be set to anything you want, but it must include - the extension. - - * debug = [true]|false - - Runs your code as debug-able; stack traces will be shown if an error - occurs. - - This lets you attach the browser to the Visual Studio - debugger and step through the running program (only when the - Silverlight tools are installed). - - When omitted/set to false, all errors will be silent - (for deployment purposes) - - * reportErrors = [HTML-element-ID] - - In the event of an error, the error window will be written into the - innerHTML property of the HTML element with an ID attribute matching - the value of this field. - - If there is no matching ID, a HTML element is created with that ID, - and the error window inserted. - - If this field is omitted, no errors will be shown. - + You can define the "onerror" param, which will let you handle any - error with JavaScript (the index.html templates do this, if you - want sample code). - - * exceptionDetail = true|[false] - - If set to true, this will also show the entire managed stack trace - in the error window rather than just the dynamic stack trace. - This is useful when debugging C#/Visual Basic when called from a - dynamic language. - - * console = true|[false] - - If set to true, will show a read-eval-print loop (REPL) window at - the bottom of the page, for whatever language the start script is in. - --> - <param name="initParams" value="start=sl_tutorial.rb, debug=true, reportErrors=errorLocation, console=true" /> - - <!-- Handle all Silverlight errors with function defined in javascripts/error.js --> - <param name="onerror" value="onSilverlightError" /> - - <!-- - Other properties of the Silverlight plug-in. For documentation on this, see: - http://msdn.microsoft.com/en-us/library/cc189089(VS.95).aspx#silverlight_plug_in_configuring - --> - <param name="background" value="white" /> - <param name="windowless" value="true" /> - - <!-- - <param name="minRuntimeVersion" value="2.0.31005.0" /> - <param name="autoUpgrade" value="true" /> - --> - - <!-- - Shows a "Install Microsoft Silverlight" link if Silverlight is - not installed - --> - <a href="http://go.microsoft.com/fwlink/?LinkID=124807" style="text-decoration: none;"> - <img src="http://go.microsoft.com/fwlink/?LinkId=108181" alt="Get Microsoft Silverlight" style="border-style: none"/> - </a> - - </object> - - <!-- - <iframe> needed to prevent Safari from caching the page and reloading - the plugin when the user navigates back to a previously-visted - Silverlight page. - --> - <iframe style='visibility:hidden;height:0;width:0;border:0px'></iframe> - - </div> - -</body> -</html> +<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> +<html xmlns="http://www.w3.org/1999/xhtml" > +<head> + <title>Silverlight Template</title> + + <!-- Basic stylesheet for application --> + <link type="text/css" rel="stylesheet" href="css/screen.css" /> + + <!-- Defines "onSilverlightError" function for Silverlight plugin --> + <script type="text/javascript" src="js/error.js"></script> +</head> + +<body> + <!-- + Runtime errors from Silverlight will be displayed here. + This will contain debugging information and should be + removed or hidden when debugging is completed + --> + <div id='errorLocation'></div> + + <div id="silverlightControlHost"> + + <!-- + Silverlight plug-in control + http://msdn.microsoft.com/en-us/library/cc189089(VS.95).aspx#silverlight_plug_in_configuring + --> + <object data="data:application/x-silverlight," type="application/x-silverlight-2" width="100%" height="100%"> + + <!-- + "source" points to the actual Silverlight application + If using "Chiron /w", value should be the "<your app folder>.xap" + --> + <param name="source" value="../Tutorial.xap"/> + + <!-- + "initParams" is a comma-seperated way to pass key=value pair arguments + into your Silverlight application. Dynamic Languages use special + arguments to configure the application: + + * start = app.(rb|py|js) + - this is the entry-point file to the application. + - By default, it will look for any file named "app", regardless of + the extension. The extension will be used to figure out the language. + - This option can be set to anything you want, but it must include + the extension. + + * debug = [true]|false + - Runs your code as debug-able; stack traces will be shown if an error + occurs. + - This lets you attach the browser to the Visual Studio + debugger and step through the running program (only when the + Silverlight tools are installed). + - When omitted/set to false, all errors will be silent + (for deployment purposes) + + * reportErrors = [HTML-element-ID] + - In the event of an error, the error window will be written into the + innerHTML property of the HTML element with an ID attribute matching + the value of this field. + - If there is no matching ID, a HTML element is created with that ID, + and the error window inserted. + - If this field is omitted, no errors will be shown. + + You can define the "onerror" param, which will let you handle any + error with JavaScript (the index.html templates do this, if you + want sample code). + + * exceptionDetail = true|[false] + - If set to true, this will also show the entire managed stack trace + in the error window rather than just the dynamic stack trace. + This is useful when debugging C#/Visual Basic when called from a + dynamic language. + + * console = true|[false] + - If set to true, will show a read-eval-print loop (REPL) window at + the bottom of the page, for whatever language the start script is in. + --> + <param name="initParams" value="start=sl_tutorial.rb, debug=true, reportErrors=errorLocation, console=true" /> + + <!-- Handle all Silverlight errors with function defined in javascripts/error.js --> + <param name="onerror" value="onSilverlightError" /> + + <!-- + Other properties of the Silverlight plug-in. For documentation on this, see: + http://msdn.microsoft.com/en-us/library/cc189089(VS.95).aspx#silverlight_plug_in_configuring + --> + <param name="background" value="white" /> + <param name="windowless" value="true" /> + + <!-- + <param name="minRuntimeVersion" value="2.0.31005.0" /> + <param name="autoUpgrade" value="true" /> + --> + + <!-- + Shows a "Install Microsoft Silverlight" link if Silverlight is + not installed + --> + <a href="http://go.microsoft.com/fwlink/?LinkID=124807" style="text-decoration: none;"> + <img src="http://go.microsoft.com/fwlink/?LinkId=108181" alt="Get Microsoft Silverlight" style="border-style: none"/> + </a> + + </object> + + <!-- + <iframe> needed to prevent Safari from caching the page and reloading + the plugin when the user navigates back to a previously-visted + Silverlight page. + --> + <iframe style='visibility:hidden;height:0;width:0;border:0px'></iframe> + + </div> + +</body> +</html> Merlin/Main/Languages/Ruby/Samples/Tutorial/index.html @@ -1,32 +1,32 @@ -function onSilverlightError(sender, args) { - var appSource = ""; - if (sender != null && sender != 0) { - appSource = sender.getHost().Source; - } - var errorType = args.ErrorType; - var iErrorCode = args.ErrorCode; - - var errMsg = "Unhandled Error in Silverlight 2 Application " + appSource + "\n" ; - - errMsg += "Code: "+ iErrorCode + " \n"; - errMsg += "Category: " + errorType + " \n"; - errMsg += "Message: " + args.ErrorMessage + " \n"; - - if (errorType == "ParserError") - { - errMsg += "File: " + args.xamlFile + " \n"; - errMsg += "Line: " + args.lineNumber + " \n"; - errMsg += "Position: " + args.charPosition + " \n"; - } - else if (errorType == "RuntimeError") - { - if (args.lineNumber != 0) - { - errMsg += "Line: " + args.lineNumber + " \n"; - errMsg += "Position: " + args.charPosition + " \n"; - } - errMsg += "MethodName: " + args.methodName + " \n"; - } - - throw new Error(errMsg); -} +function onSilverlightError(sender, args) { + var appSource = ""; + if (sender != null && sender != 0) { + appSource = sender.getHost().Source; + } + var errorType = args.ErrorType; + var iErrorCode = args.ErrorCode; + + var errMsg = "Unhandled Error in Silverlight 2 Application " + appSource + "\n" ; + + errMsg += "Code: "+ iErrorCode + " \n"; + errMsg += "Category: " + errorType + " \n"; + errMsg += "Message: " + args.ErrorMessage + " \n"; + + if (errorType == "ParserError") + { + errMsg += "File: " + args.xamlFile + " \n"; + errMsg += "Line: " + args.lineNumber + " \n"; + errMsg += "Position: " + args.charPosition + " \n"; + } + else if (errorType == "RuntimeError") + { + if (args.lineNumber != 0) + { + errMsg += "Line: " + args.lineNumber + " \n"; + errMsg += "Position: " + args.charPosition + " \n"; + } + errMsg += "MethodName: " + args.methodName + " \n"; + } + + throw new Error(errMsg); +} Merlin/Main/Languages/Ruby/Samples/Tutorial/js/error.js @@ -1,22 +1,22 @@ -# **************************************************************************** -# -# 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. -# -# -# **************************************************************************** - -include Microsoft::Scripting::Silverlight -$stdout = Repl.current.output_buffer -$stderr = Repl.current.output_buffer - -require 'gui_tutorial' - -Application.Current.RootVisual = GuiTutorial::Window.current +# **************************************************************************** +# +# 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. +# +# +# **************************************************************************** + +include Microsoft::Scripting::Silverlight +$stdout = Repl.current.output_buffer +$stderr = Repl.current.output_buffer + +require 'gui_tutorial' + +Application.Current.RootVisual = GuiTutorial::Window.current Merlin/Main/Languages/Ruby/Samples/Tutorial/sl_tutorial.rb @@ -1 +1 @@ -"%~dp0..\..\..\..\Bin\Silverlight Release\Chiron.exe" /b:Tutorial/index.html /d:"%~dp0.." +"%~dp0..\..\..\..\Bin\Silverlight Release\Chiron.exe" /b:Tutorial/index.html /d:"%~dp0.." Merlin/Main/Languages/Ruby/Samples/Tutorial/tutorial-sl.bat @@ -1 +1,17 @@ -"%~dp0..\..\..\..\Bin\Release\ir.exe" %~dp0wpf_tutorial.rb %* +@echo off +setlocal ENABLEDELAYEDEXPANSION + +set IR_CMD="%~dp0ir.exe" +if defined MERLIN_ROOT ( + REM - This is a dev environment. See http://wiki.github.com/ironruby/ironruby + if not EXIST !IR_CMD! set IR_CMD="%~dp0..\..\..\..\Bin\Release\ir.exe" + if not EXIST !IR_CMD! set IR_CMD="%MERLIN_ROOT%\bin\Debug\ir.exe" + if not EXIST !IR_CMD! ( + echo Could not find ir.exe + goto END + ) +) + +%IR_CMD% %~dp0wpf_tutorial.rb %* + +:END Merlin/Main/Languages/Ruby/Samples/Tutorial/tutorial.bat @@ -15,6 +15,8 @@ require "stringio" +SILVERLIGHT = false unless defined? SILVERLIGHT + module Tutorial class Summary Merlin/Main/Languages/Ruby/Samples/Tutorial/tutorial.rb @@ -42,20 +42,6 @@ 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 ( - if DEFINED HOMEDRIVE ( - if DEFINED HOMEPATH ( - set HOME=%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=%USERPROFILE% -) - :SetRubyEnv if NOT exist "%HOME%\.mspecrc" ( Merlin/Main/Languages/Ruby/Scripts/Dev.bat @@ -15,14 +15,14 @@ describe "System::String.new" do before(:each) do @a = Klass.new.a - @aa = Klass.new.aa + @aa = Klass.new.Aa end it "returns a new System::String from the argument" do System::String.new("a").should == Klass.new.a 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::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 end end Merlin/Main/Languages/Ruby/Tests/Interop/net/bcl/string/construction_spec.rb @@ -68,7 +68,7 @@ describe "Reading .NET Fields" do it_behaves_like :accessing_fields, nil end - if IronRuby.dlr_config.private_binding + if IronRuby.configuration.private_binding describe "works with private" do before(:each) do @result = { @@ -137,7 +137,7 @@ describe "Setting .NET Fields" do end end - if IronRuby.dlr_config.private_binding + if IronRuby.configuration.private_binding describe "with private" do it "fields works" do @klass.privateField = "bar" Merlin/Main/Languages/Ruby/Tests/Interop/net/fields/access_spec.rb @@ -155,7 +155,7 @@ describe :generic_methods, :shared => true do @klass.method(:type_constraint_method).of(SubKlass, Klass).call(SubKlass.new).foo.should == 10 end - if IronRuby.dlr_config.private_binding + if IronRuby.configuration.private_binding it "are callable via call and [] when private" do @private_method_list.each do |m| generic_count, arity = m.match(/_(\d)_generic_(\d)_/)[1..2].map {|e| e.to_i} Merlin/Main/Languages/Ruby/Tests/Interop/net/method/invocation/generic_spec.rb @@ -68,7 +68,11 @@ class TestGemRemoteFetcher def test_zip() end def test_request_unmodifed() end end - +#Fails with RangeError: bignum too big to convert into `long' +class TestGemSpecification + def test_files_non_array_pathological() end + def test_hash() end +end class TestGemValidator def test_verify_gem_file_empty() end end @@ -80,3 +84,9 @@ class TestTarWriter def test_close() end def test_mkdir() end end + +class TestGemSourceInfoCache + # Fails non-deterministically with this message + # Expected /Bulk updating/ to match "". + def test_self_cache_refreshes() end +end Merlin/Main/Languages/Ruby/Tests/Scripts/RubyGemsTests.rb @@ -88,7 +88,7 @@ namespace Microsoft.Scripting.Actions { /// <summary> /// Converts the provided expression to the given type. The expression is safe to evaluate multiple times. /// </summary> - public virtual Expression ConvertExpression(Expression expr, Type toType, ConversionResultKind kind, Expression context) { + public virtual Expression ConvertExpression(Expression expr, Type toType, ConversionResultKind kind, OverloadResolverFactory resolverFactory) { ContractUtils.RequiresNotNull(expr, "expr"); ContractUtils.RequiresNotNull(toType, "toType"); @@ -107,12 +107,6 @@ namespace Microsoft.Scripting.Actions { } Type visType = CompilerHelpers.GetVisibleType(toType); - Expression[] args; - if (context != null) { - args = new Expression[] { context, expr }; - } else { - args = new Expression[] { expr }; - } return Expression.Convert(expr, toType); } @@ -193,8 +187,8 @@ namespace Microsoft.Scripting.Actions { ); } - public ErrorInfo MakeStaticPropertyInstanceAccessError(PropertyTracker tracker, bool isAssignment, params Expression[] parameters) { - return MakeStaticPropertyInstanceAccessError(tracker, isAssignment, (IList<Expression>)parameters); + public ErrorInfo MakeStaticPropertyInstanceAccessError(PropertyTracker tracker, bool isAssignment, params DynamicMetaObject[] parameters) { + return MakeStaticPropertyInstanceAccessError(tracker, isAssignment, (IList<DynamicMetaObject>)parameters); } /// <summary> @@ -202,7 +196,7 @@ namespace Microsoft.Scripting.Actions { /// /// The default behavior is to allow the assignment. /// </summary> - public virtual ErrorInfo MakeStaticAssignFromDerivedTypeError(Type accessingType, DynamicMetaObject self, MemberTracker assigning, Expression assignedValue, Expression context) { + public virtual ErrorInfo MakeStaticAssignFromDerivedTypeError(Type accessingType, DynamicMetaObject self, MemberTracker assigning, DynamicMetaObject assignedValue, OverloadResolverFactory context) { switch (assigning.MemberType) { case TrackerTypes.Property: PropertyTracker pt = (PropertyTracker)assigning; @@ -211,7 +205,7 @@ namespace Microsoft.Scripting.Actions { AstUtils.SimpleCallHelper( setter, ConvertExpression( - assignedValue, + assignedValue.Expression, setter.GetParameters()[0].ParameterType, ConversionResultKind.ExplicitCast, context @@ -223,7 +217,7 @@ namespace Microsoft.Scripting.Actions { return ErrorInfo.FromValueNoError( Expression.Assign( Expression.Field(null, ft.Field), - ConvertExpression(assignedValue, ft.FieldType, ConversionResultKind.ExplicitCast, context) + ConvertExpression(assignedValue.Expression, ft.FieldType, ConversionResultKind.ExplicitCast, context) ) ); default: @@ -241,7 +235,7 @@ namespace Microsoft.Scripting.Actions { /// <param name="parameters">The parameters being used to access the property. This includes the instance as the first entry, any index parameters, and the /// value being assigned as the last entry if isAssignment is true.</param> /// <returns></returns> - public virtual ErrorInfo MakeStaticPropertyInstanceAccessError(PropertyTracker tracker, bool isAssignment, IList<Expression> parameters) { + public virtual ErrorInfo MakeStaticPropertyInstanceAccessError(PropertyTracker tracker, bool isAssignment, IList<DynamicMetaObject> parameters) { ContractUtils.RequiresNotNull(tracker, "tracker"); ContractUtils.Requires(tracker.IsStatic, "tracker", Strings.ExpectedStaticProperty); ContractUtils.RequiresNotNull(parameters, "parameters"); @@ -296,46 +290,7 @@ namespace Microsoft.Scripting.Actions { } #endregion - - #region Deprecated Error production - - - /// <summary> - /// Provides a way for the binder to provide a custom error message when lookup fails. Just - /// doing this for the time being until we get a more robust error return mechanism. - /// </summary> - public virtual Expression MakeReadOnlyMemberError(RuleBuilder rule, Type type, string name) { - return rule.MakeError( - Expression.New( - typeof(MissingMemberException).GetConstructor(new Type[] { typeof(string) }), - AstUtils.Constant(name) - ) - ); - } - - /// <summary> - /// Provides a way for the binder to provide a custom error message when lookup fails. Just - /// doing this for the time being until we get a more robust error return mechanism. - /// </summary> - public virtual Expression MakeUndeletableMemberError(RuleBuilder rule, Type type, string name) { - return MakeReadOnlyMemberError(rule, type, name); - } - - #endregion - - public virtual ErrorInfo MakeEventValidation(RuleBuilder rule, MemberGroup members) { - EventTracker ev = (EventTracker)members[0]; - - // handles in place addition of events - this validates the user did the right thing. - return ErrorInfo.FromValueNoError( - Expression.Call( - typeof(ScriptingRuntimeHelpers).GetMethod("SetEvent"), - AstUtils.Constant(ev), - rule.Parameters[1] - ) - ); - } - + public virtual string GetTypeName(Type t) { return t.Name; } @@ -429,65 +384,44 @@ namespace Microsoft.Scripting.Actions { /// <param name="memberTracker">The member which is being returned to the user.</param> /// <param name="type">Tthe type which the memberTrack was accessed from</param> /// <returns></returns> - public virtual Expression ReturnMemberTracker(Type type, MemberTracker memberTracker) { + public virtual DynamicMetaObject ReturnMemberTracker(Type type, MemberTracker memberTracker) { if (memberTracker.MemberType == TrackerTypes.Bound) { BoundMemberTracker bmt = (BoundMemberTracker)memberTracker; - return Expression.New( - typeof(BoundMemberTracker).GetConstructor(new Type[] { typeof(MemberTracker), typeof(object) }), - AstUtils.Constant(bmt.BoundTo), - bmt.Instance); + return new DynamicMetaObject( + Expression.New( + typeof(BoundMemberTracker).GetConstructor(new Type[] { typeof(MemberTracker), typeof(object) }), + AstUtils.Constant(bmt.BoundTo), + bmt.Instance.Expression + ), + BindingRestrictions.Empty + ); } - return AstUtils.Constant(memberTracker); + return new DynamicMetaObject(AstUtils.Constant(memberTracker), BindingRestrictions.Empty, memberTracker); } - /// <summary> - /// Builds an expression for a call to the provided method using the given expressions. If the - /// method is not static the first parameter is used for the instance. - /// - /// Parameters are converted using the binder's conversion rules. - /// - /// If an incorrect number of parameters is provided MakeCallExpression returns null. - /// </summary> - public Expression MakeCallExpression(Expression context, MethodInfo method, IList<Expression> parameters) { - ParameterInfo[] infos = method.GetParameters(); - Expression callInst = null; - int parameter = 0, startArg = 0; - Expression[] callArgs = new Expression[infos.Length]; - - if (!method.IsStatic) { - callInst = AstUtils.Convert(parameters[0], method.DeclaringType); - parameter = 1; - } - if (infos.Length > 0 && typeof(CodeContext).IsAssignableFrom(infos[0].ParameterType)) { - startArg = 1; - callArgs[0] = context; + public DynamicMetaObject MakeCallExpression(OverloadResolverFactory resolverFactory, MethodInfo method, params DynamicMetaObject[] parameters) { + OverloadResolver resolver; + if (method.IsStatic) { + resolver = resolverFactory.CreateOverloadResolver(parameters, new CallSignature(parameters.Length), CallTypes.None); + } else { + resolver = resolverFactory.CreateOverloadResolver(parameters, new CallSignature(parameters.Length - 1), CallTypes.ImplicitInstance); } + BindingTarget target = resolver.ResolveOverload(method.Name, new MethodBase[] { method }, NarrowingLevel.None, NarrowingLevel.Three); - for (int arg = startArg; arg < infos.Length; arg++) { - if (parameter < parameters.Count) { - callArgs[arg] = ConvertExpression( - parameters[parameter++], - infos[arg].ParameterType, - ConversionResultKind.ExplicitCast, - context - ); - } else { - return null; + if (!target.Success) { + BindingRestrictions restrictions = BindingRestrictions.Combine(parameters); + foreach (DynamicMetaObject mo in parameters) { + restrictions = restrictions.Merge(BindingRestrictions.GetTypeRestriction(mo.Expression, mo.GetLimitType())); } + return DefaultBinder.MakeError( + resolver.MakeInvalidParametersError(target), + restrictions, + typeof(object) + ); } - // check that we used all parameters - if (parameter != parameters.Count) { - return null; - } - - return AstUtils.SimpleCallHelper(callInst, method, callArgs); - } - - - public Expression MakeCallExpression(Expression context, MethodInfo method, params Expression[] parameters) { - return MakeCallExpression(context, method, (IList<Expression>)parameters); + return new DynamicMetaObject(target.MakeExpression(), target.RestrictedArguments.GetAllRestrictions()); } } } Merlin/Main/Runtime/Microsoft.Scripting/Actions/ActionBinder.cs @@ -14,15 +14,16 @@ * ***************************************************************************/ using System; -using System.Linq.Expressions; +using System.Dynamic; +using Microsoft.Scripting.Actions.Calls; namespace Microsoft.Scripting.Actions { public class BoundMemberTracker : MemberTracker { - private Expression _instance; + private DynamicMetaObject _instance; private MemberTracker _tracker; private object _objInst; - public BoundMemberTracker(MemberTracker tracker, Expression instance) { + public BoundMemberTracker(MemberTracker tracker, DynamicMetaObject instance) { _tracker = tracker; _instance = instance; } @@ -44,7 +45,7 @@ namespace Microsoft.Scripting.Actions { get { return _tracker.Name; } } - public Expression Instance { + public DynamicMetaObject Instance { get { return _instance; } @@ -62,16 +63,16 @@ namespace Microsoft.Scripting.Actions { } } - public override Expression GetValue(Expression context, ActionBinder binder, Type type) { - return _tracker.GetBoundValue(context, binder, type, _instance); + public override DynamicMetaObject GetValue(OverloadResolverFactory resolverFactory, ActionBinder binder, Type type) { + return _tracker.GetBoundValue(resolverFactory, binder, type, _instance); } public override ErrorInfo GetError(ActionBinder binder) { return _tracker.GetBoundError(binder, _instance); } - public override Expression SetValue(Expression context, ActionBinder binder, Type type, Expression value) { - return _tracker.SetBoundValue(context, binder, type, value, _instance); + public override DynamicMetaObject SetValue(OverloadResolverFactory resolverFactory, ActionBinder binder, Type type, DynamicMetaObject value) { + return _tracker.SetBoundValue(resolverFactory, binder, type, value, _instance); } } } Merlin/Main/Runtime/Microsoft.Scripting/Actions/BoundMemberTracker.cs @@ -48,6 +48,11 @@ namespace Microsoft.Scripting.Actions { _bodies.Add(body); } + public void FinishCondition(DynamicMetaObject body) { + _restrictions = _restrictions.Merge(body.Restrictions); + FinishCondition(body.Expression); + } + /// <summary> /// Adds the non-conditional terminating node. /// </summary> Merlin/Main/Runtime/Microsoft.Scripting/Actions/ConditionalBuilder.cs @@ -14,9 +14,11 @@ * ***************************************************************************/ using System; +using System.Dynamic; using System.Linq.Expressions; using System.Reflection; -using System.Dynamic; + +using Microsoft.Scripting.Actions.Calls; using Microsoft.Scripting.Generation; using Microsoft.Scripting.Runtime; using Microsoft.Scripting.Utils; @@ -24,9 +26,9 @@ using Microsoft.Scripting.Utils; namespace Microsoft.Scripting.Actions { using Ast = System.Linq.Expressions.Expression; using AstUtils = Microsoft.Scripting.Ast.Utils; - + public partial class DefaultBinder : ActionBinder { - public DynamicMetaObject ConvertTo(Type toType, ConversionResultKind kind, DynamicMetaObject arg) { + public DynamicMetaObject ConvertTo(Type toType, ConversionResultKind kind, DynamicMetaObject arg, OverloadResolverFactory resolverFactory) { ContractUtils.RequiresNotNull(toType, "toType"); ContractUtils.RequiresNotNull(arg, "arg"); @@ -39,8 +41,8 @@ namespace Microsoft.Scripting.Actions { DynamicMetaObject res = TryConvertToObject(toType, arg.Expression.Type, arg, typeRestrictions) ?? - TryAllConversions(toType, kind, arg.Expression.Type, typeRestrictions, arg) ?? - TryAllConversions(toType, kind, arg.GetLimitType(), typeRestrictions, arg) ?? + TryAllConversions(resolverFactory, toType, kind, arg.Expression.Type, typeRestrictions, arg) ?? + TryAllConversions(resolverFactory, toType, kind, arg.GetLimitType(), typeRestrictions, arg) ?? MakeErrorTarget(toType, kind, typeRestrictions, arg); if ((kind == ConversionResultKind.ExplicitTry || kind == ConversionResultKind.ImplicitTry) && toType.IsValueType) { @@ -74,14 +76,14 @@ namespace Microsoft.Scripting.Actions { /// <summary> /// Checks if any conversions are available and if so builds the target for that conversion. /// </summary> - private DynamicMetaObject TryAllConversions(Type toType, ConversionResultKind kind, Type knownType, BindingRestrictions restrictions, DynamicMetaObject arg) { + private DynamicMetaObject TryAllConversions(OverloadResolverFactory factory, Type toType, ConversionResultKind kind, Type knownType, BindingRestrictions restrictions, DynamicMetaObject arg) { return - TryAssignableConversion(toType, knownType, restrictions, arg) ?? // known type -> known type - TryExtensibleConversion(toType, knownType, restrictions, arg) ?? // Extensible<T> -> Extensible<T>.Value - TryUserDefinedConversion(kind, toType, knownType, restrictions, arg) ?? // op_Implicit - TryImplicitNumericConversion(toType, knownType, restrictions, arg) ?? // op_Implicit - TryNullableConversion(toType, kind, knownType, restrictions, arg) ?? // null -> Nullable<T> or T -> Nullable<T> - TryNullConversion(toType, knownType, restrictions); // null -> reference type + TryAssignableConversion(toType, knownType, restrictions, arg) ?? // known type -> known type + TryExtensibleConversion(toType, knownType, restrictions, arg) ?? // Extensible<T> -> Extensible<T>.Value + TryUserDefinedConversion(kind, toType, knownType, restrictions, arg) ?? // op_Implicit + TryImplicitNumericConversion(toType, knownType, restrictions, arg) ?? // op_Implicit + TryNullableConversion(factory, toType, kind, knownType, restrictions, arg) ?? // null -> Nullable<T> or T -> Nullable<T> + TryNullConversion(toType, knownType, restrictions); // null -> reference type } /// <summary> @@ -207,7 +209,7 @@ namespace Microsoft.Scripting.Actions { /// <summary> /// Checks if there's a conversion to/from Nullable of T. /// </summary> - private DynamicMetaObject TryNullableConversion(Type toType, ConversionResultKind kind, Type knownType, BindingRestrictions restrictions, DynamicMetaObject arg) { + private DynamicMetaObject TryNullableConversion(OverloadResolverFactory factory, Type toType, ConversionResultKind kind, Type knownType, BindingRestrictions restrictions, DynamicMetaObject arg) { if (toType.IsGenericType && toType.GetGenericTypeDefinition() == typeof(Nullable<>)) { if (knownType == typeof(DynamicNull)) { // null -> Nullable<T> @@ -217,7 +219,7 @@ namespace Microsoft.Scripting.Actions { } else if (kind == ConversionResultKind.ExplicitCast || kind == ConversionResultKind.ExplicitTry) { if (knownType != typeof(object)) { // when doing an explicit cast we'll do things like int -> Nullable<float> - return MakeConvertingToTToNullableOfTTarget(toType, kind, restrictions, arg); + return MakeConvertingToTToNullableOfTTarget(factory, toType, kind, restrictions, arg); } } } @@ -410,13 +412,13 @@ namespace Microsoft.Scripting.Actions { /// <summary> /// Helper to produce the rule for converting T to Nullable of T /// </summary> - private DynamicMetaObject MakeConvertingToTToNullableOfTTarget(Type toType, ConversionResultKind kind, BindingRestrictions restrictions, DynamicMetaObject arg) { + private DynamicMetaObject MakeConvertingToTToNullableOfTTarget(OverloadResolverFactory resolverFactory, Type toType, ConversionResultKind kind, BindingRestrictions restrictions, DynamicMetaObject arg) { Type valueType = toType.GetGenericArguments()[0]; // ConvertSelfToT -> Nullable<T> if (kind == ConversionResultKind.ExplicitCast) { // if the conversion to T fails we just throw - Expression conversion = ConvertExpression(arg.Expression, valueType, kind, AstUtils.Constant(null, typeof(CodeContext))); + Expression conversion = ConvertExpression(arg.Expression, valueType, kind, resolverFactory); return new DynamicMetaObject( Ast.New( @@ -426,7 +428,7 @@ namespace Microsoft.Scripting.Actions { restrictions ); } else { - Expression conversion = ConvertExpression(arg.Expression, valueType, kind, AstUtils.Constant(null, typeof(CodeContext))); + Expression conversion = ConvertExpression(arg.Expression, valueType, kind, resolverFactory); // if the conversion to T succeeds then produce the nullable<T>, otherwise return default(retType) ParameterExpression tmp = Ast.Variable(typeof(object), "tmp"); Merlin/Main/Runtime/Microsoft.Scripting/Actions/DefaultBinder.Conversions.cs @@ -14,40 +14,26 @@ * ***************************************************************************/ using System; -using System.Linq.Expressions; -using System.Reflection; using System.Dynamic; +using System.Reflection; + +using Microsoft.Scripting.Actions.Calls; using Microsoft.Scripting.Runtime; using Microsoft.Scripting.Utils; + using AstUtils = Microsoft.Scripting.Ast.Utils; namespace Microsoft.Scripting.Actions { - using Ast = System.Linq.Expressions.Expression; public partial class DefaultBinder : ActionBinder { - /// <summary> - /// Builds a MetaObject for performing a member delete. Supports all built-in .NET members, the OperatorMethod - /// DeleteMember, and StrongBox instances. - /// </summary> - public DynamicMetaObject DeleteMember(string name, DynamicMetaObject target) { - ContractUtils.RequiresNotNull(name, "name"); - ContractUtils.RequiresNotNull(target, "target"); - - return DeleteMember( - name, - target, - AstUtils.Constant(null, typeof(CodeContext)) - ); - } - - public DynamicMetaObject DeleteMember(string name, DynamicMetaObject target, Expression codeContext) { + public DynamicMetaObject DeleteMember(string name, DynamicMetaObject target, OverloadResolverFactory resolutionFactory) { ContractUtils.RequiresNotNull(name, "name"); ContractUtils.RequiresNotNull(target, "target"); return MakeDeleteMemberTarget( new SetOrDeleteMemberInfo( name, - codeContext + resolutionFactory ), target.Restrict(target.GetLimitType()) ); @@ -69,7 +55,7 @@ namespace Microsoft.Scripting.Actions { delInfo.Body.Restrictions = restrictions; - if (self == null || !MakeOperatorDeleteMemberBody(delInfo, self.Expression, type, "DeleteMember")) { + if (self == null || !MakeOperatorDeleteMemberBody(delInfo, self, type, "DeleteMember")) { MemberGroup group = GetMember(MemberRequestKind.Delete, type, delInfo.Name); if (group.Count != 0) { if (group[0].MemberType == TrackerTypes.Property) { @@ -102,21 +88,21 @@ namespace Microsoft.Scripting.Actions { private void MakePropertyDeleteStatement(SetOrDeleteMemberInfo delInfo, DynamicMetaObject instance, MethodInfo delete) { delInfo.Body.FinishCondition( instance == null ? - MakeCallExpression(delInfo.CodeContext, delete) : - MakeCallExpression(delInfo.CodeContext, delete, instance.Expression) + MakeCallExpression(delInfo.ResolutionFactory, delete) : + MakeCallExpression(delInfo.ResolutionFactory, delete, instance) ); } /// <summary> if a member-injector is defined-on or registered-for this type call it </summary> - private bool MakeOperatorDeleteMemberBody(SetOrDeleteMemberInfo delInfo, Expression instance, Type type, string name) { + private bool MakeOperatorDeleteMemberBody(SetOrDeleteMemberInfo delInfo, DynamicMetaObject instance, Type type, string name) { MethodInfo delMem = GetMethod(type, name); if (delMem != null && delMem.IsSpecialName) { - Expression call = MakeCallExpression(delInfo.CodeContext, delMem, instance, AstUtils.Constant(delInfo.Name)); + DynamicMetaObject call = MakeCallExpression(delInfo.ResolutionFactory, delMem, instance, new DynamicMetaObject(AstUtils.Constant(delInfo.Name), BindingRestrictions.Empty, delInfo.Name)); if (delMem.ReturnType == typeof(bool)) { delInfo.Body.AddCondition( - call, + call.Expression, AstUtils.Constant(null) ); } else { @@ -133,12 +119,12 @@ namespace Microsoft.Scripting.Actions { /// </summary> private sealed class SetOrDeleteMemberInfo { public readonly string Name; - public readonly Expression CodeContext; + public readonly OverloadResolverFactory ResolutionFactory; public readonly ConditionalBuilder Body = new ConditionalBuilder(); - public SetOrDeleteMemberInfo(string name, Expression codeContext) { + public SetOrDeleteMemberInfo(string name, OverloadResolverFactory resolutionFactory) { Name = name; - CodeContext = codeContext; + ResolutionFactory = resolutionFactory; } } } Merlin/Main/Runtime/Microsoft.Scripting/Actions/DefaultBinder.DeleteMember.cs @@ -14,34 +14,21 @@ * ***************************************************************************/ using System; +using System.Dynamic; using System.Linq.Expressions; using System.Reflection; using System.Runtime.CompilerServices; -using System.Dynamic; + +using Microsoft.Scripting.Actions.Calls; using Microsoft.Scripting.Runtime; using Microsoft.Scripting.Utils; + using AstUtils = Microsoft.Scripting.Ast.Utils; namespace Microsoft.Scripting.Actions { using Ast = System.Linq.Expressions.Expression; - + public partial class DefaultBinder : ActionBinder { - - /// <summary> - /// Builds a MetaObject for performing a member get. Supports all built-in .NET members, the OperatorMethod - /// GetBoundMember, and StrongBox instances. - /// </summary> - /// <param name="name"> - /// The name of the member to retrieve. This name is not processed by the DefaultBinder and - /// is instead handed off to the GetMember API which can do name mangling, case insensitive lookups, etc... - /// </param> - /// <param name="target"> - /// The MetaObject from which the member is retrieved. - /// </param> - public DynamicMetaObject GetMember(string name, DynamicMetaObject target) { - return GetMember(name, target, AstUtils.Constant(null, typeof(CodeContext))); - } - /// <summary> /// Builds a MetaObject for performing a member get. Supports all built-in .NET members, the OperatorMethod /// GetBoundMember, and StrongBox instances. @@ -53,16 +40,14 @@ namespace Microsoft.Scripting.Actions { /// <param name="target"> /// The MetaObject from which the member is retrieved. /// </param> - /// <param name="codeContext"> - /// An expression which provides access to the CodeContext if its required for - /// accessing the member (e.g. for an extension property which takes CodeContext). By default this - /// a null CodeContext object is passed. + /// <param name="resolverFactory"> + /// Provides overload resolution and method binding for any calls which need to be performed for the GetMember. /// </param> - public DynamicMetaObject GetMember(string name, DynamicMetaObject target, Expression codeContext) { + public DynamicMetaObject GetMember(string name, DynamicMetaObject target, OverloadResolverFactory resolverFactory) { return GetMember( name, target, - codeContext, + resolverFactory, false, null ); @@ -79,10 +64,8 @@ namespace Microsoft.Scripting.Actions { /// <param name="target"> /// The MetaObject from which the member is retrieved. /// </param> - /// <param name="codeContext"> - /// An expression which provides access to the CodeContext if its required for - /// accessing the member (e.g. for an extension property which takes CodeContext). By default this - /// a null CodeContext object is passed. + /// <param name="resolverFactory"> + /// An OverloadResolverFactory which can be used for performing overload resolution and method binding. /// </param> /// <param name="isNoThrow"> /// True if the operation should return Operation.Failed on failure, false if it @@ -91,15 +74,15 @@ namespace Microsoft.Scripting.Actions { /// <param name="errorSuggestion"> /// The meta object to be used if the get results in an error. /// </param> - public DynamicMetaObject GetMember(string name, DynamicMetaObject target, Expression codeContext, bool isNoThrow, DynamicMetaObject errorSuggestion) { + public DynamicMetaObject GetMember(string name, DynamicMetaObject target, OverloadResolverFactory resolverFactory, bool isNoThrow, DynamicMetaObject errorSuggestion) { ContractUtils.RequiresNotNull(name, "name"); ContractUtils.RequiresNotNull(target, "target"); - ContractUtils.RequiresNotNull(codeContext, "codeContext"); + ContractUtils.RequiresNotNull(resolverFactory, "resolverFactory"); return MakeGetMemberTarget( new GetMemberInfo( name, - codeContext, + resolverFactory, isNoThrow, errorSuggestion ), @@ -150,11 +133,15 @@ namespace Microsoft.Scripting.Actions { } } - Expression propSelf = self == null ? null : self.Expression; + DynamicMetaObject propSelf = self == null ? null : self; // if lookup failed try the strong-box type if available. if (members.Count == 0 && typeof(IStrongBox).IsAssignableFrom(type) && propSelf != null) { // properties/fields need the direct value, methods hold onto the strong box. - propSelf = Ast.Field(AstUtils.Convert(propSelf, type), type.GetField("Value")); + propSelf = new DynamicMetaObject( + Ast.Field(AstUtils.Convert(propSelf.Expression, type), type.GetField("Value")), + propSelf.Restrictions, + ((IStrongBox)propSelf.Value).Value + ); type = type.GetGenericArguments()[0]; @@ -171,7 +158,7 @@ namespace Microsoft.Scripting.Actions { return getMemInfo.Body.GetMetaObject(target); } - private void MakeBodyHelper(GetMemberInfo getMemInfo, DynamicMetaObject self, Expression propSelf, Type type, MemberGroup members) { + private void MakeBodyHelper(GetMemberInfo getMemInfo, DynamicMetaObject self, DynamicMetaObject propSelf, Type type, MemberGroup members) { if (self != null) { MakeOperatorGetMemberBody(getMemInfo, propSelf, type, "GetCustomMember"); } @@ -186,7 +173,7 @@ namespace Microsoft.Scripting.Actions { } } - private void MakeSuccessfulMemberAccess(GetMemberInfo getMemInfo, DynamicMetaObject self, Expression propSelf, Type type, MemberGroup members, TrackerTypes memberType) { + private void MakeSuccessfulMemberAccess(GetMemberInfo getMemInfo, DynamicMetaObject self, DynamicMetaObject propSelf, Type type, MemberGroup members, TrackerTypes memberType) { switch (memberType) { case TrackerTypes.TypeGroup: case TrackerTypes.Type: @@ -194,7 +181,7 @@ namespace Microsoft.Scripting.Actions { break; case TrackerTypes.Method: // turn into a MethodGroup - MakeGenericBodyWorker(getMemInfo, type, ReflectionCache.GetMethodGroup(getMemInfo.Name, members), self == null ? null : self.Expression); + MakeGenericBodyWorker(getMemInfo, type, ReflectionCache.GetMethodGroup(getMemInfo.Name, members), self); break; case TrackerTypes.Event: case TrackerTypes.Field: @@ -216,7 +203,7 @@ namespace Microsoft.Scripting.Actions { } } - private void MakeGenericBody(GetMemberInfo getMemInfo, Type type, MemberGroup members, Expression instance) { + private void MakeGenericBody(GetMemberInfo getMemInfo, Type type, MemberGroup members, DynamicMetaObject instance) { MemberTracker bestMember = members[0]; if (members.Count > 1) { // if we were given multiple members pick the member closest to the type... @@ -249,15 +236,15 @@ namespace Microsoft.Scripting.Actions { typeTracker = TypeGroup.UpdateTypeEntity(typeTracker, (TypeTracker)members[i]); } - getMemInfo.Body.FinishCondition(typeTracker.GetValue(getMemInfo.CodeContext, this, type)); + getMemInfo.Body.FinishCondition(typeTracker.GetValue(getMemInfo.ResolutionFactory, this, type)); } - private void MakeGenericBodyWorker(GetMemberInfo getMemInfo, Type type, MemberTracker tracker, Expression instance) { + private void MakeGenericBodyWorker(GetMemberInfo getMemInfo, Type type, MemberTracker tracker, DynamicMetaObject instance) { if (instance != null) { tracker = tracker.BindToInstance(instance); } - Expression val = tracker.GetValue(getMemInfo.CodeContext, this, type); + DynamicMetaObject val = tracker.GetValue(getMemInfo.ResolutionFactory, this, type); if (val != null) { getMemInfo.Body.FinishCondition(val); @@ -272,7 +259,7 @@ namespace Microsoft.Scripting.Actions { } /// <summary> if a member-injector is defined-on or registered-for this type call it </summary> - private void MakeOperatorGetMemberBody(GetMemberInfo getMemInfo, Expression instance, Type type, string name) { + private void MakeOperatorGetMemberBody(GetMemberInfo getMemInfo, DynamicMetaObject instance, Type type, string name) { MethodInfo getMem = GetMethod(type, name); if (getMem != null && getMem.IsSpecialName) { ParameterExpression tmp = Ast.Variable(typeof(object), "getVal"); @@ -283,11 +270,19 @@ namespace Microsoft.Scripting.Actions { Ast.Assign( tmp, MakeCallExpression( - getMemInfo.CodeContext, + getMemInfo.ResolutionFactory, getMem, - AstUtils.Convert(instance, type), - AstUtils.Constant(getMemInfo.Name) - ) + new DynamicMetaObject( + Expression.Convert(instance.Expression, type), + instance.Restrictions, + instance.Value + ), + new DynamicMetaObject( + Expression.Constant(getMemInfo.Name), + BindingRestrictions.Empty, + getMemInfo.Name + ) + ).Expression ), Ast.Field(null, typeof(OperationFailed).GetField("Value")) ), @@ -318,14 +313,14 @@ namespace Microsoft.Scripting.Actions { /// </summary> private sealed class GetMemberInfo { public readonly string Name; - public readonly Expression CodeContext; + public readonly OverloadResolverFactory ResolutionFactory; public readonly bool IsNoThrow; public readonly ConditionalBuilder Body = new ConditionalBuilder(); public readonly DynamicMetaObject ErrorSuggestion; - public GetMemberInfo(string name, Expression codeContext, bool noThrow, DynamicMetaObject errorSuggestion) { + public GetMemberInfo(string name, OverloadResolverFactory resolutionFactory, bool noThrow, DynamicMetaObject errorSuggestion) { Name = name; - CodeContext = codeContext; + ResolutionFactory = resolutionFactory; IsNoThrow = noThrow; ErrorSuggestion = errorSuggestion; } Merlin/Main/Runtime/Microsoft.Scripting/Actions/DefaultBinder.GetMember.cs @@ -57,7 +57,7 @@ namespace Microsoft.Scripting.Actions { /// </summary> public DynamicMetaObject GetIndex(OverloadResolverFactory resolverFactory, DynamicMetaObject[] args) { if (args[0].GetLimitType().IsArray) { - return MakeArrayIndexRule(IndexType.Get, args); + return MakeArrayIndexRule(resolverFactory, IndexType.Get, args); } return MakeMethodIndexRule(IndexType.Get, resolverFactory, args); @@ -73,7 +73,7 @@ namespace Microsoft.Scripting.Actions { /// </summary> public DynamicMetaObject SetIndex(OverloadResolverFactory resolverFactory, DynamicMetaObject[] args) { if (args[0].LimitType.IsArray) { - return MakeArrayIndexRule(IndexType.Set, args); + return MakeArrayIndexRule(resolverFactory, IndexType.Set, args); } return MakeMethodIndexRule(IndexType.Set, resolverFactory, args); @@ -408,8 +408,6 @@ namespace Microsoft.Scripting.Actions { StringBuilder res = new StringBuilder(); string comma = ""; foreach (ParameterInfo param in mb.GetParameters()) { - if (param.ParameterType == typeof(CodeContext)) continue; - res.Append(comma); res.Append(param.ParameterType.Name); res.Append(" "); @@ -484,7 +482,7 @@ namespace Microsoft.Scripting.Actions { return null; } - private DynamicMetaObject MakeArrayIndexRule(IndexType oper, DynamicMetaObject[] args) { + private DynamicMetaObject MakeArrayIndexRule(OverloadResolverFactory factory, IndexType oper, DynamicMetaObject[] args) { if (CanConvertFrom(GetArgType(args, 1), typeof(int), false, NarrowingLevel.All)) { BindingRestrictions restrictions = BindingRestrictionsHelpers.GetRuntimeTypeRestriction(args[0].Expression, args[0].GetLimitType()).Merge(BindingRestrictions.Combine(args)); @@ -492,7 +490,7 @@ namespace Microsoft.Scripting.Actions { return new DynamicMetaObject( Ast.ArrayAccess( args[0].Expression, - ConvertIfNeeded(args[1].Expression, typeof(int)) + ConvertIfNeeded(factory, args[1].Expression, typeof(int)) ), restrictions ); @@ -501,9 +499,9 @@ namespace Microsoft.Scripting.Actions { Ast.Assign( Ast.ArrayAccess( args[0].Expression, - ConvertIfNeeded(args[1].Expression, typeof(int)) + ConvertIfNeeded(factory, args[1].Expression, typeof(int)) ), - ConvertIfNeeded(args[2].Expression, args[0].GetLimitType().GetElementType()) + ConvertIfNeeded(factory, args[2].Expression, args[0].GetLimitType().GetElementType()) ), restrictions.Merge(args[1].Restrictions) ); @@ -590,11 +588,11 @@ namespace Microsoft.Scripting.Actions { } } - private Expression ConvertIfNeeded(Expression expression, Type type) { + private Expression ConvertIfNeeded(OverloadResolverFactory factory, Expression expression, Type type) { Assert.NotNull(expression, type); if (expression.Type != type) { - return ConvertExpression(expression, type, ConversionResultKind.ExplicitCast, AstUtils.Constant(null, typeof(CodeContext))); + return ConvertExpression(expression, type, ConversionResultKind.ExplicitCast, factory); } return expression; } Merlin/Main/Runtime/Microsoft.Scripting/Actions/DefaultBinder.Operations.cs @@ -14,38 +14,23 @@ * ***************************************************************************/ using System; +using System.Diagnostics; +using System.Dynamic; using System.Linq.Expressions; using System.Reflection; using System.Runtime.CompilerServices; -using System.Dynamic; + +using Microsoft.Scripting.Actions.Calls; using Microsoft.Scripting.Generation; using Microsoft.Scripting.Runtime; using Microsoft.Scripting.Utils; + using AstUtils = Microsoft.Scripting.Ast.Utils; namespace Microsoft.Scripting.Actions { using Ast = System.Linq.Expressions.Expression; - using System.Diagnostics; - - public partial class DefaultBinder : ActionBinder { - /// <summary> - /// Builds a MetaObject for performing a member get. Supports all built-in .NET members, the OperatorMethod - /// GetBoundMember, and StrongBox instances. - /// </summary> - /// <param name="name"> - /// The name of the member to retrieve. This name is not processed by the DefaultBinder and - /// is instead handed off to the GetMember API which can do name mangling, case insensitive lookups, etc... - /// </param> - /// <param name="target"> - /// The MetaObject from which the member is retrieved. - /// </param> - /// <param name="value"> - /// The value being assigned to the target member. - /// </param> - public DynamicMetaObject SetMember(string name, DynamicMetaObject target, DynamicMetaObject value) { - return SetMember(name, target, value, AstUtils.Constant(null, typeof(CodeContext))); - } - + + public partial class DefaultBinder : ActionBinder { /// <summary> /// Builds a MetaObject for performing a member get. Supports all built-in .NET members, the OperatorMethod /// GetBoundMember, and StrongBox instances. @@ -60,19 +45,17 @@ namespace Microsoft.Scripting.Actions { /// <param name="value"> /// The value being assigned to the target member. /// </param> - /// <param name="codeContext"> - /// An expression which provides access to the CodeContext if its required for - /// accessing the member (e.g. for an extension property which takes CodeContext). By default this - /// a null CodeContext object is passed. + /// <param name="resolverFactory"> + /// rovides overload resolution and method binding for any calls which need to be performed for the SetMember. /// </param> - public DynamicMetaObject SetMember(string name, DynamicMetaObject target, DynamicMetaObject value, Expression codeContext) { + public DynamicMetaObject SetMember(string name, DynamicMetaObject target, DynamicMetaObject value, OverloadResolverFactory resolverFactory) { ContractUtils.RequiresNotNull(name, "name"); ContractUtils.RequiresNotNull(target, "target"); ContractUtils.RequiresNotNull(value, "value"); - ContractUtils.RequiresNotNull(codeContext, "codeContext"); + ContractUtils.RequiresNotNull(resolverFactory, "resolverFactory"); return MakeSetMemberTarget( - new SetOrDeleteMemberInfo(name, codeContext), + new SetOrDeleteMemberInfo(name, resolverFactory), target, value ); @@ -125,12 +108,12 @@ namespace Microsoft.Scripting.Actions { case TrackerTypes.Type: case TrackerTypes.Constructor: memInfo.Body.FinishCondition( - MakeError(MakeReadOnlyMemberError(type, memInfo.Name), typeof(object)) + MakeError(MakeReadOnlyMemberError(type, memInfo.Name), BindingRestrictions.Empty, typeof(object)) ); break; case TrackerTypes.Event: memInfo.Body.FinishCondition( - MakeError(MakeEventValidation(members, self == null ? null : self.Expression, value.Expression, memInfo.CodeContext), typeof(object)) + MakeError(MakeEventValidation(members, self, value, memInfo.ResolutionFactory), BindingRestrictions.Empty, typeof(object)) ); break; case TrackerTypes.Field: @@ -149,7 +132,7 @@ namespace Microsoft.Scripting.Actions { } memInfo.Body.FinishCondition( - MakeError(MakeMissingMemberErrorForAssign(type, self, memInfo.Name), typeof(object)) + MakeError(MakeMissingMemberErrorForAssign(type, self, memInfo.Name), BindingRestrictions.Empty, typeof(object)) ); break; default: @@ -162,10 +145,10 @@ namespace Microsoft.Scripting.Actions { private void MakeGenericBody(SetOrDeleteMemberInfo memInfo, DynamicMetaObject instance, DynamicMetaObject target, Type type, MemberTracker tracker) { if (instance != null) { - tracker = tracker.BindToInstance(instance.Expression); + tracker = tracker.BindToInstance(instance); } - Expression val = tracker.SetValue(memInfo.CodeContext, this, type, target.Expression); + DynamicMetaObject val = tracker.SetValue(memInfo.ResolutionFactory, this, type, target); if (val != null) { memInfo.Body.FinishCondition(val); @@ -197,8 +180,8 @@ namespace Microsoft.Scripting.Actions { MakeStaticPropertyInstanceAccessError( info, true, - instance == null ? null : instance.Expression, - target.Expression + instance, + target ), typeof(object) ) @@ -206,7 +189,7 @@ namespace Microsoft.Scripting.Actions { } else if (info.IsStatic && info.DeclaringType != targetType) { memInfo.Body.FinishCondition( MakeError( - MakeStaticAssignFromDerivedTypeError(targetType, instance, info, target.Expression, memInfo.CodeContext), + MakeStaticAssignFromDerivedTypeError(targetType, instance, info, target, memInfo.ResolutionFactory), typeof(object) ) ); @@ -224,7 +207,7 @@ namespace Microsoft.Scripting.Actions { target.Expression, setter.GetParameters()[0].ParameterType, ConversionResultKind.ExplicitCast, - memInfo.CodeContext + memInfo.ResolutionFactory ) ), Ast.Constant(null) @@ -233,7 +216,7 @@ namespace Microsoft.Scripting.Actions { } else { memInfo.Body.FinishCondition( MakeReturnValue( - MakeCallExpression(memInfo.CodeContext, setter, instance.Expression, target.Expression), + MakeCallExpression(memInfo.ResolutionFactory, setter, instance, target), target ) ); @@ -251,7 +234,7 @@ namespace Microsoft.Scripting.Actions { target.Expression, setter.GetParameters()[0].ParameterType, ConversionResultKind.ExplicitCast, - memInfo.CodeContext + memInfo.ResolutionFactory ), typeof(object) ), @@ -299,7 +282,7 @@ namespace Microsoft.Scripting.Actions { } else if (field.IsStatic && targetType != field.DeclaringType) { memInfo.Body.FinishCondition( MakeError( - MakeStaticAssignFromDerivedTypeError(targetType, instance, field, target.Expression, memInfo.CodeContext), + MakeStaticAssignFromDerivedTypeError(targetType, instance, field, target, memInfo.ResolutionFactory), typeof(object) ) ); @@ -325,7 +308,7 @@ namespace Microsoft.Scripting.Actions { AstUtils.Convert(instance.Expression, field.DeclaringType), field.Field ), - ConvertExpression(target.Expression, field.FieldType, ConversionResultKind.ExplicitCast, memInfo.CodeContext) + ConvertExpression(target.Expression, field.FieldType, ConversionResultKind.ExplicitCast, memInfo.ResolutionFactory) ), target ) @@ -349,6 +332,16 @@ namespace Microsoft.Scripting.Actions { } } + private DynamicMetaObject MakeReturnValue(DynamicMetaObject expression, DynamicMetaObject target) { + return new DynamicMetaObject( + Ast.Block( + expression.Expression, + Expression.Convert(target.Expression, typeof(object)) + ), + target.Restrictions.Merge(expression.Restrictions) + ); + } + private Expression MakeReturnValue(Expression expression, DynamicMetaObject target) { return Ast.Block( expression, @@ -364,9 +357,15 @@ namespace Microsoft.Scripting.Actions { ParameterExpression tmp = Ast.Variable(target.Expression.Type, "setValue"); memInfo.Body.AddVariable(tmp); - Expression call = MakeCallExpression(memInfo.CodeContext, setMem, AstUtils.Convert(self.Expression, type), AstUtils.Constant(memInfo.Name), tmp); + var callMo = MakeCallExpression( + memInfo.ResolutionFactory, + setMem, + self.Clone(AstUtils.Convert(self.Expression, type)), + new DynamicMetaObject(AstUtils.Constant(memInfo.Name), BindingRestrictions.Empty, memInfo.Name), + target.Clone(tmp) + ); - call = Ast.Block(Ast.Assign(tmp, target.Expression), call); + var call = Ast.Block(Ast.Assign(tmp, target.Expression), callMo.Expression); if (setMem.ReturnType == typeof(bool)) { memInfo.Body.AddCondition( Merlin/Main/Runtime/Microsoft.Scripting/Actions/DefaultBinder.SetMember.cs @@ -39,17 +39,6 @@ namespace Microsoft.Scripting.Actions { : base(manager) { } - protected static CodeContext ExtractCodeContext(object[] args, out object[] extracted) { - CodeContext cc; - if (args.Length > 0 && (cc = args[0] as CodeContext) != null) { - extracted = ArrayUtils.ShiftLeft(args, 1); - } else { - cc = null; - extracted = args; - } - return cc; - } - /// <summary> /// Provides a way for the binder to provide a custom error message when lookup fails. Just /// doing this for the time being until we get a more robust error return mechanism. @@ -63,7 +52,7 @@ namespace Microsoft.Scripting.Actions { /// /// The default implementation allows access to the fields or properties using reflection. /// </summary> - public virtual ErrorInfo MakeNonPublicMemberGetError(Expression codeContext, MemberTracker member, Type type, Expression instance) { + public virtual ErrorInfo MakeNonPublicMemberGetError(OverloadResolverFactory resolverFactory, MemberTracker member, Type type, DynamicMetaObject instance) { switch (member.MemberType) { case TrackerTypes.Field: FieldTracker ft = (FieldTracker)member; @@ -72,14 +61,14 @@ namespace Microsoft.Scripting.Actions { Ast.Call( AstUtils.Convert(AstUtils.Constant(ft.Field), typeof(FieldInfo)), typeof(FieldInfo).GetMethod("GetValue"), - AstUtils.Convert(instance, typeof(object)) + AstUtils.Convert(instance.Expression, typeof(object)) ) ); case TrackerTypes.Property: PropertyTracker pt = (PropertyTracker)member; return ErrorInfo.FromValueNoError( - MemberTracker.FromMemberInfo(pt.GetGetMethod(true)).Call(codeContext, this, instance) + MemberTracker.FromMemberInfo(pt.GetGetMethod(true)).Call(resolverFactory, this, instance).Expression ); default: throw new InvalidOperationException(); @@ -99,7 +88,7 @@ namespace Microsoft.Scripting.Actions { ); } - public virtual ErrorInfo MakeEventValidation(MemberGroup members, Expression eventObject, Expression value, Expression codeContext) { + public virtual ErrorInfo MakeEventValidation(MemberGroup members, DynamicMetaObject eventObject, DynamicMetaObject value, OverloadResolverFactory resolverFactory) { EventTracker ev = (EventTracker)members[0]; // handles in place addition of events - this validates the user did the right thing. @@ -107,29 +96,29 @@ namespace Microsoft.Scripting.Actions { Expression.Call( typeof(BinderOps).GetMethod("SetEvent"), AstUtils.Constant(ev), - value + value.Expression ) ); } - public static Expression MakeError(ErrorInfo error, Type type) { + public static DynamicMetaObject MakeError(ErrorInfo error, Type type) { + return MakeError(error, BindingRestrictions.Empty, type); + } + + public static DynamicMetaObject MakeError(ErrorInfo error, BindingRestrictions restrictions, Type type) { switch (error.Kind) { case ErrorInfoKind.Error: // error meta objecT? - return AstUtils.Convert(error.Expression, type); + return new DynamicMetaObject(AstUtils.Convert(error.Expression, type), restrictions); case ErrorInfoKind.Exception: - return AstUtils.Convert(Expression.Throw(error.Expression), type); + return new DynamicMetaObject(AstUtils.Convert(Expression.Throw(error.Expression), type), restrictions); case ErrorInfoKind.Success: - return error.Expression; + return new DynamicMetaObject(error.Expression, restrictions); default: throw new InvalidOperationException(); } } - public static DynamicMetaObject MakeError(ErrorInfo error, BindingRestrictions restrictions, Type type) { - return new DynamicMetaObject(MakeError(error, type), restrictions); - } - private static Expression MakeAmbiguousMatchError(MemberGroup members) { StringBuilder sb = new StringBuilder(); foreach (MemberTracker mi in members) { @@ -194,7 +183,7 @@ namespace Microsoft.Scripting.Actions { } while (curType != null); return null; - } + } } } Merlin/Main/Runtime/Microsoft.Scripting/Actions/DefaultBinder.cs @@ -80,23 +80,6 @@ namespace Microsoft.Scripting.Actions { return new ErrorInfo(resultValue, ErrorInfoKind.Success); } - /// <summary> - /// Internal helper to produce the actual expression used for the error when emitting - /// the error into a rule. - /// </summary> - public Expression MakeErrorForRule(RuleBuilder rule, ActionBinder binder) { - switch (_kind) { - case ErrorInfoKind.Error: - rule.IsError = true; - return rule.MakeReturn(binder, _value); - case ErrorInfoKind.Success: - return rule.MakeReturn(binder, _value); - case ErrorInfoKind.Exception: - return rule.MakeError(_value); - default: throw new InvalidOperationException(); - } - } - public ErrorInfoKind Kind { get { return _kind; Merlin/Main/Runtime/Microsoft.Scripting/Actions/ErrorInfo.cs @@ -14,17 +14,19 @@ * ***************************************************************************/ using System; +using System.Collections.Generic; using System.Diagnostics; -using System.Linq.Expressions; +using System.Dynamic; using System.Reflection; -using Microsoft.Contracts; -using System.Collections.Generic; -using Microsoft.Scripting.Utils; -using Microsoft.Scripting.Runtime; using System.Runtime.InteropServices; -using Microsoft.Scripting.Generation; using System.Threading; +using Microsoft.Contracts; +using Microsoft.Scripting.Actions.Calls; +using Microsoft.Scripting.Generation; +using Microsoft.Scripting.Runtime; +using Microsoft.Scripting.Utils; + namespace Microsoft.Scripting.Actions { public class EventTracker : MemberTracker { // For each instance of the class that declares the event there is a list of pairs in a table @@ -102,11 +104,11 @@ namespace Microsoft.Scripting.Actions { } } - protected internal override Expression GetBoundValue(Expression context, ActionBinder binder, Type type, Expression instance) { + protected internal override DynamicMetaObject GetBoundValue(OverloadResolverFactory resolverFactory, ActionBinder binder, Type type, DynamicMetaObject instance) { return binder.ReturnMemberTracker(type, new BoundMemberTracker(this, instance)); } - public override MemberTracker BindToInstance(Expression instance) { + public override MemberTracker BindToInstance(DynamicMetaObject instance) { if (IsStatic) { return this; } Merlin/Main/Runtime/Microsoft.Scripting/Actions/EventTracker.cs @@ -15,10 +15,13 @@ using System; using System.Diagnostics; -using System.Linq.Expressions; +using System.Dynamic; using System.Reflection; + using Microsoft.Contracts; +using Microsoft.Scripting.Actions.Calls; using Microsoft.Scripting.Utils; + using AstUtils = Microsoft.Scripting.Ast.Utils; namespace Microsoft.Scripting.Actions { @@ -87,9 +90,12 @@ namespace Microsoft.Scripting.Actions { #region Public expression builders - public override Expression GetValue(Expression context, ActionBinder binder, Type type) { + public override DynamicMetaObject GetValue(OverloadResolverFactory resolverFactory, ActionBinder binder, Type type) { if (Field.IsLiteral) { - return AstUtils.Constant(Field.GetValue(null), typeof(object)); + return new DynamicMetaObject( + AstUtils.Constant(Field.GetValue(null), typeof(object)), + BindingRestrictions.Empty + ); } if (!IsStatic) { @@ -102,13 +108,19 @@ namespace Microsoft.Scripting.Actions { } if (IsPublic && DeclaringType.IsPublic) { - return Ast.Convert(Ast.Field(null, Field), typeof(object)); + return new DynamicMetaObject( + Ast.Convert(Ast.Field(null, Field), typeof(object)), + BindingRestrictions.Empty + ); } - return Ast.Call( - AstUtils.Convert(AstUtils.Constant(Field), typeof(FieldInfo)), - typeof(FieldInfo).GetMethod("GetValue"), - AstUtils.Constant(null) + return new DynamicMetaObject( + Ast.Call( + AstUtils.Convert(AstUtils.Constant(Field), typeof(FieldInfo)), + typeof(FieldInfo).GetMethod("GetValue"), + AstUtils.Constant(null) + ), + BindingRestrictions.Empty ); } @@ -124,21 +136,24 @@ namespace Microsoft.Scripting.Actions { #region Internal expression builders - protected internal override Expression GetBoundValue(Expression context, ActionBinder binder, Type type, Expression instance) { + protected internal override DynamicMetaObject GetBoundValue(OverloadResolverFactory resolverFactory, ActionBinder binder, Type type, DynamicMetaObject instance) { if (IsPublic && DeclaringType.IsVisible) { - return AstUtils.Convert( - Ast.Field( - AstUtils.Convert(instance, Field.DeclaringType), - Field + return new DynamicMetaObject( + AstUtils.Convert( + Ast.Field( + AstUtils.Convert(instance.Expression, Field.DeclaringType), + Field + ), + typeof(object) ), - typeof(object) + BindingRestrictions.Empty ); } - return DefaultBinder.MakeError(((DefaultBinder)binder).MakeNonPublicMemberGetError(context, this, type, instance), typeof(object)); + return DefaultBinder.MakeError(((DefaultBinder)binder).MakeNonPublicMemberGetError(resolverFactory, this, type, instance), BindingRestrictions.Empty, typeof(object)); } - public override MemberTracker BindToInstance(Expression instance) { + public override MemberTracker BindToInstance(DynamicMetaObject instance) { if (IsStatic) return this; return new BoundMemberTracker(this, instance); Merlin/Main/Runtime/Microsoft.Scripting/Actions/FieldTracker.cs @@ -15,8 +15,10 @@ using System; using System.Collections.Generic; -using System.Linq.Expressions; +using System.Dynamic; using System.Reflection; + +using Microsoft.Scripting.Actions.Calls; using Microsoft.Scripting.Runtime; using Microsoft.Scripting.Utils; @@ -137,7 +139,7 @@ namespace Microsoft.Scripting.Actions { /// Returns null if it's an error to get the value. The caller can then call GetErrorForGet to get /// the correct error Expression (or null if they should provide a default). /// </summary> - public virtual Expression GetValue(Expression context, ActionBinder binder, Type type) { + public virtual DynamicMetaObject GetValue(OverloadResolverFactory resolverFactory, ActionBinder binder, Type type) { return binder.ReturnMemberTracker(type, this); } @@ -147,7 +149,7 @@ namespace Microsoft.Scripting.Actions { /// Returns null if it's an error to assign to. The caller can then call GetErrorForSet to /// get the correct error Expression (or null if a default error should be provided). /// </summary> - public virtual Expression SetValue(Expression context, ActionBinder binder, Type type, Expression value) { + public virtual DynamicMetaObject SetValue(OverloadResolverFactory resolverFactory, ActionBinder binder, Type type, DynamicMetaObject value) { return null; } @@ -158,7 +160,7 @@ namespace Microsoft.Scripting.Actions { /// GetErrorsForDoCall to get the correct error Expression (or null if a default error should be provided). /// </summary> [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1716:IdentifiersShouldNotMatchKeywords", MessageId = "Call")] // TODO: fix - internal virtual Expression Call(Expression context, ActionBinder binder, params Expression[] arguments) { + internal virtual DynamicMetaObject Call(OverloadResolverFactory resolverFactory, ActionBinder binder, params DynamicMetaObject[] arguments) { return null; } @@ -180,7 +182,7 @@ namespace Microsoft.Scripting.Actions { /// /// A null return value indicates that the default error message should be provided by the caller. /// </summary> - public virtual ErrorInfo GetBoundError(ActionBinder binder, Expression instance) { + public virtual ErrorInfo GetBoundError(ActionBinder binder, DynamicMetaObject instance) { return null; } @@ -188,16 +190,16 @@ namespace Microsoft.Scripting.Actions { /// Helper for getting values that have been bound. Called from BoundMemberTracker. Custom member /// trackers can override this to provide their own behaviors when bound to an instance. /// </summary> - protected internal virtual Expression GetBoundValue(Expression context, ActionBinder binder, Type type, Expression instance) { - return GetValue(context, binder, type); + protected internal virtual DynamicMetaObject GetBoundValue(OverloadResolverFactory resolverFactory, ActionBinder binder, Type type, DynamicMetaObject instance) { + return GetValue(resolverFactory, binder, type); } /// <summary> /// Helper for setting values that have been bound. Called from BoundMemberTracker. Custom member /// trackers can override this to provide their own behaviors when bound to an instance. /// </summary> - protected internal virtual Expression SetBoundValue(Expression context, ActionBinder binder, Type type, Expression value, Expression instance) { - return SetValue(context, binder, type, instance); + protected internal virtual DynamicMetaObject SetBoundValue(OverloadResolverFactory resolverFactory, ActionBinder binder, Type type, DynamicMetaObject value, DynamicMetaObject instance) { + return SetValue(resolverFactory, binder, type, instance); } /// <summary> @@ -207,7 +209,7 @@ namespace Microsoft.Scripting.Actions { /// field results in a new BoundMemberTracker which will get GetBoundValue/SetBoundValue to pass the /// instance through. /// </summary> - public virtual MemberTracker BindToInstance(Expression instance) { + public virtual MemberTracker BindToInstance(DynamicMetaObject instance) { return this; } Merlin/Main/Runtime/Microsoft.Scripting/Actions/MemberTracker.cs @@ -16,10 +16,12 @@ using System; using System.Collections.Generic; using System.Diagnostics; -using System.Linq.Expressions; +using System.Dynamic; using System.Reflection; using System.Threading; + using Microsoft.Contracts; +using Microsoft.Scripting.Actions.Calls; namespace Microsoft.Scripting.Actions { /// <summary> @@ -84,11 +86,11 @@ namespace Microsoft.Scripting.Actions { return methods; } - public override Expression GetValue(Expression context, ActionBinder binder, Type type) { - return base.GetValue(context, binder, type); + public override DynamicMetaObject GetValue(OverloadResolverFactory resolverFactory, ActionBinder binder, Type type) { + return base.GetValue(resolverFactory, binder, type); } - public override MemberTracker BindToInstance(Expression instance) { + public override MemberTracker BindToInstance(DynamicMetaObject instance) { if (ContainsInstance) { return new BoundMemberTracker(this, instance); } @@ -96,7 +98,7 @@ namespace Microsoft.Scripting.Actions { return this; } - protected internal override Expression GetBoundValue(Expression context, ActionBinder binder, Type type, Expression instance) { + protected internal override DynamicMetaObject GetBoundValue(OverloadResolverFactory resolverFactory, ActionBinder binder, Type type, DynamicMetaObject instance) { return binder.ReturnMemberTracker(type, BindToInstance(instance)); } Merlin/Main/Runtime/Microsoft.Scripting/Actions/MethodGroup.cs @@ -14,15 +14,18 @@ * ***************************************************************************/ using System; -using System.Linq.Expressions; +using System.Dynamic; using System.Reflection; -using Microsoft.Scripting.Utils; + using Microsoft.Contracts; +using Microsoft.Scripting.Actions.Calls; +using Microsoft.Scripting.Utils; + using AstUtils = Microsoft.Scripting.Ast.Utils; namespace Microsoft.Scripting.Actions { using Ast = System.Linq.Expressions.Expression; - + public class MethodTracker : MemberTracker { private readonly MethodInfo _method; private readonly bool _isStatic; @@ -74,7 +77,7 @@ namespace Microsoft.Scripting.Actions { return _method.ToString(); } - public override MemberTracker BindToInstance(Expression instance) { + public override MemberTracker BindToInstance(DynamicMetaObject instance) { if (IsStatic) { return this; } @@ -82,38 +85,46 @@ namespace Microsoft.Scripting.Actions { return new BoundMemberTracker(this, instance); } - protected internal override Expression GetBoundValue(Expression context, ActionBinder binder, Type type, Expression instance) { + protected internal override DynamicMetaObject GetBoundValue(OverloadResolverFactory resolverFactory, ActionBinder binder, Type type, DynamicMetaObject instance) { return binder.ReturnMemberTracker(type, BindToInstance(instance)); } - internal override System.Linq.Expressions.Expression Call(Expression context, ActionBinder binder, params Expression[] arguments) { + internal override DynamicMetaObject Call(OverloadResolverFactory resolverFactory, ActionBinder binder, params DynamicMetaObject[] arguments) { if (Method.IsPublic && Method.DeclaringType.IsVisible) { - // TODO: Need to use MethodBinder in here to make this right. - return binder.MakeCallExpression(context, Method, arguments); + return binder.MakeCallExpression(resolverFactory, Method, arguments); } //methodInfo.Invoke(obj, object[] params) if (Method.IsStatic) { - return Ast.Convert( - Ast.Call( - AstUtils.Constant(Method), - typeof(MethodInfo).GetMethod("Invoke", new Type[] { typeof(object), typeof(object[]) }), - AstUtils.Constant(null), - AstUtils.NewArrayHelper(typeof(object), arguments) - ), - Method.ReturnType); + return new DynamicMetaObject( + Ast.Convert( + Ast.Call( + AstUtils.Constant(Method), + typeof(MethodInfo).GetMethod("Invoke", new Type[] { typeof(object), typeof(object[]) }), + AstUtils.Constant(null), + AstUtils.NewArrayHelper(typeof(object), ArrayUtils.ConvertAll(arguments, x => x.Expression)) + ), + Method.ReturnType + ), + BindingRestrictions.Empty + ) + ; } if (arguments.Length == 0) throw Error.NoInstanceForCall(); - return Ast.Convert( - Ast.Call( - AstUtils.Constant(Method), - typeof(MethodInfo).GetMethod("Invoke", new Type[] { typeof(object), typeof(object[]) }), - arguments[0], - AstUtils.NewArrayHelper(typeof(object), ArrayUtils.RemoveFirst(arguments)) + return new DynamicMetaObject( + Ast.Convert( + Ast.Call( + AstUtils.Constant(Method), + typeof(MethodInfo).GetMethod("Invoke", new Type[] { typeof(object), typeof(object[]) }), + arguments[0].Expression, + AstUtils.NewArrayHelper(typeof(object), ArrayUtils.ConvertAll(ArrayUtils.RemoveFirst(arguments), x => x.Expression)) + ), + Method.ReturnType ), - Method.ReturnType); + BindingRestrictions.Empty + ); } } } Merlin/Main/Runtime/Microsoft.Scripting/Actions/MethodTracker.cs @@ -392,22 +392,25 @@ namespace Microsoft.Scripting.Actions { lock (_topPackage.HierarchyLock) { List<object> res = new List<object>(); - foreach (string s in _dict.Keys) { - res.Add(s); - } + return (ICollection<object>)AddKeys(res); + } + } + } - foreach (KeyValuePair<Assembly, TypeNames> kvp in _typeNames) { - foreach (string typeName in kvp.Value.GetNormalizedTypeNames()) { - if (!res.Contains(typeName)) { - res.Add(typeName); - } - } - } + private IList AddKeys(IList res) { + foreach (string s in _dict.Keys) { + res.Add(s); + } - res.Sort(); - return res; + foreach (KeyValuePair<Assembly, TypeNames> kvp in _typeNames) { + foreach (string typeName in kvp.Value.GetNormalizedTypeNames()) { + if (!res.Contains(typeName)) { + res.Add(typeName); + } } } + + return res; } #endregion @@ -545,8 +548,16 @@ namespace Microsoft.Scripting.Actions { #region IMembersList Members - public IList<object> GetMemberNames(CodeContext context) { - return (IList<object>)Keys; + public IList<string> GetMemberNames() { + LoadNamespaces(); + + lock (_topPackage.HierarchyLock) { + + List<string> res = new List<string>(); + AddKeys(res); + res.Sort(); + return res; + } } #endregion Merlin/Main/Runtime/Microsoft.Scripting/Actions/NamespaceTracker.cs @@ -14,11 +14,11 @@ * ***************************************************************************/ using System; -using System.Linq.Expressions; +using System.Dynamic; using System.Reflection; + +using Microsoft.Scripting.Actions.Calls; using Microsoft.Scripting.Generation; -using Microsoft.Scripting.Runtime; -using AstUtils = Microsoft.Scripting.Ast.Utils; namespace Microsoft.Scripting.Actions { @@ -57,7 +57,7 @@ namespace Microsoft.Scripting.Actions { #region Public expression builders - public override Expression GetValue(Expression context, ActionBinder binder, Type type) { + public override DynamicMetaObject GetValue(OverloadResolverFactory resolverFactory, ActionBinder binder, Type type) { if (!IsStatic || GetIndexParameters().Length > 0) { // need to bind to a value or parameters to get the value. return binder.ReturnMemberTracker(type, this); @@ -70,11 +70,11 @@ namespace Microsoft.Scripting.Actions { } if (getter.IsPublic && getter.DeclaringType.IsPublic) { - return AstUtils.Convert(binder.MakeCallExpression(context, getter), typeof(object)); + return binder.MakeCallExpression(resolverFactory, getter); } // private binding is just a call to the getter method... - return MemberTracker.FromMemberInfo(getter).Call(context, binder); + return MemberTracker.FromMemberInfo(getter).Call(resolverFactory, binder); } public override ErrorInfo GetError(ActionBinder binder) { @@ -95,7 +95,7 @@ namespace Microsoft.Scripting.Actions { #region Internal expression builders - protected internal override Expression GetBoundValue(Expression context, ActionBinder binder, Type type, Expression instance) { + protected internal override DynamicMetaObject GetBoundValue(OverloadResolverFactory resolverFactory, ActionBinder binder, Type type, DynamicMetaObject instance) { if (instance != null && IsStatic) { return null; } @@ -114,14 +114,14 @@ namespace Microsoft.Scripting.Actions { getter = CompilerHelpers.TryGetCallableMethod(getter); if (binder.PrivateBinding || CompilerHelpers.IsVisible(getter)) { - return AstUtils.Convert(binder.MakeCallExpression(context, getter, instance), typeof(object)); + return ((DefaultBinder)binder).MakeCallExpression(resolverFactory, getter, instance); } // private binding is just a call to the getter method... - return DefaultBinder.MakeError(((DefaultBinder)binder).MakeNonPublicMemberGetError(context, this, type, instance), typeof(object)); + return DefaultBinder.MakeError(((DefaultBinder)binder).MakeNonPublicMemberGetError(resolverFactory, this, type, instance), BindingRestrictions.Empty, typeof(object)); } - public override ErrorInfo GetBoundError(ActionBinder binder, Expression instance) { + public override ErrorInfo GetBoundError(ActionBinder binder, DynamicMetaObject instance) { MethodInfo getter = ResolveGetter(binder.PrivateBinding); if (getter == null) { @@ -139,7 +139,7 @@ namespace Microsoft.Scripting.Actions { throw new InvalidOperationException(); } - public override MemberTracker BindToInstance(Expression instance) { + public override MemberTracker BindToInstance(DynamicMetaObject instance) { return new BoundMemberTracker(this, instance); } Merlin/Main/Runtime/Microsoft.Scripting/Actions/PropertyTracker.cs @@ -83,7 +83,7 @@ namespace Microsoft.Scripting.Actions { return repr.ToString(); } - public override IList<object> GetMemberNames(CodeContext context) { + public override IList<string> GetMemberNames() { Dictionary<string, string> members = new Dictionary<string, string>(); foreach (Type t in this.Types) { CollectMembers(members, t); Merlin/Main/Runtime/Microsoft.Scripting/Actions/TypeGroup.cs @@ -38,15 +38,15 @@ namespace Microsoft.Scripting.Actions { #region IMembersList Members - public virtual IList<object> GetMemberNames(CodeContext context) { + public virtual IList<string> GetMemberNames() { Dictionary<string, string> members = new Dictionary<string, string>(); CollectMembers(members, Type); return MembersToList(members); } - internal static IList<object> MembersToList(Dictionary<string, string> members) { - List<object> res = new List<object>(); + internal static IList<string> MembersToList(Dictionary<string, string> members) { + List<string> res = new List<string>(); foreach (string key in members.Keys) { res.Add(key); } Merlin/Main/Runtime/Microsoft.Scripting/Actions/TypeTracker.cs @@ -47,7 +47,6 @@ namespace Microsoft.Scripting.Ast { private Expression _body; private bool _dictionary; private bool _visible = true; - private bool _addCodeContext; private bool _completed; private static int _lambdaId; //for generating unique lambda name @@ -148,20 +147,7 @@ namespace Microsoft.Scripting.Ast { _visible = value; } } - - /// <summary> - /// Prevents builder from inserting context scope. - /// Default is false (will insert if needed). - /// </summary> - public bool AddCodeContext { - get { - return _addCodeContext; - } - set { - _addCodeContext = value; - } - } - + public List<ParameterExpression> GetVisibleVariables() { var vars = new List<ParameterExpression>(_visibleVars.Count); foreach (var v in _visibleVars) { @@ -538,25 +524,7 @@ namespace Microsoft.Scripting.Ast { private Expression MakeBody() { Expression body = _body; - - // wrap a CodeContext scope if needed - if (AddCodeContext) { - - var vars = GetVisibleVariables(); - - if (vars.Count > 0) { - body = Utils.CodeContextScope( - body, - Expression.Call( - typeof(RuntimeHelpers).GetMethod("CreateNestedCodeContext"), - Utils.VariableDictionary(vars), - Utils.CodeContext(), - AstUtils.Constant(_visible) - ) - ); - } - } - + // wrap a scope if needed if (_locals != null && _locals.Count > 0) { body = Expression.Block(new ReadOnlyCollection<ParameterExpression>(_locals.ToArray()), body); @@ -611,11 +579,6 @@ namespace Microsoft.Scripting.Ast { namespace Microsoft.Scripting.Runtime { public static partial class ScriptingRuntimeHelpers { - public static CodeContext CreateNestedCodeContext(CustomSymbolDictionary variables, CodeContext context, bool visible) { - Debug.Assert(variables.Count > 0); - return new CodeContext(new Scope(context.Scope, variables, visible), context.LanguageContext, context); - } - /// <summary> /// Used by prologue code that is injected in lambdas to ensure that delegate signature matches what /// lambda body expects. Such code typically unwraps subset of the params array manually, Merlin/Main/Runtime/Microsoft.Scripting/Ast/LambdaBuilder.cs @@ -662,15 +662,6 @@ namespace Microsoft.Scripting.Generation { return res; } - /// <summary> - /// Returns a value which indicates failure when a ConvertToAction of ImplicitTry or - /// ExplicitTry. - /// </summary> - public static Expression GetTryConvertReturnValue(CodeContext context, RuleBuilder rule) { - rule.IsError = true; - return rule.MakeReturn(context.LanguageContext.Binder, GetTryConvertReturnValue(rule.ReturnType)); - } - public static bool HasTypeConverter(Type fromType, Type toType) { #if SILVERLIGHT return false; Merlin/Main/Runtime/Microsoft.Scripting/Generation/CompilerHelpers.cs @@ -456,7 +456,7 @@ namespace Microsoft.Scripting.Hosting { ContractUtils.RequiresNotNull(scope, "scope"); ContractUtils.RequiresNotNull(name, "name"); - return _language.LookupName(scope.Scope, SymbolTable.StringToId(name)); + return scope.Scope.GetVariable(SymbolTable.StringToId(name)); } /// <summary> @@ -474,7 +474,7 @@ namespace Microsoft.Scripting.Hosting { ContractUtils.RequiresNotNull(scope, "scope"); ContractUtils.RequiresNotNull(name, "name"); - return _language.RemoveName(scope.Scope, SymbolTable.StringToId(name)); + return scope.Scope.TryRemoveVariable(SymbolTable.StringToId(name)); } /// <summary> @@ -490,7 +490,7 @@ namespace Microsoft.Scripting.Hosting { ContractUtils.RequiresNotNull(scope, "scope"); ContractUtils.RequiresNotNull(name, "name"); - _language.SetName(scope.Scope, SymbolTable.StringToId(name), value); + scope.Scope.SetVariable(SymbolTable.StringToId(name), value); } /// <summary> @@ -509,7 +509,7 @@ namespace Microsoft.Scripting.Hosting { ContractUtils.RequiresNotNull(scope, "scope"); ContractUtils.RequiresNotNull(name, "name"); - return _language.TryLookupName(scope.Scope, SymbolTable.StringToId(name), out value); + return scope.Scope.TryGetVariable(SymbolTable.StringToId(name), out value); } /// <summary> Merlin/Main/Runtime/Microsoft.Scripting/Hosting/ScriptEngine.cs @@ -84,7 +84,7 @@ namespace Microsoft.Scripting.Hosting { /// <exception cref="MissingMemberException">The specified name is not defined in the scope.</exception> /// <exception cref="ArgumentNullException"><paramref name="name"/> is a <c>null</c> reference.</exception> public dynamic GetVariable(string name) { - return _scope.LookupName(_engine.LanguageContext, SymbolTable.StringToId(name)); + return _scope.GetVariable(SymbolTable.StringToId(name)); } /// <summary> @@ -103,7 +103,7 @@ namespace Microsoft.Scripting.Hosting { /// </summary> /// <exception cref="ArgumentNullException"><paramref name="name"/> is a <c>null</c> reference.</exception> public bool TryGetVariable(string name, out dynamic value) { - return _scope.TryGetName(SymbolTable.StringToId(name), out value); + return _scope.TryGetVariable(SymbolTable.StringToId(name), out value); } /// <summary> @@ -114,7 +114,7 @@ namespace Microsoft.Scripting.Hosting { /// <exception cref="ArgumentNullException"><paramref name="name"/> is a <c>null</c> reference.</exception> public bool TryGetVariable<T>(string name, out T value) { object result; - if (_scope.TryGetName(SymbolTable.StringToId(name), out result)) { + if (_scope.TryGetVariable(SymbolTable.StringToId(name), out result)) { value = _engine.Operations.ConvertTo<T>(result); return true; } @@ -127,7 +127,7 @@ namespace Microsoft.Scripting.Hosting { /// </summary> /// <exception cref="ArgumentNullException"><paramref name="name"/> is a <c>null</c> reference.</exception> public void SetVariable(string name, object value) { - _scope.SetName(SymbolTable.StringToId(name), value); + _scope.SetVariable(SymbolTable.StringToId(name), value); } #if !SILVERLIGHT @@ -174,7 +174,7 @@ namespace Microsoft.Scripting.Hosting { /// </summary> /// <exception cref="ArgumentNullException"><paramref name="name"/> is a <c>null</c> reference.</exception> public bool ContainsVariable(string name) { - return _scope.ContainsName(SymbolTable.StringToId(name)); + return _scope.ContainsVariable(SymbolTable.StringToId(name)); } /// <summary> @@ -183,7 +183,7 @@ namespace Microsoft.Scripting.Hosting { /// <returns><c>true</c> if the value existed in the scope before it has been removed.</returns> /// <exception cref="ArgumentNullException"><paramref name="name"/> is a <c>null</c> reference.</exception> public bool RemoveVariable(string name) { - return _scope.TryRemoveName(SymbolTable.StringToId(name)); + return _scope.TryRemoveVariable(SymbolTable.StringToId(name)); } /// <summary> Merlin/Main/Runtime/Microsoft.Scripting/Hosting/ScriptScope.cs Merlin/Main/Runtime/Microsoft.Scripting/Microsoft.Scripting.Build.csproj @@ -22,7 +22,7 @@ <SignedSym Condition="'$(SignAssembly)' == 'true'">SIGNED</SignedSym> <DelaySign>true</DelaySign> <BaseAddress>857735168</BaseAddress> - <SilverlightPath Condition="$(SilverlightPath) == ''">..\..\Utilities\Silverlight\x86ret\</SilverlightPath> + <SilverlightPath Condition="'$(SilverlightPath)' == ''">..\..\Utilities\Silverlight\x86ret\</SilverlightPath> </PropertyGroup> <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'FxCop|AnyCPU' "> <DebugType>pdbonly</DebugType> @@ -85,8 +85,8 @@ <SilverlightBuild>true</SilverlightBuild> </PropertyGroup> <ItemGroup> - <Reference Include="System" Condition=" $(SilverlightBuild) != 'true' " /> - <Reference Include="System.Configuration" Condition=" $(SilverlightBuild) != 'true' " /> + <Reference Include="System" Condition=" '$(SilverlightBuild)' != 'true' " /> + <Reference Include="System.Configuration" Condition=" '$(SilverlightBuild)' != 'true' " /> <Reference Include="mscorlib, Version=2.0.5.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e" Condition=" '$(SilverlightBuild)' == 'true' "> <SpecificVersion>False</SpecificVersion> <HintPath>$(SilverlightPath)\mscorlib.dll</HintPath> @@ -96,8 +96,8 @@ <HintPath>$(SilverlightPath)\System.dll</HintPath> </Reference> <Reference Include="System.Data" /> - <Reference Include="System.Runtime.Remoting" Condition=" $(SilverlightBuild) != 'true' " /> - <Reference Include="System.Xml" Condition=" $(SilverlightBuild) != 'true' " /> + <Reference Include="System.Runtime.Remoting" Condition=" '$(SilverlightBuild)' != 'true' " /> + <Reference Include="System.Xml" Condition=" '$(SilverlightBuild)' != 'true' " /> </ItemGroup> <ItemGroup> <Compile Include="..\..\Hosts\Silverlight\SilverlightVersion.cs" Condition=" '$(SilverlightBuild)' == 'true' "> @@ -144,7 +144,6 @@ <Compile Include="Actions\OperationBinder.cs" /> <Compile Include="Actions\OperationMetaObject.cs" /> <Compile Include="ArgumentTypeException.cs" /> - <Compile Include="Ast\CodeContextExpression.cs" /> <Compile Include="Ast\FinallyFlowControlExpression.cs" /> <Compile Include="Ast\FlowControlRewriter.cs" /> <Compile Include="Ast\SourceFileInformation.cs" /> @@ -353,7 +352,6 @@ <Compile Include="Actions\NestedTypeTracker.cs" /> <Compile Include="Actions\PropertyTracker.cs" /> <Compile Include="Actions\ReflectedPropertyTracker.cs" /> - <Compile Include="Actions\RuleBuilder.cs" /> <Compile Include="Actions\TopNamespaceTracker.cs" /> <Compile Include="Actions\TrackerTypes.cs" /> <Compile Include="Actions\TypeGroup.cs" /> @@ -369,7 +367,6 @@ <Compile Include="Runtime\BaseSymbolDictionary.cs" /> <Compile Include="Runtime\BinderType.cs" /> <Compile Include="Runtime\CallTargets.cs" /> - <Compile Include="Runtime\CodeContext.cs" /> <Compile Include="Runtime\ContextId.cs" /> <Compile Include="Runtime\CustomSymbolDictionary.cs" /> <Compile Include="Runtime\DlrCachedCodeAttribute.cs" /> @@ -403,7 +400,6 @@ <Compile Include="Runtime\StaticExtensionMethodAttribute.cs" /> <Compile Include="Runtime\SymbolDictionary.cs" /> <Compile Include="Runtime\TransformDictEnumerator.cs" /> - <Compile Include="Runtime\UnboundNameException.cs" /> <Compile Include="Runtime\Uninitialized.cs" /> <Compile Include="Utils\ArrayUtils.cs" /> <Compile Include="Utils\AssemblyQualifiedTypeName.cs" /> Merlin/Main/Runtime/Microsoft.Scripting/Microsoft.Scripting.csproj @@ -135,9 +135,6 @@ InvalidArgumentType=Invalid type of argument {0}; expecting {1}. ## ExceptionType=ArgumentException CannotChangeNonCachingValue=Cannot change non-caching value. -## ExceptionType=Microsoft.Scripting.Runtime.UnboundLocalException -ReferencedBeforeAssignment=Local variable '{0}' referenced before assignment. - ## ExceptionType=MissingMemberException FieldReadonly=Field {0} is read-only Merlin/Main/Runtime/Microsoft.Scripting/Microsoft.Scripting.txt @@ -67,13 +67,12 @@ namespace Microsoft.Scripting.Runtime { internal static class AssemblyTypeNames { public static IEnumerable<TypeName> GetTypeNames(Assembly assem, bool includePrivateTypes) { #if !SILVERLIGHT - AssemblyName assemblyName = new AssemblyName(assem.FullName); - switch (assemblyName.Name) { - case "mscorlib": return Get_mscorlib_TypeNames(); - case "System": return Get_System_TypeNames(); - case "System.Xml": return Get_SystemXml_TypeNames(); - case "System.Drawing": return Get_SystemDrawing_TypeNames(); - case "System.Windows.Forms": return Get_SystemWindowsForms_TypeNames(); + switch (assem.FullName) { + case "mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089": return Get_mscorlib_TypeNames(); + case "System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089": return Get_System_TypeNames(); + case "System.Xml, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089": return Get_SystemXml_TypeNames(); + case "System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a": return Get_SystemDrawing_TypeNames(); + case "System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089": return Get_SystemWindowsForms_TypeNames(); } #endif Merlin/Main/Runtime/Microsoft.Scripting/Runtime/AssemblyTypeNames.cs @@ -92,45 +92,7 @@ namespace Microsoft.Scripting.Runtime { } return res; } - - #region Event support - - public static EventTracker EventTrackerInPlaceAdd<T>(CodeContext context, EventTracker self, T target) { - MethodInfo add = self.Event.GetAddMethod(context.LanguageContext.DomainManager.Configuration.PrivateBinding); - add.Invoke(null, new object[] { target }); - return self; - } - - public static EventTracker EventTrackerInPlaceRemove<T>(CodeContext context, EventTracker self, T target) { - MethodInfo remove = self.Event.GetRemoveMethod(context.LanguageContext.DomainManager.Configuration.PrivateBinding); - remove.Invoke(null, new object[] { target }); - return self; - } - - public static BoundMemberTracker BoundEventTrackerInPlaceAdd<T>(CodeContext context, BoundMemberTracker self, T target) { - if (self.BoundTo.MemberType == TrackerTypes.Event) { - EventTracker et = (EventTracker)self.BoundTo; - - MethodInfo add = et.Event.GetAddMethod(context.LanguageContext.DomainManager.Configuration.PrivateBinding); - add.Invoke(self.ObjectInstance, new object[] { target }); - return self; - } - throw new InvalidOperationException(); - } - - public static BoundMemberTracker BoundEventTrackerInPlaceRemove<T>(CodeContext context, BoundMemberTracker self, T target) { - if (self.BoundTo.MemberType == TrackerTypes.Event) { - EventTracker et = (EventTracker)self.BoundTo; - - MethodInfo remove = et.Event.GetRemoveMethod(context.LanguageContext.DomainManager.Configuration.PrivateBinding); - remove.Invoke(self.ObjectInstance, new object[] { target }); - return self; - } - throw new InvalidOperationException(); - } - #endregion - public static ArgumentTypeException BadArgumentsForOperation(Operators op, params object[] args) { StringBuilder message = new StringBuilder("unsupported operand type(s) for operation "); message.Append(op.ToString()); Merlin/Main/Runtime/Microsoft.Scripting/Runtime/BinderOps.cs @@ -48,7 +48,7 @@ namespace Microsoft.Scripting.Runtime { throw new NotImplementedException(); } - public override Expression ConvertExpression(Expression expr, Type toType, ConversionResultKind kind, Expression context) { + public override Expression ConvertExpression(Expression expr, Type toType, ConversionResultKind kind, OverloadResolverFactory factory) { if (toType.IsAssignableFrom(expr.Type)) { return expr; } Merlin/Main/Runtime/Microsoft.Scripting/Runtime/DefaultLanguageContext.cs @@ -20,26 +20,18 @@ namespace Microsoft.Scripting.Runtime { /// Helper for storing information about stack frames. /// </summary> public class DynamicStackFrame { - private CodeContext _context; private string _funcName; private string _filename; private int _lineNo; private MethodBase _method; - public DynamicStackFrame(CodeContext context, MethodBase method, string funcName, string filename, int line) { - _context = context; + public DynamicStackFrame(MethodBase method, string funcName, string filename, int line) { _funcName = funcName; _filename = filename; _lineNo = line; _method = method; } - public CodeContext CodeContext { - get { - return _context; - } - } - [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate")] public MethodBase GetMethod() { return _method; Merlin/Main/Runtime/Microsoft.Scripting/Runtime/DynamicStackFrame.cs @@ -112,17 +112,7 @@ namespace Microsoft.Scripting.Runtime { return TryGetAssociatedStackTraces(rethrow, out result) ? result : null; } - public static void UpdateStackTrace(CodeContext context, MethodBase method, string funcName, string filename, int line) { - if (line != -1) { - Debug.Assert(filename != null); - if (_stackFrames == null) _stackFrames = new List<DynamicStackFrame>(); - - Debug.Assert(line != SourceLocation.None.Line); - - _stackFrames.Add(new DynamicStackFrame(context, method, funcName, filename, line)); - } - } - + public static List<DynamicStackFrame> AssociateDynamicStackFrames(Exception clrException) { if (_stackFrames != null) { clrException.Data[typeof(DynamicStackFrame)] = _stackFrames; @@ -287,7 +277,7 @@ namespace Microsoft.Scripting.Runtime { } } - return new DynamicStackFrame(null, method, methodName, filename, line); + return new DynamicStackFrame(method, methodName, filename, line); } #endregion Merlin/Main/Runtime/Microsoft.Scripting/Runtime/ExceptionHelpers.cs @@ -18,13 +18,9 @@ using System.Collections.Generic; namespace Microsoft.Scripting.Runtime { /// <summary> - /// Provides a list of all the members of an instance. ie. all the keys in the - /// dictionary of the object. Note that it can contain objects that are not strings. - /// - /// Such keys can be added in IronPython using syntax like: - /// obj.__dict__[100] = someOtherObject + /// Provides a list of all the members of an instance. /// </summary> public interface IMembersList { - IList<object> GetMemberNames(CodeContext context); + IList<string> GetMemberNames(); } } Merlin/Main/Runtime/Microsoft.Scripting/Runtime/IMembersList.cs @@ -152,78 +152,6 @@ namespace Microsoft.Scripting.Runtime { #endregion - - /// <summary> - /// Looks up the name in the provided Scope using the current language's semantics. - /// </summary> - public virtual bool TryLookupName(Scope scope, SymbolId name, out object value) { - if (scope.TryLookupName(name, out value) && value != Uninitialized.Instance) { - return true; - } - - return TryLookupGlobal(scope, name, out value); - } - - /// <summary> - /// Looks up the name in the provided scope using the current language's semantics. - /// - /// If the name cannot be found throws the language appropriate exception or returns - /// the language's appropriate default value. - /// </summary> - public virtual object LookupName(Scope scope, SymbolId name) { - object value; - if (!TryLookupName(scope, name, out value) || value == Uninitialized.Instance) { - throw MissingName(name); - } - - return value; - } - - /// <summary> - /// Attempts to set the name in the provided scope using the current language's semantics. - /// </summary> - public virtual void SetName(Scope scope, SymbolId name, object value) { - scope.SetName(name, value); - } - - /// <summary> - /// Attempts to remove the name from the provided scope using the current language's semantics. - /// </summary> - public virtual bool RemoveName(Scope scope, SymbolId name) { - if (!scope.TryRemoveName(name)) { - throw MissingName(name); - } - return true; - } - - /// <summary> - /// Attemps to lookup a global variable using the language's semantics called from - /// the provided Scope. The default implementation will attempt to lookup the variable - /// at the host level. - /// </summary> - public virtual bool TryLookupGlobal(Scope scope, SymbolId name, out object value) { - value = null; - return false; - } - - /// <summary> - /// Called when a lookup has failed and an exception should be thrown. Enables the - /// language context to throw the appropriate exception for their language when - /// name lookup fails. - /// </summary> - protected internal virtual Exception MissingName(SymbolId name) { - return Error.NameNotDefined(SymbolTable.IdToString(name)); - } - - [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2001:AvoidCallingProblematicMethods", MessageId = "System.Reflection.Assembly.LoadFile")] - public virtual Assembly LoadAssemblyFromFile(string file) { -#if SILVERLIGHT - return null; -#else - return Assembly.LoadFile(file); -#endif - } - #region ScriptEngine API public virtual Version LanguageVersion { Merlin/Main/Runtime/Microsoft.Scripting/Runtime/LanguageContext.cs @@ -143,53 +143,26 @@ namespace Microsoft.Scripting.Runtime { /// Trys to lookup the provided name in the current scope. Search includes /// names that are only visible to the provided LanguageContext. /// </summary> - public bool TryGetName(SymbolId name, out object value) { - if (_dict.TryGetValue(name, out value)) return true; - - value = null; - return false; + public bool TryGetVariable(SymbolId name, out object value) { + return _dict.TryGetValue(name, out value); } - - /// <summary> - /// Attempts to lookup the provided name in this scope or any outer scope. - /// </summary> - public bool TryLookupName(SymbolId name, out object value) { - Scope curScope = this; - do { - if (curScope == this || curScope.IsVisible) { - if (curScope.TryGetName(name, out value)) { - return true; - } - } - - curScope = curScope.Parent; - } while (curScope != null); - - value = null; - return false; - } - - /// <summary> - /// Attempts to lookup the provided name in this scope or any outer scope. - /// If the name is not defined the language defined MissingName exception is thrown. - /// </summary> - public object LookupName(LanguageContext context, SymbolId name) { - object res; - if (!TryLookupName(name, out res)) { - throw context.MissingName(name); + + public object GetVariable(SymbolId name) { + object value; + if (!TryGetVariable(name, out value)) { + throw Error.NameNotDefined(SymbolTable.IdToString(name)); } - - return res; + return value; } /// <summary> /// Sets the name to the specified value for the current context. /// </summary> /// <exception cref="MemberAccessException">The name has already been published and marked as ReadOnly</exception> - public void SetName(SymbolId name, object value) { + public void SetVariable(SymbolId name, object value) { _dict[name] = value; } - + /// <summary> /// Removes all members from the dictionary and any context-sensitive dictionaries. /// </summary> @@ -200,20 +173,15 @@ namespace Microsoft.Scripting.Runtime { } } - /// <summary> - /// Determines if this context or any outer scope contains the defined name that - /// is available from the provided LanguageContext. - /// </summary> - public bool ContainsName(SymbolId name) { - object tmp; - return TryLookupName(name, out tmp); + public bool ContainsVariable(SymbolId name) { + return _dict.ContainsKey(name); } /// <summary> /// Attemps to remove the provided name from this scope removing names visible /// to both the current context and all contexts. /// </summary> - public bool TryRemoveName(SymbolId name) { + public bool TryRemoveVariable(SymbolId name) { bool fRemoved = false; // TODO: Ideally, we could do this without having to do two lookups. @@ -225,19 +193,6 @@ namespace Microsoft.Scripting.Runtime { return fRemoved; } - // Emitted by TupleSlotFactory - /// <summary> - /// Gets the outer-most scope associated with this scope. - /// </summary> - public Scope ModuleScope { - get { - Scope cur = this; - while (cur.Parent != null) cur = cur.Parent; - - return cur; - } - } - /// <summary> /// Default scope dictionary /// </summary> @@ -292,5 +247,24 @@ namespace Microsoft.Scripting.Runtime { } #endregion + + #region Obsolete + + [Obsolete("Use SetVariable instead")] + public void SetName(SymbolId name, object value) { + SetVariable(name, value); + } + + [Obsolete("Use TryGetVariable instead")] + public bool TryGetName(SymbolId name, out object value) { + return TryGetVariable(name, out value); + } + + [Obsolete("Use ContainsVariable instead")] + public bool ContainsName(SymbolId name) { + return ContainsVariable(name); + } + + #endregion } } Merlin/Main/Runtime/Microsoft.Scripting/Runtime/Scope.cs @@ -112,10 +112,6 @@ namespace Microsoft.Scripting.Runtime { return new MissingMemberException(message); } - public static void ThrowUnboundLocalError(SymbolId name) { - throw Error.ReferencedBeforeAssignment(SymbolTable.IdToString(name)); - } - public static object ReadOnlyAssignError(bool field, string fieldName) { if (field) { throw Error.FieldReadonly(fieldName); Merlin/Main/Runtime/Microsoft.Scripting/Runtime/ScriptingRuntimeHelpers.cs @@ -456,13 +456,6 @@ namespace Microsoft.Scripting { } /// <summary> - /// A string like "Local variable '{0}' referenced before assignment." - /// </summary> - internal static string ReferencedBeforeAssignment(object p0) { - return FormatString("Local variable '{0}' referenced before assignment.", p0); - } - - /// <summary> /// A string like "Field {0} is read-only" /// </summary> internal static string FieldReadonly(object p0) { @@ -874,13 +867,6 @@ namespace Microsoft.Scripting { } /// <summary> - /// Microsoft.Scripting.Runtime.UnboundLocalException with message like "Local variable '{0}' referenced before assignment." - /// </summary> - internal static Exception ReferencedBeforeAssignment(object p0) { - return new Microsoft.Scripting.Runtime.UnboundLocalException(Strings.ReferencedBeforeAssignment(p0)); - } - - /// <summary> /// MissingMemberException with message like "Field {0} is read-only" /// </summary> internal static Exception FieldReadonly(object p0) { Merlin/Main/Runtime/Microsoft.Scripting/Utils/ExceptionFactory.Generated.cs @@ -20,7 +20,7 @@ namespace Microsoft.Scripting.Utils { // Like ReadOnlyCollection<T>: wraps an IDictionary<K, V> in a read-only wrapper [Serializable] - internal sealed class ReadOnlyDictionary<K, V> : IDictionary<K, V> { + public sealed class ReadOnlyDictionary<K, V> : IDictionary<K, V> { // For wrapping non-readonly Keys, Values collections // Not used for standard dictionaries, which return read-only Keys and Values @@ -84,7 +84,7 @@ namespace Microsoft.Scripting.Utils { private readonly IDictionary<K, V> _dict; - internal ReadOnlyDictionary(IDictionary<K, V> dict) { + public ReadOnlyDictionary(IDictionary<K, V> dict) { ReadOnlyDictionary<K, V> rodict = dict as ReadOnlyDictionary<K, V>; _dict = (rodict != null) ? rodict._dict : dict; } Merlin/Main/Runtime/Microsoft.Scripting/Utils/ReadOnlyDictionary.cs @@ -23,22 +23,28 @@ namespace Microsoft.Scripting.Utils { /// provides a thread-safe implementation. It holds onto a Dictionary[TKey, TValue] instead of inheriting from /// it so that users who need to do manual synchronization can access the underlying Dictionary[TKey, TValue]. /// </summary> - internal class SynchronizedDictionary<TKey, TValue> : + public class SynchronizedDictionary<TKey, TValue> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>> { - Dictionary<TKey, TValue> _dictionary = new Dictionary<TKey, TValue>(); + Dictionary<TKey, TValue> _dictionary; /// <summary> /// This returns the raw unsynchronized Dictionary[TKey, TValue]. Users are responsible for locking /// on it before accessing it. Also, it should not be arbitrarily handed out to other code since deadlocks /// can be caused if other code incorrectly locks on it. /// </summary> - internal Dictionary<TKey, TValue> UnderlyingDictionary { - get { - return _dictionary; - } + public Dictionary<TKey, TValue> UnderlyingDictionary { + get { return _dictionary; } + } + + public SynchronizedDictionary() + : this(new Dictionary<TKey, TValue>()) { + } + + public SynchronizedDictionary(Dictionary<TKey, TValue> dictionary) { + _dictionary = dictionary; } #region IDictionary<TKey,TValue> Members Merlin/Main/Runtime/Microsoft.Scripting/Utils/SynchronizedDictionary.cs @@ -18,6 +18,10 @@ using System.Collections.ObjectModel; using System.Dynamic.Utils; using System.Linq.Expressions; +#if SILVERLIGHT +using System.Core; +#endif //SILVERLIGHT + namespace System.Dynamic { /// <summary> ndp/fx/src/Core/Microsoft/Scripting/Actions/CallInfo.cs @@ -22,6 +22,10 @@ using System.Linq.Expressions; using System.Linq.Expressions.Compiler; using System.Reflection; +#if SILVERLIGHT +using System.Core; +#endif //SILVERLIGHT + namespace System.Runtime.CompilerServices { // ndp/fx/src/Core/Microsoft/Scripting/Actions/CallSite.cs @@ -22,6 +22,10 @@ using System.Linq.Expressions; using System.Threading; using System.Reflection; +#if SILVERLIGHT +using System.Core; +#endif //SILVERLIGHT + namespace System.Runtime.CompilerServices { /// <summary> /// Class responsible for runtime binding of the dynamic operations on the dynamic call site. @@ -131,9 +135,10 @@ namespace System.Runtime.CompilerServices { // // finally produce the new rule if we need to // -#if !MICROSOFT_SCRIPTING_CORE +#if !MICROSOFT_SCRIPTING_CORE && !SILVERLIGHT // We cannot compile rules in the heterogeneous app domains since they // may come from less trusted sources + // Silverlight always uses a homogenous appdomain, so we don’t need this check if (!AppDomain.CurrentDomain.IsHomogenous) { throw Error.HomogenousAppDomainRequired(); } ndp/fx/src/Core/Microsoft/Scripting/Actions/CallSiteBinder.cs @@ -17,7 +17,12 @@ using System.Collections.Generic; using System.Dynamic.Utils; using System.Linq.Expressions; using System.Reflection; + +#if SILVERLIGHT +using System.Core; +#else using System.Runtime.Remoting; +#endif namespace System.Dynamic { /// <summary> ndp/fx/src/Core/Microsoft/Scripting/Actions/DynamicMetaObject.cs @@ -19,7 +19,12 @@ using System.Dynamic.Utils; using System.Linq.Expressions; using System.Linq.Expressions.Compiler; using System.Runtime.CompilerServices; + +#if SILVERLIGHT +using System.Core; +#else using System.Runtime.Remoting; +#endif namespace System.Dynamic { /// <summary> ndp/fx/src/Core/Microsoft/Scripting/Actions/DynamicMetaObjectBinder.cs @@ -21,6 +21,10 @@ using System.Dynamic.Utils; using System.Linq.Expressions; using System.Runtime.CompilerServices; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Dynamic { /// <summary> /// Represents an object with members that can be dynamically added and removed at runtime. ndp/fx/src/Core/Microsoft/Scripting/Actions/ExpandoObject.cs @@ -19,6 +19,10 @@ using System.Diagnostics; using System.Dynamic.Utils; using System.Reflection; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions { /// <summary> ndp/fx/src/Core/Microsoft/Scripting/Ast/BinaryExpression.cs @@ -19,6 +19,10 @@ using System.Diagnostics; using System.Dynamic.Utils; using System.Threading; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions { /// <summary> /// Represents a block that contains a sequence of expressions where variables can be defined. ndp/fx/src/Core/Microsoft/Scripting/Ast/BlockExpression.cs @@ -16,6 +16,10 @@ using System.Diagnostics; using System.Dynamic.Utils; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions { /// <summary> ndp/fx/src/Core/Microsoft/Scripting/Ast/CatchBlock.cs @@ -16,6 +16,10 @@ using System.Dynamic.Utils; using System.Diagnostics; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions { /// <summary> ndp/fx/src/Core/Microsoft/Scripting/Ast/ConditionalExpression.cs @@ -16,6 +16,10 @@ using System.Diagnostics; using System.Dynamic.Utils; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions { /// <summary> ndp/fx/src/Core/Microsoft/Scripting/Ast/ConstantExpression.cs @@ -16,6 +16,10 @@ using System.Diagnostics; using System.Dynamic.Utils; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions { /// <summary> /// Emits or clears a sequence point for debug information. ndp/fx/src/Core/Microsoft/Scripting/Ast/DebugInfoExpression.cs @@ -21,6 +21,10 @@ using System.Linq.Expressions.Compiler; using System.Reflection; using System.Runtime.CompilerServices; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions { /// <summary> /// Represents a dynamic operation. ndp/fx/src/Core/Microsoft/Scripting/Ast/DynamicExpression.cs @@ -20,6 +20,10 @@ using System.Reflection; using System.Text; using System.Dynamic.Utils; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions { /// <summary> /// Represents the initialization of a list. ndp/fx/src/Core/Microsoft/Scripting/Ast/ElementInit.cs @@ -22,6 +22,10 @@ using System.Reflection; using System.Runtime.CompilerServices; using System.Threading; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions { /// <summary> /// The base type for all nodes in Expression Trees. ndp/fx/src/Core/Microsoft/Scripting/Ast/Expression.cs @@ -18,6 +18,10 @@ using System.Diagnostics; using System.Dynamic.Utils; using System.Runtime.CompilerServices; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions { /// <summary> ndp/fx/src/Core/Microsoft/Scripting/Ast/ExpressionVisitor.cs @@ -16,6 +16,10 @@ using System.Diagnostics; using System.Dynamic.Utils; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions { /// <summary> /// Specifies what kind of jump this <see cref="GotoExpression"/> represents. ndp/fx/src/Core/Microsoft/Scripting/Ast/GotoExpression.cs @@ -21,6 +21,10 @@ using System.Reflection; using System.Runtime.CompilerServices; using System.Text; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions { /// <summary> /// Represents indexing a property or array. ndp/fx/src/Core/Microsoft/Scripting/Ast/IndexExpression.cs @@ -19,6 +19,10 @@ using System.Diagnostics; using System.Dynamic.Utils; using System.Reflection; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions { /// <summary> /// Represents an expression that applies a delegate or lambda expression to a list of argument expressions. ndp/fx/src/Core/Microsoft/Scripting/Ast/InvocationExpression.cs @@ -23,6 +23,10 @@ using System.Reflection.Emit; using System.Threading; using System.Runtime.CompilerServices; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions { /// <summary> /// Creates a <see cref="LambdaExpression"/> node. ndp/fx/src/Core/Microsoft/Scripting/Ast/LambdaExpression.cs @@ -20,6 +20,10 @@ using System.Dynamic.Utils; using System.Reflection; using System.Runtime.CompilerServices; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions { /// <summary> /// Represents a constructor call that has a collection initializer. ndp/fx/src/Core/Microsoft/Scripting/Ast/ListInitExpression.cs @@ -16,6 +16,10 @@ using System.Diagnostics; using System.Dynamic.Utils; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions { /// <summary> /// Represents an infinite loop. It can be exited with "break". ndp/fx/src/Core/Microsoft/Scripting/Ast/LoopExpression.cs @@ -16,6 +16,10 @@ using System.Dynamic.Utils; using System.Reflection; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions { /// <summary> /// Represents assignment to a member of an object. ndp/fx/src/Core/Microsoft/Scripting/Ast/MemberAssignment.cs @@ -17,6 +17,10 @@ using System.Diagnostics; using System.Dynamic.Utils; using System.Reflection; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions { /// <summary> ndp/fx/src/Core/Microsoft/Scripting/Ast/MemberExpression.cs @@ -19,6 +19,10 @@ using System.Collections.ObjectModel; using System.Dynamic.Utils; using System.Reflection; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions { /// <summary> ndp/fx/src/Core/Microsoft/Scripting/Ast/MemberListBinding.cs @@ -18,6 +18,10 @@ using System.Collections.ObjectModel; using System.Dynamic.Utils; using System.Reflection; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions { /// <summary> /// Represents initializing members of a member of a newly created object. ndp/fx/src/Core/Microsoft/Scripting/Ast/MemberMemberBinding.cs @@ -20,6 +20,10 @@ using System.Dynamic.Utils; using System.Reflection; using System.Runtime.CompilerServices; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions { /// <summary> /// Represents a call to either static or an instance method. ndp/fx/src/Core/Microsoft/Scripting/Ast/MethodCallExpression.cs @@ -19,6 +19,10 @@ using System.Diagnostics; using System.Dynamic.Utils; using System.Runtime.CompilerServices; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions { /// <summary> ndp/fx/src/Core/Microsoft/Scripting/Ast/NewArrayExpression.cs @@ -20,6 +20,10 @@ using System.Dynamic.Utils; using System.Reflection; using System.Runtime.CompilerServices; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions { /// <summary> ndp/fx/src/Core/Microsoft/Scripting/Ast/NewExpression.cs @@ -16,6 +16,10 @@ using System.Diagnostics; using System.Dynamic.Utils; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions { /// <summary> ndp/fx/src/Core/Microsoft/Scripting/Ast/ParameterExpression.cs @@ -19,6 +19,10 @@ using System.Diagnostics; using System.Dynamic.Utils; using System.Reflection; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions { /// <summary> /// Represents a control expression that handles multiple selections by passing control to a <see cref="SwitchCase"/>. ndp/fx/src/Core/Microsoft/Scripting/Ast/SwitchExpression.cs @@ -18,6 +18,10 @@ using System.Collections.ObjectModel; using System.Diagnostics; using System.Dynamic.Utils; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions { /// <summary> /// Represents a try/catch/finally/fault block. ndp/fx/src/Core/Microsoft/Scripting/Ast/TryExpression.cs @@ -16,6 +16,10 @@ using System.Diagnostics; using System.Dynamic.Utils; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions { /// <summary> /// Represents an operation between an expression and a type. ndp/fx/src/Core/Microsoft/Scripting/Ast/TypeBinaryExpression.cs @@ -18,6 +18,10 @@ using System.Diagnostics; using System.Linq.Expressions; using System.Reflection; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Dynamic.Utils { internal static class TypeUtils { @@ -139,8 +143,9 @@ namespace System.Dynamic.Utils { return false; } - internal static bool AreEquivalent(Type t1, Type t2) { -#if MICROSOFT_SCRIPTING_CORE + internal static bool AreEquivalent(Type t1, Type t2) + { +#if MICROSOFT_SCRIPTING_CORE || SILVERLIGHT return t1 == t2; #else return t1 == t2 || t1.IsEquivalentTo(t2); ndp/fx/src/Core/Microsoft/Scripting/Ast/TypeUtils.cs @@ -18,6 +18,10 @@ using System.Dynamic.Utils; using System.Reflection; using System.Runtime.CompilerServices; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions { /// <summary> ndp/fx/src/Core/Microsoft/Scripting/Ast/UnaryExpression.cs @@ -19,6 +19,10 @@ using System.Reflection.Emit; using System.Runtime.CompilerServices; using System.Dynamic.Utils; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions.Compiler { /// <summary> /// This type tracks "runtime" constants--live objects that appear in ndp/fx/src/Core/Microsoft/Scripting/Compiler/BoundConstants.cs @@ -21,6 +21,10 @@ using System.Runtime.CompilerServices; using System.Dynamic; using System.Dynamic.Utils; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions.Compiler { internal enum VariableStorageKind { Local, ndp/fx/src/Core/Microsoft/Scripting/Compiler/CompilerScope.cs @@ -13,7 +13,7 @@ * * ***************************************************************************/ -#if MICROSOFT_SCRIPTING_CORE +#if MICROSOFT_SCRIPTING_CORE || SILVERLIGHT using ILGenerator = System.Linq.Expressions.Compiler.OffsetTrackingILGenerator; #endif ndp/fx/src/Core/Microsoft/Scripting/Compiler/DebugInfoGenerator.cs @@ -13,7 +13,7 @@ * * ***************************************************************************/ -#if MICROSOFT_SCRIPTING_CORE +#if MICROSOFT_SCRIPTING_CORE || SILVERLIGHT using ILGenerator = System.Linq.Expressions.Compiler.OffsetTrackingILGenerator; #endif @@ -24,6 +24,10 @@ using System.Reflection; using System.Reflection.Emit; using System.Runtime.CompilerServices; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions.Compiler { internal static class ILGen { ndp/fx/src/Core/Microsoft/Scripting/Compiler/ILGen.cs @@ -16,6 +16,10 @@ using System.Collections.Generic; using System.Linq.Expressions; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions.Compiler { /// <summary> ndp/fx/src/Core/Microsoft/Scripting/Compiler/KeyedQueue.cs @@ -13,7 +13,7 @@ * * ***************************************************************************/ -#if MICROSOFT_SCRIPTING_CORE +#if MICROSOFT_SCRIPTING_CORE || SILVERLIGHT using ILGenerator = System.Linq.Expressions.Compiler.OffsetTrackingILGenerator; #endif @@ -22,6 +22,10 @@ using System.Diagnostics; using System.Dynamic.Utils; using System.Reflection.Emit; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions.Compiler { /// <summary> ndp/fx/src/Core/Microsoft/Scripting/Compiler/LabelInfo.cs @@ -19,6 +19,10 @@ using System.Dynamic.Utils; using System.Reflection; using System.Reflection.Emit; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions.Compiler { partial class LambdaCompiler { ndp/fx/src/Core/Microsoft/Scripting/Compiler/LambdaCompiler.Binary.cs @@ -21,6 +21,10 @@ using System.Reflection; using System.Reflection.Emit; using System.Runtime.CompilerServices; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions.Compiler { partial class LambdaCompiler { [Flags] ndp/fx/src/Core/Microsoft/Scripting/Compiler/LambdaCompiler.Expressions.cs @@ -18,6 +18,10 @@ using System.Dynamic.Utils; using System.Reflection; using System.Reflection.Emit; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions.Compiler { partial class LambdaCompiler { ndp/fx/src/Core/Microsoft/Scripting/Compiler/LambdaCompiler.Logical.cs @@ -20,6 +20,10 @@ using System.Reflection; using System.Reflection.Emit; using System.Globalization; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions.Compiler { partial class LambdaCompiler { private void EmitBlockExpression(Expression expr, CompilationFlags flags) { ndp/fx/src/Core/Microsoft/Scripting/Compiler/LambdaCompiler.Statements.cs @@ -19,6 +19,10 @@ using System.Reflection; using System.Reflection.Emit; using System.Runtime.CompilerServices; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions.Compiler { partial class LambdaCompiler { ndp/fx/src/Core/Microsoft/Scripting/Compiler/LambdaCompiler.Unary.cs @@ -13,7 +13,7 @@ * * ***************************************************************************/ -#if MICROSOFT_SCRIPTING_CORE +#if MICROSOFT_SCRIPTING_CORE || SILVERLIGHT using ILGenerator = System.Linq.Expressions.Compiler.OffsetTrackingILGenerator; #endif @@ -83,7 +83,7 @@ namespace System.Linq.Expressions.Compiler { private LambdaCompiler(AnalyzedTree tree, LambdaExpression lambda) { Type[] parameterTypes = GetParameterTypes(lambda).AddFirst(typeof(Closure)); -#if SILVERLIGHT +#if SILVERLIGHT && MICROSOFT_SCRIPTING_CORE var method = new DynamicMethod(lambda.Name ?? "lambda_method", lambda.ReturnType, parameterTypes); #else var method = new DynamicMethod(lambda.Name ?? "lambda_method", lambda.ReturnType, parameterTypes, true); @@ -93,7 +93,7 @@ namespace System.Linq.Expressions.Compiler { _lambda = lambda; _method = method; -#if MICROSOFT_SCRIPTING_CORE +#if MICROSOFT_SCRIPTING_CORE || SILVERLIGHT _ilg = new OffsetTrackingILGenerator(method.GetILGenerator()); #else _ilg = method.GetILGenerator(); @@ -132,7 +132,7 @@ namespace System.Linq.Expressions.Compiler { _typeBuilder = (TypeBuilder)method.DeclaringType; _method = method; -#if MICROSOFT_SCRIPTING_CORE +#if MICROSOFT_SCRIPTING_CORE || SILVERLIGHT _ilg = new OffsetTrackingILGenerator(method.GetILGenerator()); #else _ilg = method.GetILGenerator(); ndp/fx/src/Core/Microsoft/Scripting/Compiler/LambdaCompiler.cs @@ -22,7 +22,7 @@ using System.Diagnostics.SymbolStore; // Not needed in CLR 4 builds because we have the // ILGenerator.ILOffset property. -#if MICROSOFT_SCRIPTING_CORE +#if MICROSOFT_SCRIPTING_CORE || SILVERLIGHT namespace System.Linq.Expressions.Compiler { /// <summary> ndp/fx/src/Core/Microsoft/Scripting/Compiler/OffsetTrackingILGenerator.cs @@ -17,6 +17,10 @@ using System.Collections.ObjectModel; using System.Dynamic.Utils; using System.Runtime.CompilerServices; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions.Compiler { internal partial class StackSpiller { ndp/fx/src/Core/Microsoft/Scripting/Compiler/StackSpiller.Bindings.cs @@ -20,6 +20,10 @@ using System.Dynamic.Utils; using System.Reflection; using System.Runtime.CompilerServices; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions.Compiler { /// <summary> ndp/fx/src/Core/Microsoft/Scripting/Compiler/StackSpiller.cs @@ -13,7 +13,7 @@ * * ***************************************************************************/ -#if MICROSOFT_SCRIPTING_CORE +#if MICROSOFT_SCRIPTING_CORE || SILVERLIGHT using ILGenerator = System.Linq.Expressions.Compiler.OffsetTrackingILGenerator; #endif @@ -25,6 +25,10 @@ using System.Linq.Expressions.Compiler; using System.Reflection; using System.Reflection.Emit; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Runtime.CompilerServices { /// <summary> /// Generator of PDB debugging information for expression trees. ndp/fx/src/Core/Microsoft/Scripting/Compiler/SymbolDocumentGenerator.cs @@ -18,6 +18,10 @@ using System.Collections.ObjectModel; using System.Diagnostics; using System.Dynamic.Utils; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Linq.Expressions.Compiler { /// <summary> /// Determines if variables are closed over in nested lambdas and need to ndp/fx/src/Core/Microsoft/Scripting/Compiler/VariableBinder.cs @@ -21,7 +21,7 @@ <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> + <SilverlightPath Condition="'$(SilverlightPath)' == ''">..\..\..\..\..\..\Merlin\Main\Utilities\Silverlight\x86ret\</SilverlightPath> <BaseAddress>855638016</BaseAddress> </PropertyGroup> <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'FxCop|AnyCPU' "> @@ -91,8 +91,8 @@ <SilverlightBuild>true</SilverlightBuild> </PropertyGroup> <ItemGroup> - <Reference Include="System" Condition=" $(SilverlightBuild) != 'true' " /> - <Reference Include="System.Configuration" Condition=" $(SilverlightBuild) != 'true' " /> + <Reference Include="System" Condition=" '$(SilverlightBuild)' != 'true' " /> + <Reference Include="System.Configuration" Condition=" '$(SilverlightBuild)' != 'true' " /> <Reference Include="mscorlib, Version=2.0.5.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e" Condition=" '$(SilverlightBuild)' == 'true' "> <SpecificVersion>False</SpecificVersion> <HintPath>$(SilverlightPath)\mscorlib.dll</HintPath> @@ -101,8 +101,8 @@ <SpecificVersion>False</SpecificVersion> <HintPath>$(SilverlightPath)\System.dll</HintPath> </Reference> - <Reference Include="System.Data" Condition=" $(SilverlightBuild) != 'true' " /> - <Reference Include="System.Xml" Condition=" $(SilverlightBuild) != 'true' " /> + <Reference Include="System.Data" Condition=" '$(SilverlightBuild)' != 'true' " /> + <Reference Include="System.Xml" Condition=" '$(SilverlightBuild)' != 'true' " /> </ItemGroup> <ItemGroup> <Compile Include="..\..\..\..\..\..\Merlin\Main\Hosts\Silverlight\SilverlightVersion.cs" Condition=" '$(SilverlightBuild)' == 'true' "> ndp/fx/src/Core/Microsoft/Scripting/Microsoft.Scripting.Core.csproj @@ -19,7 +19,7 @@ <SignedSym Condition="'$(SignAssembly)' == 'true'">SIGNED</SignedSym> <DelaySign>true</DelaySign> <BaseAddress>866123776</BaseAddress> - <SilverlightPath Condition="$(SilverlightPath) == ''">..\..\..\..\..\..\Merlin\Main\Utilities\Silverlight\x86ret\</SilverlightPath> + <SilverlightPath Condition="'$(SilverlightPath)' == ''">..\..\..\..\..\..\Merlin\Main\Utilities\Silverlight\x86ret\</SilverlightPath> </PropertyGroup> <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'FxCop|AnyCPU' "> <DebugType>pdbonly</DebugType> @@ -79,7 +79,7 @@ <SilverlightBuild>true</SilverlightBuild> </PropertyGroup> <ItemGroup> - <Reference Include="System" Condition=" $(SilverlightBuild) != 'true' " /> + <Reference Include="System" Condition=" '$(SilverlightBuild)' != 'true' " /> <Reference Include="mscorlib, Version=2.0.5.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e" Condition=" '$(SilverlightBuild)' == 'true' "> <SpecificVersion>False</SpecificVersion> <HintPath>$(SilverlightPath)\mscorlib.dll</HintPath> ndp/fx/src/Core/Microsoft/Scripting/Microsoft.Scripting.ExtensionAttribute.csproj @@ -19,6 +19,13 @@ using System.Dynamic.Utils; #if SILVERLIGHT // Stubs +// This is needed so we can build Silverlight version on Codeplex +// where System.Core namespace is not defined. +namespace System.Core +{ + class Dummy { } +} + namespace System { /// <summary> ndp/fx/src/Core/Microsoft/Scripting/Stubs.cs @@ -14,14 +14,14 @@ * ***************************************************************************/ namespace System { - #if MICROSOFT_SCRIPTING_CORE + #if MICROSOFT_SCRIPTING_CORE || SILVERLIGHT /// <summary> /// Encapsulates a method that takes no parameters and does not return a value. /// </summary> public delegate void Action(); - #endif +#endif // public delegate void Action<T>(T obj); -- Already defined in mscorlib @@ -30,7 +30,7 @@ namespace System { // *** BEGIN GENERATED CODE *** // generated by function: gen_action_types from: generate_dynsites.py -#if MICROSOFT_SCRIPTING_CORE +#if MICROSOFT_SCRIPTING_CORE || SILVERLIGHT /// <summary> /// Encapsulates a method that takes two parameters and does not return a value. ndp/fx/src/Core/Microsoft/Scripting/Utils/Action.cs @@ -17,6 +17,10 @@ using System.Collections.Generic; using System.Diagnostics; using System.Linq.Expressions; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Dynamic.Utils { // Will be replaced with CLRv4 managed contracts ndp/fx/src/Core/Microsoft/Scripting/Utils/ContractUtils.cs @@ -15,7 +15,7 @@ namespace System { - #if MICROSOFT_SCRIPTING_CORE + #if MICROSOFT_SCRIPTING_CORE || SILVERLIGHT /// <summary> /// Encapsulates a method that has no parameters and returns a value of the type specified by the TResult parameter. @@ -33,14 +33,14 @@ namespace System { /// <returns>The return value of the method that this delegate encapsulates.</returns> public delegate TResult Func<T, TResult>(T arg); - #endif +#endif #region Generated Func Types // *** BEGIN GENERATED CODE *** // generated by function: gen_func_types from: generate_dynsites.py -#if MICROSOFT_SCRIPTING_CORE +#if MICROSOFT_SCRIPTING_CORE || SILVERLIGHT /// <summary> /// Encapsulates a method that has two parameters and returns a value of the type specified by the TResult parameter. ndp/fx/src/Core/Microsoft/Scripting/Utils/Function.cs @@ -18,12 +18,18 @@ using System.Collections.ObjectModel; using System.Dynamic.Utils; using System.Linq.Expressions; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Runtime.CompilerServices { /// <summary> /// The builder for read only collection. /// </summary> /// <typeparam name="T">The type of the collection element.</typeparam> +#if !SILVERLIGHT [Serializable] +#endif [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1710:IdentifiersShouldHaveCorrectSuffix")] public sealed class ReadOnlyCollectionBuilder<T> : IList<T>, System.Collections.IList { private const int DefaultCapacity = 4; @@ -31,7 +37,10 @@ namespace System.Runtime.CompilerServices { private T[] _items; private int _size; private int _version; + +#if !SILVERLIGHT [NonSerialized] +#endif private Object _syncRoot; static readonly T[] _emptyArray = new T[0]; @@ -439,7 +448,9 @@ namespace System.Runtime.CompilerServices { throw new ArgumentException(Strings.InvalidObjectType(value != null ? value.GetType() : (object)"null", typeof(T)), argument); } +#if !SILVERLIGHT [Serializable] +#endif private class Enumerator : IEnumerator<T>, System.Collections.IEnumerator { private readonly ReadOnlyCollectionBuilder<T> _builder; private readonly int _version; ndp/fx/src/Core/Microsoft/Scripting/Utils/ReadOnlyCollectionBuilder.cs @@ -16,6 +16,10 @@ using System.Collections.Generic; using System.Linq.Expressions; +#if SILVERLIGHT +using System.Core; +#endif + namespace System.Dynamic.Utils { // Like ReadOnlyCollection<T>: wraps an IDictionary<K, V> in a read-only wrapper ndp/fx/src/Core/Microsoft/Scripting/Utils/ReadOnlyDictionary.cs Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags/core/array/zip_tags.txt Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags/core/bignum/div_tags.txt Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags/core/bignum/divmod_tags.txt Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags/core/bignum/modulo_tags.txt Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags/core/bignum/remainder_tags.txt Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags/core/bignum/to_s_tags.txt Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags/library/net/http/http/get_print_tags.txt Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags/library/net/http/http/lock_tags.txt Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags/library/net/http/http/post_form_tags.txt Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags/library/net/http/http/post_tags.txt Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags/library/net/http/http/propfind_tags.txt Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags/library/net/http/http/proppatch_tags.txt Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags/library/net/http/http/put_tags.txt Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags/library/net/http/http/request_tags.txt Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags/library/net/http/http/send_request_tags.txt Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags/library/net/http/http/unlock_tags.txt Merlin/Main/Languages/Ruby/IronRuby.Tests.VS/IronRuby.Tests.VS.csproj Merlin/Main/Languages/Ruby/IronRuby.Tests.VS/MsTest.cs Merlin/Main/Languages/Ruby/RubyCodeCoverage.testrunconfig Merlin/Main/Languages/Ruby/RubyCodeCoverage.vsmdi Merlin/Main/Runtime/Microsoft.Scripting/Actions/RuleBuilder.cs Merlin/Main/Runtime/Microsoft.Scripting/Ast/CodeContextExpression.cs Merlin/Main/Runtime/Microsoft.Scripting/Runtime/CodeContext.cs Merlin/Main/Runtime/Microsoft.Scripting/Runtime/UnboundNameException.cs 4a4455dcbc726d7210996b57cd60e8ff0374f6bb b5f157e1d9da99a863dbfd24d0a6ab05cc3d59bf Jim Deville jdeville@microsoft.com http://github.com/shri/ironruby/commit/05ed08e4ab67cc3ec43e9f49265ddd48c3c0c320 05ed08e4ab67cc3ec43e9f49265ddd48c3c0c320 2009-07-27T09:14:05-07:00 2009-07-27T09:14:05-07:00 Merge branch 'master' of git@github.com:ironruby/ironruby 52b9c09a17d1000bf76838259d17dc9bf6ca1360 Jim Deville jdeville@microsoft.com