Example #1
0
        internal override MSA.Expression /*!*/ TransformRead(AstGenerator /*!*/ gen)
        {
            if (gen.CurrentMethod.IsTopLevelCode && gen.CurrentBlock == null && !gen.CompilerOptions.IsEval)
            {
                return(Ast.Throw(Methods.MakeTopLevelSuperException.OpCall()));
            }

            // invoke super member action:
            CallBuilder callBuilder = new CallBuilder(gen);

            // self:
            callBuilder.Instance = gen.CurrentSelfVariable;

            // arguments:
            if (Arguments != null)
            {
                Arguments.TransformToCall(gen, callBuilder);
            }
            else
            {
                // copy parameters from the method:
                // TODO: parameters in top-level eval
                LexicalScope.TransformParametersToSuperCall(gen, callBuilder, gen.CurrentMethod.Parameters);
            }

            // block:
            MSA.Expression transformedBlock;
            if (Block != null)
            {
                transformedBlock = Block.Transform(gen);
            }
            else
            {
                transformedBlock = gen.MakeMethodBlockParameterRead();
            }

            // variable assigned to the transformed block in MakeCallWithBlockRetryable:
            MSA.Expression blockArgVariable = gen.CurrentScope.DefineHiddenVariable("#super-call-block", typeof(Proc));
            callBuilder.Block = blockArgVariable;

            // TODO: this could be improved, currently the right method name and declaring module is always searched for at run-time (at the site):

            return(gen.DebugMark(
                       MethodCall.MakeCallWithBlockRetryable(gen,
                                                             callBuilder.MakeSuperCallAction(gen.CurrentFrame.UniqueId),
                                                             blockArgVariable,
                                                             transformedBlock,
                                                             Block != null && Block.IsDefinition
                                                             ),
                       "#RB: super call ('" + gen.CurrentMethod.MethodName + "')"
                       ));
        }
Example #2
0
        internal override MSA.Expression/*!*/ TransformRead(AstGenerator/*!*/ gen) {
            if (gen.CurrentMethod.IsTopLevelCode && gen.CurrentBlock == null && !gen.CompilerOptions.IsEval) {
                return Ast.Throw(Methods.MakeTopLevelSuperException.OpCall());
            }

            // invoke super member action:
            CallBuilder callBuilder = new CallBuilder(gen);

            // self:
            callBuilder.Instance = gen.CurrentSelfVariable;

            // arguments:
            if (Arguments != null) {
                Arguments.TransformToCall(gen, callBuilder);
            } else {
                // copy parameters from the method:
                // TODO: parameters in top-level eval
                LexicalScope.TransformParametersToSuperCall(gen, callBuilder, gen.CurrentMethod.Parameters);
            }

            // block:
            MSA.Expression transformedBlock;
            if (Block != null) {
                transformedBlock = Block.Transform(gen);
            } else {
                transformedBlock = gen.MakeMethodBlockParameterRead();
            }

            // variable assigned to the transformed block in MakeCallWithBlockRetryable:
            MSA.Expression blockArgVariable = gen.CurrentScope.DefineHiddenVariable("#super-call-block", typeof(Proc));
            callBuilder.Block = blockArgVariable;

            // TODO: this could be improved, currently the right method name and declaring module is always searched for at run-time (at the site):

            return gen.DebugMark(
                MethodCall.MakeCallWithBlockRetryable(gen, 
                    callBuilder.MakeSuperCallAction(gen.CurrentFrame.UniqueId), 
                    blockArgVariable, 
                    transformedBlock,
                    Block != null && Block.IsDefinition
                ),
                "#RB: super call ('" + gen.CurrentMethod.MethodName + "')"
            );
        }
Example #3
0
        internal void TransformToCall(AstGenerator /*!*/ gen, CallBuilder callBuilder)
        {
            if (_expressions != null)
            {
                foreach (var arg in _expressions)
                {
                    callBuilder.Add(arg.TransformRead(gen));
                }
            }

            if (_maplets != null)
            {
                callBuilder.Add(gen.TransformToHashConstructor(_maplets));
            }

            if (_array != null)
            {
                callBuilder.SplattedArgument = _array.TransformRead(gen);
            }
        }
