// UNDONE: Rename to CreateBoundAnonymousFunction
        public EXPRBOUNDLAMBDA CreateAnonymousMethod(AggregateType delegateType)
        {
            Debug.Assert(delegateType == null || delegateType.isDelegateType());
            EXPRBOUNDLAMBDA rval = new EXPRBOUNDLAMBDA();

            rval.kind  = ExpressionKind.EK_BOUNDLAMBDA;
            rval.type  = delegateType;
            rval.flags = 0;
            Debug.Assert(rval != null);
            return(rval);
        }
Ejemplo n.º 2
0
 protected EXPR DestroyWraps(EXPRBOUNDLAMBDA anonmeth, EXPR sequence)
 {
     for (Symbol sym = anonmeth.ArgumentScope(); sym != null; sym = sym.nextChild)
     {
         if (!sym.IsLocalVariableSymbol())
         {
             continue;
         }
         LocalVariableSymbol local = sym.AsLocalVariableSymbol();
         if (local.isThis)
         {
             continue;
         }
         Debug.Assert(local.wrap != null);
         Debug.Assert(anonmeth.OptionalBody != null);
         EXPR freeWrap = GetExprFactory().CreateWrap(anonmeth.OptionalBody.OptionalScopeSymbol, local.wrap);
         sequence = GetExprFactory().CreateReverseSequence(sequence, freeWrap);
     }
     return sequence;
 }
Ejemplo n.º 3
0
        protected EXPR CreateWraps(EXPRBOUNDLAMBDA anonmeth)
        {
            EXPR sequence = null;
            for (Symbol sym = anonmeth.ArgumentScope().firstChild; sym != null; sym = sym.nextChild)
            {
                if (!sym.IsLocalVariableSymbol())
                {
                    continue;
                }
                LocalVariableSymbol local = sym.AsLocalVariableSymbol();
                if (local.isThis)
                {
                    continue;
                }
                Debug.Assert(anonmeth.OptionalBody != null);
                EXPR create = GenerateParameter(local.name.Text, local.GetType());
                local.wrap = GetExprFactory().CreateWrapNoAutoFree(anonmeth.OptionalBody.OptionalScopeSymbol, create);
                EXPR save = GetExprFactory().CreateSave(local.wrap);
                if (sequence == null)
                {
                    sequence = save;
                }
                else
                {
                    sequence = GetExprFactory().CreateSequence(sequence, save);
                }
            }

            return sequence;
        }
Ejemplo n.º 4
0
        protected EXPR RewriteLambdaParameters(EXPRBOUNDLAMBDA anonmeth)
        {
            Debug.Assert(anonmeth != null);

            // new ParameterExpression[2] {Parameter(typeof(type1), name1), Parameter(typeof(type2), name2)}

            EXPR paramArrayInitializerArgs = null;
            EXPR paramArrayInitializerArgsTail = paramArrayInitializerArgs;

            for (Symbol sym = anonmeth.ArgumentScope(); sym != null; sym = sym.nextChild)
            {
                if (!sym.IsLocalVariableSymbol())
                {
                    continue;
                }
                LocalVariableSymbol local = sym.AsLocalVariableSymbol();
                if (local.isThis)
                {
                    continue;
                }
                GetExprFactory().AppendItemToList(local.wrap, ref paramArrayInitializerArgs, ref paramArrayInitializerArgsTail);
            }

            return GenerateParamsArray(paramArrayInitializerArgs, PredefinedType.PT_PARAMETEREXPRESSION);
        }
