[Ironruby-core] State of IronRuby 10/5/07

Mike Moore blowmage at gmail.com
Fri Oct 5 23:51:04 EDT 2007


Thanks!  This is great info.  Much appreciated.

On 10/5/07, John Lam (DLR) <jflam at microsoft.com> wrote:
>
> These are the IronRuby related check-ins that have happened the week of
> 10/5/07. Note that most of the work done this week is in DLR, since the team
> is heavily engaged in a refactoring pass across that codebase.
>
> 283358:
>
> (dinov) This change adds a fast invocation path to avoid doing
> methodInfo.Invoke.  But while it does offer speed improvements this change
> is largely motivated by a limitation in Silverlight that prevents us from
> calling methods like System.Type.MakeArrayType or
> System.Type.IsAssignableFrom from reflection - there are various types
> that are locked down and until now that hasn't really been an issue.  That
> will enable my next check-in to remove the infinite recursion possibility
> when dealing w/ mutating types & new rules.  Enough about that future
> check-in though...
>
> ReflectedCaller is a class which encapsulates how to call a method as fast
> as it can.  If it can't call a method quickly it'll just fallback to
> MethodInfo.Invoke.  It attempts to be fast in two areas: The creation of
> the calling helper object and the invocation of the method.
>
> It accomplishes the speed of the creation through a series of static
> generic methods which look at the type code and call the next in the series,
> ultimately using their type parameters to create the new instance. If the
> type is an unrecognized type it'll fallback to the slow path of using
> MakeGenericType and Activator.CreateInstance
>
> generate_reflected_calls.py add $/Merlin/Main/Languages/IronPython/Scripts
> test_cPickle.py edit $/Merlin/Main/Languages/IronPython/Tests
> MethodCallExpression.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting/Ast
> ReflectedCaller.cs add $/Merlin/Main/Runtime/Microsoft.Scripting/Utils
> Microsoft.Scripting.csproj edit $/Merlin/Main/Runtime/Microsoft.Scripting
> ReflectedCaller.Generated.cs add $/Merlin/Main/Runtime/Microsoft.Scripting
> /Utils
>
> 283390:
>
> (mmaly) AstWriter overhaul
> - expressions are preferably written in one line
> - more nodes implemented
> - more consistent output
>
> AstWriter.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting/Ast
> CatchBlock.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting/Ast
> DeleteUnboundExpression.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting
> /Ast
> DynamicConversionExpression.cs edit $/Merlin/Main/Runtime/Microsof
> t.Scripting/Ast
> UnboundAssignment.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting/Ast
>
> 284474:
>
> (tomat) "Fixes" tons of FxCop warnings. My strategy is as follows: in the
> first phase (this shelveset), enable some groups of rules and "fix" all
> violations to get zero number of warnings. The next checkin will enable
> these groups in SNAP tests and dev test suite so that it won't be possible
> to check in any violation. The last phase will gradually enable and "fix"
> the rest of the rules. Eventually, all rules should be enabled except for
> the rules we will consider bogus - I'll make up an Excel sheet listing those
> that I think are bogus and we can discuss them.
>
> Now, what "fix" does actually mean. It means
>
> a)      the warning is relevant and it is simple to fix it -> fix the
> code.
> b)      the warning is relevant but it would be more work to fix it ->
> suppress it and add comment "//TODO: fix" right after the suppression
> attribute (so we can search for such suppressions easily). These
> suppressions makes up the "baseline".
> c)      the warning is bogus (yet the rule is not) -> suppress the
> warning.
>
> All suppressions are inlined in the code - no global suppression file is
> necessary.
>
> 284812:
>
> (mmaly) Making Ast.Call stricter.
>
> This is next step toward bringing the AST closer to LINQ. LINQ's method
> call expression is much simpler than ours. Parameter types must match, LINQ
> doesn't deal with default parameter values or "params" arrays. I am changing
> the Ast.Call methods to behave in the LINQ way. However, since there are
> some 250 references to the originally behaving methods, most of which depend
> on the loose behavior of the MethodCallExpression node, I am keeping the old
> semantic around (for now - will be going away in the future checkins) as
> WeakCall method. The intent is that no new uses of WeakCall should be
> introduced and the method will go away. The reason for having it around is
> that the variety of binders depend heavily on it and it would be too big of
> a change to do it all at once, so I'd rather take it step by step.
>
> RubyClass.cs edit $/Merlin/Main/Languages/Ruby/Ruby/Builtins
> AstGenerator.cs edit $/Merlin/Main/Languages/Ruby/Ruby/Compiler
> AstFactory.cs edit $/Merlin/Main/Languages/Ruby/Ruby/Compiler/AST
> YieldCall.cs edit $/Merlin/Main/Languages/Ruby
> /Ruby/Compiler/AST/Expressions
> CompoundLeftValue.cs edit $/Merlin/Main/Languages/Ruby
> /Ruby/Compiler/AST/LeftValues
> RubyTests.cs edit $/Merlin/Main/Languages/Ruby/RubyTestHost
> BinderHelper.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting
> DeleteMemberBinderHelper.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting
> /Actions
> Generator.vb edit
> RubyActionBinder.cs edit $/Merlin/Main/Languages/Ruby/Ruby/Runtime
> RubyMethodGroupInfo.cs edit $/Merlin/Main/Languages/Ruby/Ruby/Runtime
> RubyMethodInfo.cs edit $/Merlin/Main/Languages/Ruby/Ruby/Runtime
> ActionBinder.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting/Actions
> CallBinderHelper.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting/Actions
> CreateInstanceBinderHelper.cs edit $/Merlin/Main/Runtime/Microsof
> t.Scripting/Actions
> DoOperationBinderHelper.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting
> /Actions
> FieldTracker.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting/Actions
> GetMemberBinderHelper.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting
> /Actions
> MemberBinderHelper.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting
> /Actions
> SetMemberBinderHelper.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting
> /Actions
> MethodCallExpression.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting/Ast
> TypeUtils.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting/Ast
> ParamsDictArgBuilder.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting
> /Generation
> MethodTarget.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting/Generation
> ReferenceArgBuilder.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting
> /Generation
> DefaultActionBinder.cs edit $/Merlin/Main/Runtime/Tests
> /TestAst/Microsoft.Scripting.Helpers.Actions
> StandardRule.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting/Actions
> BinaryExpression.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting/Ast
> ByRefReturnBuilder.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting
> /Generation
> DynamicType.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting/Types
>
> 284891:
>
> (haiboluo) make the test script externally-run friendly
>
> common.rb edit $/Merlin/Main/Languages/Ruby/Tests
> run.rb edit $/Merlin/Main/Languages/Ruby/Tests
> run_syntax.rb edit $/Merlin/Main/Languages/Ruby/Tests/Syntax
>
> 284926:
>
> (tomat) Adds FxCop to build scripts. Changes ToolsVersion in *.*proj to
> 3.5, so if built from Visual Studio, Orcas FxCop is used (and C# 3.0 as
> well). However, all other build scripts (bdc, bsc, Run.bat, ...) forces
> msbuild to use C# 2.0 (command line argument /ToolsVersion:2.0, the help
> explains: "This version will override the versions specified by individual
> projects"). Without this trick Whidbey msbuild picks Whidbey FxCop msbuild
> task that calls Orcas (!) FxCop backend. As these two are incompatible, bad
> things happen. I think using Orcas C# within Visual Studio is fine as long
> as any other build script will use Whidbey. Also newer version of FxCop has
> more features (e.g. auto-suppress warnings for code marked by
> GeneratedCodeAttribute).
>
> Adds BuildRowan/BuildNession/BuildVBX.cmd scripts, which should be the
> only ones that are directly calling msbuild. They pass /ToolsVersion:2.0to it.
> Also adds Check.cmd which runs FxCop on Microsoft.Scripting.csproj.
> Enables FxCop check in Run 0 by inserting call to Check.cmd.
>
> 284928:
>
> (mmaly) Making the Ast.Condition stricter.
>
> Future checkins will address all WeakCondition instances to replace them
> with correct code.Same idea as the WeakCall. There are several complex
> cases which use the conditional expression's lax design. Introducing
> WeakCondition which will go away, and changing the Condition to check types
> LINQ-style (condition must be bool, both operands identically typed.
> Definitely no optional upcast that sneaked in while I was gone
>
> RubyClass.cs edit $/Merlin/Main/Languages/Ruby/Ruby/Builtins
> ConditionalExpression.cs edit   $/Merlin/Main/Languages/Ruby
> /Ruby/Compiler/AST/Expressions
> UnlessExpression.cs edit $/Merlin/Main/Languages/Ruby
> /Ruby/Compiler/AST/Expressions
> IfExpression.cs edit $/Merlin/Main/Languages/Ruby
> /Ruby/Compiler/AST/Expressions
> ConditionalExpression.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting
> /Ast
> BinaryExpression.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting/Ast
> MethodTarget.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting/Generation
> ReferenceArgBuilder.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting
> /Generation
>
> 285886:
>
> (mmaly) Making throw a statement again.
>
> Body.cs edit $/Merlin/Main/Languages/Ruby/Ruby/Compiler/AST
> Microsoft.Scripting.csproj edit $/Merlin/Main/Runtime/Microsoft.Scripting
> SmallRuleSet.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting/Actions
> StandardRule.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting/Actions
> TryStatementBuilder.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting/Ast
> AstWriter.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting/Ast
> ThrowStatement.cs rename, edit $/Merlin/Main/Runtime/Microsoft.Scripting
> /Ast
> Walker.Generated.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting/Ast
>
> 286041:
>
> (mmaly) Call helpers.
>
> Introducing 3 useful helpers to the DLR. They are pure helpers which
> create AST sub-trees so no magic here, but here they are:
>
> *       ConvertHelper - generate convert node if types don't match
> *       SimpleCallHelper - generates convert nodes around instance and
> arguments of the call. Doesn't deal with param arrays or default arguments.
> It tries to be smart so as to not allocate extra array if not required
> *       ComplexCallHelper - the big gun. This will deal with param arrays
> and default parameter values. Is also smart to not allocate unnecessary
> array, unless things don't match quite well.
>
> All of the instances of WeakCall are converted to either Call, or one of
> the two new call helpers.
>
> RubyMethodGroupInfo.cs edit $/Merlin/Main/Languages/Ruby/Ruby/Runtime
> RubyMethodInfo.cs edit $/Merlin/Main/Languages/Ruby/Ruby/Runtime
> RubyTests.cs edit $/Merlin/Main/Languages/Ruby/RubyTestHost
> RubyClass.cs edit $/Merlin/Main/Languages/Ruby/Ruby/Builtins
> AstGenerator.cs edit $/Merlin/Main/Languages/Ruby/Ruby/Compiler
> AstFactory.cs edit $/Merlin/Main/Languages/Ruby/Ruby/Compiler/AST
> YieldCall.cs edit $/Merlin/Main/Languages/Ruby
> /Ruby/Compiler/AST/Expressions
> CompoundLeftValue.cs edit $/Merlin/Main/Languages/Ruby
> /Ruby/Compiler/AST/LeftValues
> RubyActionBinder.cs edit $/Merlin/Main/Languages/Ruby/Ruby/Runtime
> ActionBinder.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting/Actions
> MemberBinderHelper.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting
> /Actions
> BinaryExpression.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting/Ast
> ByRefReturnBuilder.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting
> /Generation
> MethodTarget.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting/Generation
> ParamsDictArgBuilder.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting
> /Generation
> ReferenceArgBuilder.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting
> /Generation
> DefaultActionBinder.cs edit $/Merlin/Main/Runtime/Tests
> /TestAst/Microsoft.Scripting.Helpers.Actions
> BinderHelper.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting
> UnaryExpression.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting/Ast
> CreateInstanceBinderHelper.cs edit $/Merlin/Main/Runtime/Microsof
> t.Scripting/Actions
> DeleteMemberBinderHelper.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting
> /Actions
> DoOperationBinderHelper.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting
> /Actions
> FieldTracker.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting/Actions
> GetMemberBinderHelper.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting
> /Actions
> SetMemberBinderHelper.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting
> /Actions
> MemberExpression.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting/Ast
> DynamicType.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting/Types
> MethodCallExpression.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting/Ast
> CallBinderHelper.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting/Actions
> StandardRule.cs edit $/Merlin/Main/Runtime/Microsoft.Scripting/Actions
> _______________________________________________
> Ironruby-core mailing list
> Ironruby-core at rubyforge.org
> http://rubyforge.org/mailman/listinfo/ironruby-core
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://rubyforge.org/pipermail/ironruby-core/attachments/20071005/a6c8bbf9/attachment-0001.html 


More information about the Ironruby-core mailing list