Example #4
0
        // arguments: complex arguments (expressions, maplets, splat, block) 
        // singleArgument: siple argument (complex are not used)
        // assignmentRhsArgument: rhs of the assignment: target.method=(rhs)
        internal static MSA.Expression/*!*/ TransformRead(Expression/*!*/ node, AstGenerator/*!*/ gen, bool hasImplicitSelf, 
            string/*!*/ methodName, MSA.Expression/*!*/ transformedTarget,
            Arguments arguments, Block block, MSA.Expression singleArgument, MSA.Expression assignmentRhsArgument) {

            Debug.Assert(assignmentRhsArgument == null || block == null, "Block not allowed in assignment");
            Debug.Assert(singleArgument == null || arguments == null && assignmentRhsArgument == null);
            Assert.NotNull(gen, transformedTarget);
            Assert.NotEmpty(methodName);

            // Pass args in this order:
            // 1. instance
            // 2. block (if present)
            // 3. passed args: normal args, maplets, array
            // 4. RHS of assignment (if present)

            CallBuilder callBuilder = new CallBuilder(gen);
            callBuilder.Instance = transformedTarget;
            
            MSA.Expression blockArgVariable = null;
            MSA.Expression transformedBlock = null;

            if (block != null) {
                blockArgVariable = gen.CurrentScope.DefineHiddenVariable("#block-def", typeof(Proc));
                transformedBlock = block.Transform(gen);
                callBuilder.Block = blockArgVariable;
            }

            if (arguments != null) {
                arguments.TransformToCall(gen, callBuilder);
            } else if (singleArgument != null) {
                callBuilder.Add(singleArgument);
            }

            MSA.Expression rhsVariable = null;
            if (assignmentRhsArgument != null) {
                rhsVariable = gen.CurrentScope.DefineHiddenVariable("#rhs", assignmentRhsArgument.Type);
                callBuilder.RhsArgument = Ast.Assign(rhsVariable, assignmentRhsArgument);
            }

            var dynamicSite = callBuilder.MakeCallAction(methodName, hasImplicitSelf);
            if (gen.Context.CallSiteCreated != null) {
                gen.Context.CallSiteCreated(node, dynamicSite);
            }

            MSA.Expression result = gen.DebugMark(dynamicSite, methodName);

            if (block != null) {
                result = gen.DebugMark(MakeCallWithBlockRetryable(gen, result, blockArgVariable, transformedBlock, block.IsDefinition),
                    "#RB: method call with a block ('" + methodName + "')");
            }

            if (assignmentRhsArgument != null) {
                result = AstFactory.Block(result, rhsVariable);
            }

            return result;
        }
Example #5
0
        internal void TransformToCall(AstGenerator/*!*/ gen, CallBuilder callBuilder) {
            if (_expressions != null) {
                foreach (var arg in _expressions) {
                    callBuilder.Add(arg.TransformRead(gen));
                }
            }

            if (_maplets != null) {
                callBuilder.Add(gen.TransformToHashConstructor(_maplets));
            }

            if (_array != null) {
                callBuilder.SplattedArgument = 
                    Ast.Dynamic(SplatAction.Make(gen.Context), typeof(IList), _array.TransformRead(gen));
            }
        }
Example #6
0
        internal void TransformToCall(AstGenerator/*!*/ gen, CallBuilder callBuilder) {
            if (_expressions != null) {
                foreach (var arg in _expressions) {
                    callBuilder.Add(arg.TransformRead(gen));
                }
            }

            if (_maplets != null) {
                callBuilder.Add(gen.TransformToHashConstructor(_maplets));
            }

            if (_array != null) {
                callBuilder.SplattedArgument = _array.TransformRead(gen);
            }
        }
Example #7
0
        // arguments: complex arguments (expressions, maplets, splat, block)
        // singleArgument: siple argument (complex are not used)
        // assignmentRhsArgument: rhs of the assignment: target.method=(rhs)
        internal static MSA.Expression /*!*/ TransformRead(Expression /*!*/ node, AstGenerator /*!*/ gen, bool hasImplicitSelf,
                                                           string /*!*/ methodName, MSA.Expression /*!*/ transformedTarget,
                                                           Arguments arguments, Block block, MSA.Expression singleArgument, MSA.Expression assignmentRhsArgument)
        {
            Debug.Assert(assignmentRhsArgument == null || block == null, "Block not allowed in assignment");
            Debug.Assert(singleArgument == null || arguments == null && assignmentRhsArgument == null);
            Assert.NotNull(gen, transformedTarget);
            Assert.NotEmpty(methodName);

            // Pass args in this order:
            // 1. instance
            // 2. block (if present)
            // 3. passed args: normal args, maplets, array
            // 4. RHS of assignment (if present)

            CallBuilder callBuilder = new CallBuilder(gen);

            callBuilder.Instance = transformedTarget;

            MSA.Expression blockArgVariable = null;
            MSA.Expression transformedBlock = null;

            if (block != null)
            {
                blockArgVariable  = gen.CurrentScope.DefineHiddenVariable("#block-def", typeof(Proc));
                transformedBlock  = block.Transform(gen);
                callBuilder.Block = blockArgVariable;
            }

            if (arguments != null)
            {
                arguments.TransformToCall(gen, callBuilder);
            }
            else if (singleArgument != null)
            {
                callBuilder.Add(singleArgument);
            }

            MSA.Expression rhsVariable = null;
            if (assignmentRhsArgument != null)
            {
                rhsVariable             = gen.CurrentScope.DefineHiddenVariable("#rhs", assignmentRhsArgument.Type);
                callBuilder.RhsArgument = Ast.Assign(rhsVariable, assignmentRhsArgument);
            }

            var dynamicSite = callBuilder.MakeCallAction(methodName, hasImplicitSelf);

            gen.TraceCallSite(node, dynamicSite);

            MSA.Expression result = gen.DebugMark(dynamicSite, methodName);

            if (block != null)
            {
                result = gen.DebugMark(MakeCallWithBlockRetryable(gen, result, blockArgVariable, transformedBlock, block.IsDefinition),
                                       "#RB: method call with a block ('" + methodName + "')");
            }

            if (assignmentRhsArgument != null)
            {
                result = AstFactory.Block(result, rhsVariable);
            }

            return(result);
        }