IronRuby.Builtins.RubyClass.BuildAllocatorCall C# (CSharp) Method

        public bool BuildAllocatorCall(MetaObjectBuilder/*!*/ metaBuilder, CallArguments/*!*/ args, Func<Expression>/*!*/ defaultExceptionMessage) {
            var newExpression = GetAllocatorNewExpression(args, defaultExceptionMessage);
            if (newExpression != null) {
                metaBuilder.Result = MarkNewException(newExpression);
                return true;
            } else {
                return false;
            }
        }

        public static RuleGenerator /*!*/ GetException()
        {
            return(new RuleGenerator((metaBuilder, args, name) => {
                Debug.Assert(args.Target is Exception);

                // 1 optional parameter (exceptionArg):
                var argsBuilder = new ArgsBuilder(0, 0, 1, false);
                argsBuilder.AddCallArguments(metaBuilder, args);

                if (!metaBuilder.Error)
                {
                    if (argsBuilder.ExplicitArgumentCount == 0)
                    {
                        metaBuilder.Result = args.TargetExpression;
                    }
                    else
                    {
                        RubyClass cls = args.RubyContext.GetClassOf(args.Target);
                        var classExpression = AstUtils.Constant(cls);
                        args.SetTarget(classExpression, cls);

                        ParameterExpression messageVariable = null;

                        // RubyOps.MarkException(new <exception-type>(GetClrMessage(<class>, #message = <message>)))
                        if (cls.BuildAllocatorCall(metaBuilder, args, () =>
                                                   Ast.Call(null, new Func <RubyClass, object, string>(GetClrMessage).Method,
                                                            classExpression,
                                                            Ast.Assign(messageVariable = metaBuilder.GetTemporary(typeof(object), "#message"), AstUtils.Box(argsBuilder[0]))
                                                            )
                                                   ))
                        {
                            // ReinitializeException(<result>, #message)
                            metaBuilder.Result = Ast.Call(null, new Func <RubyContext, Exception, object, Exception>(ReinitializeException).Method,
                                                          AstUtils.Convert(args.MetaContext.Expression, typeof(RubyContext)),
                                                          metaBuilder.Result,
                                                          messageVariable ?? AstUtils.Box(argsBuilder[0])
                                                          );
                        }
                        else
                        {
                            metaBuilder.SetError(Methods.MakeAllocatorUndefinedError.OpCall(Ast.Convert(args.TargetExpression, typeof(RubyClass))));
                        }
                    }
                }
            }));
        }