Ejemplo n.º 5
0
        protected EXPR RewriteLambdaBody(EXPRBOUNDLAMBDA anonmeth)
        {
            Debug.Assert(anonmeth != null);
            Debug.Assert(anonmeth.OptionalBody != null);
            Debug.Assert(anonmeth.OptionalBody.GetOptionalStatements() != null);
            // There ought to be no way to get an empty statement block successfully converted into an expression tree.
            Debug.Assert(anonmeth.OptionalBody.GetOptionalStatements().GetOptionalNextStatement() == null);

            EXPRBLOCK body = anonmeth.OptionalBody;

            // The most likely case:
            if (body.GetOptionalStatements().isRETURN())
            {
                Debug.Assert(body.GetOptionalStatements().asRETURN().GetOptionalObject() != null);
                return Visit(body.GetOptionalStatements().asRETURN().GetOptionalObject());
            }
            // This can only if it is a void delegate and this is a void expression, such as a call to a void method
            // or something like Expression<Action<Foo>> e = (Foo f) => f.MyEvent += MyDelegate;

            throw Error.InternalCompilerError();
        }
Ejemplo n.º 6
0
        /////////////////////////////////////////////////////////////////////////////////
        // Expression types.

        protected override EXPR VisitBOUNDLAMBDA(EXPRBOUNDLAMBDA anonmeth)
        {
            Debug.Assert(anonmeth != null);

            EXPRBOUNDLAMBDA prevAnonMeth = currentAnonMeth;
            currentAnonMeth = anonmeth;
            MethodSymbol lambdaMethod = GetPreDefMethod(PREDEFMETH.PM_EXPRESSION_LAMBDA);

            CType delegateType = anonmeth.DelegateType();
            TypeArray lambdaTypeParams = GetSymbolLoader().getBSymmgr().AllocParams(1, new CType[] { delegateType });
            AggregateType expressionType = GetSymbolLoader().GetOptPredefTypeErr(PredefinedType.PT_EXPRESSION, true);
            MethWithInst mwi = new MethWithInst(lambdaMethod, expressionType, lambdaTypeParams);
            EXPR createParameters = CreateWraps(anonmeth);
            EXPR body = RewriteLambdaBody(anonmeth);
            EXPR parameters = RewriteLambdaParameters(anonmeth);
            EXPR args = GetExprFactory().CreateList(body, parameters);
            CType typeRet = GetSymbolLoader().GetTypeManager().SubstType(mwi.Meth().RetType, mwi.GetType(), mwi.TypeArgs);
            EXPRMEMGRP pMemGroup = GetExprFactory().CreateMemGroup(null, mwi);
            EXPR callLambda = GetExprFactory().CreateCall(0, typeRet, args, pMemGroup, mwi);

            callLambda.asCALL().PredefinedMethod = PREDEFMETH.PM_EXPRESSION_LAMBDA;

            currentAnonMeth = prevAnonMeth;
            if (createParameters != null)
            {
                callLambda = GetExprFactory().CreateSequence(createParameters, callLambda);
            }
            EXPR expr = DestroyWraps(anonmeth, callLambda);
            // If we are already inside an expression tree rewrite and this is an expression tree lambda
            // then it needs to be quoted.
            if (currentAnonMeth != null)
            {
                expr = GenerateCall(PREDEFMETH.PM_EXPRESSION_QUOTE, expr);
            }
            return expr;
        }
Ejemplo n.º 7
0
 protected virtual EXPR VisitBOUNDLAMBDA(EXPRBOUNDLAMBDA pExpr)
 {
     return VisitEXPR(pExpr);
 }
Ejemplo n.º 8
0
 protected virtual EXPR VisitBOUNDLAMBDA(EXPRBOUNDLAMBDA pExpr)
 {
     return(VisitEXPR(pExpr));
 }
Ejemplo n.º 9
0
 public EXPRBOUNDLAMBDA CreateAnonymousMethod(AggregateType delegateType)
 {
     Debug.Assert(delegateType == null || delegateType.isDelegateType());
     EXPRBOUNDLAMBDA rval = new EXPRBOUNDLAMBDA();
     rval.kind = ExpressionKind.EK_BOUNDLAMBDA;
     rval.type = delegateType;
     rval.flags = 0;
     Debug.Assert(rval != null);
     return (rval);
 }