EmitLift()

void System.Linq.Expressions.Compiler.LambdaCompiler.EmitLift ( ExpressionType nodeType, Type resultType, MethodCallExpression mc, ParameterExpression[] paramList, Expression[] argList )

inlineprivate

Definition at line 1939 of file LambdaCompiler.cs.

    {
        switch (nodeType)
        {
        default:
        {
            Label label4 = _ilg.DefineLabel();
            Label label5 = _ilg.DefineLabel();
            LocalBuilder local3 = GetLocal(typeof(bool));
            _ilg.Emit(OpCodes.Ldc_I4_0);
            _ilg.Emit(OpCodes.Stloc, local3);
            int j = 0;
            for (int num2 = paramList.Length; j < num2; j++)
            {
                ParameterExpression variable2 = paramList[j];
                Expression expression2 = argList[j];
                if (expression2.Type.IsNullableType())
                {
                    _scope.AddLocal(this, variable2);
                    EmitAddress(expression2, expression2.Type);
                    _ilg.Emit(OpCodes.Dup);
                    _ilg.EmitHasValue(expression2.Type);
                    _ilg.Emit(OpCodes.Ldc_I4_0);
                    _ilg.Emit(OpCodes.Ceq);
                    _ilg.Emit(OpCodes.Stloc, local3);
                    _ilg.EmitGetValueOrDefault(expression2.Type);
                    _scope.EmitSet(variable2);
                }
                else
                {
                    _scope.AddLocal(this, variable2);
                    EmitExpression(expression2);
                    if (!expression2.Type.IsValueType)
                    {
                        _ilg.Emit(OpCodes.Dup);
                        _ilg.Emit(OpCodes.Ldnull);
                        _ilg.Emit(OpCodes.Ceq);
                        _ilg.Emit(OpCodes.Stloc, local3);
                    }
                    _scope.EmitSet(variable2);
                }
                _ilg.Emit(OpCodes.Ldloc, local3);
                _ilg.Emit(OpCodes.Brtrue, label5);
            }
            EmitMethodCallExpression(mc);
            if (resultType.IsNullableType() && !TypeUtils.AreEquivalent(resultType, mc.Type))
            {
                ConstructorInfo nullableConstructor2 = TypeUtils.GetNullableConstructor(resultType);
                _ilg.Emit(OpCodes.Newobj, nullableConstructor2);
            }
            _ilg.Emit(OpCodes.Br_S, label4);
            _ilg.MarkLabel(label5);
            if (TypeUtils.AreEquivalent(resultType, mc.Type.GetNullableType()))
            {
                if (resultType.IsValueType)
                {
                    LocalBuilder local4 = GetLocal(resultType);
                    _ilg.Emit(OpCodes.Ldloca, local4);
                    _ilg.Emit(OpCodes.Initobj, resultType);
                    _ilg.Emit(OpCodes.Ldloc, local4);
                    FreeLocal(local4);
                }
                else
                {
                    _ilg.Emit(OpCodes.Ldnull);
                }
            }
            else
            {
                _ilg.Emit(OpCodes.Ldc_I4_0);
            }
            _ilg.MarkLabel(label4);
            FreeLocal(local3);
            break;
        }
        case ExpressionType.Equal:
        case ExpressionType.NotEqual:
            if (!TypeUtils.AreEquivalent(resultType, mc.Type.GetNullableType()))
            {
                Label label = _ilg.DefineLabel();
                Label label2 = _ilg.DefineLabel();
                Label label3 = _ilg.DefineLabel();
                LocalBuilder local = GetLocal(typeof(bool));
                LocalBuilder local2 = GetLocal(typeof(bool));
                _ilg.Emit(OpCodes.Ldc_I4_0);
                _ilg.Emit(OpCodes.Stloc, local);
                _ilg.Emit(OpCodes.Ldc_I4_1);
                _ilg.Emit(OpCodes.Stloc, local2);
                int i = 0;
                for (int num = paramList.Length; i < num; i++)
                {
                    ParameterExpression variable = paramList[i];
                    Expression expression = argList[i];
                    _scope.AddLocal(this, variable);
                    if (expression.Type.IsNullableType())
                    {
                        EmitAddress(expression, expression.Type);
                        _ilg.Emit(OpCodes.Dup);
                        _ilg.EmitHasValue(expression.Type);
                        _ilg.Emit(OpCodes.Ldc_I4_0);
                        _ilg.Emit(OpCodes.Ceq);
                        _ilg.Emit(OpCodes.Dup);
                        _ilg.Emit(OpCodes.Ldloc, local);
                        _ilg.Emit(OpCodes.Or);
                        _ilg.Emit(OpCodes.Stloc, local);
                        _ilg.Emit(OpCodes.Ldloc, local2);
                        _ilg.Emit(OpCodes.And);
                        _ilg.Emit(OpCodes.Stloc, local2);
                        _ilg.EmitGetValueOrDefault(expression.Type);
                    }
                    else
                    {
                        EmitExpression(expression);
                        if (!expression.Type.IsValueType)
                        {
                            _ilg.Emit(OpCodes.Dup);
                            _ilg.Emit(OpCodes.Ldnull);
                            _ilg.Emit(OpCodes.Ceq);
                            _ilg.Emit(OpCodes.Dup);
                            _ilg.Emit(OpCodes.Ldloc, local);
                            _ilg.Emit(OpCodes.Or);
                            _ilg.Emit(OpCodes.Stloc, local);
                            _ilg.Emit(OpCodes.Ldloc, local2);
                            _ilg.Emit(OpCodes.And);
                            _ilg.Emit(OpCodes.Stloc, local2);
                        }
                        else
                        {
                            _ilg.Emit(OpCodes.Ldc_I4_0);
                            _ilg.Emit(OpCodes.Stloc, local2);
                        }
                    }
                    _scope.EmitSet(variable);
                }
                _ilg.Emit(OpCodes.Ldloc, local2);
                _ilg.Emit(OpCodes.Brtrue, label2);
                _ilg.Emit(OpCodes.Ldloc, local);
                _ilg.Emit(OpCodes.Brtrue, label3);
                EmitMethodCallExpression(mc);
                if (resultType.IsNullableType() && !TypeUtils.AreEquivalent(resultType, mc.Type))
                {
                    ConstructorInfo nullableConstructor = TypeUtils.GetNullableConstructor(resultType);
                    _ilg.Emit(OpCodes.Newobj, nullableConstructor);
                }
                _ilg.Emit(OpCodes.Br_S, label);
                _ilg.MarkLabel(label2);
                _ilg.EmitPrimitive(nodeType == ExpressionType.Equal);
                _ilg.Emit(OpCodes.Br_S, label);
                _ilg.MarkLabel(label3);
                _ilg.EmitPrimitive(nodeType == ExpressionType.NotEqual);
                _ilg.MarkLabel(label);
                FreeLocal(local);
                FreeLocal(local2);
                break;
            }
            goto default;
        }
    }

References System.Linq.Expressions.Compiler.LambdaCompiler._ilg, System.Linq.Expressions.Compiler.LambdaCompiler._scope, System.Linq.Expressions.Compiler.CompilerScope.AddLocal(), System.Reflection.Emit.OpCodes.And, System.Dynamic.Utils.TypeUtils.AreEquivalent(), System.Reflection.Emit.OpCodes.Br_S, System.Reflection.Emit.OpCodes.Brtrue, System.Reflection.Emit.OpCodes.Ceq, System.Reflection.Emit.ILGenerator.DefineLabel(), System.Reflection.Emit.OpCodes.Dup, System.Reflection.Emit.ILGenerator.Emit(), System.Linq.Expressions.Compiler.LambdaCompiler.EmitAddress(), System.Linq.Expressions.Compiler.LambdaCompiler.EmitExpression(), System.Linq.Expressions.Compiler.LambdaCompiler.EmitMethodCallExpression(), System.Linq.Expressions.Compiler.CompilerScope.EmitSet(), System.Linq.Expressions.Compiler.LambdaCompiler.FreeLocal(), System.Linq.Expressions.Compiler.LambdaCompiler.GetLocal(), System.Dynamic.Utils.TypeUtils.GetNullableConstructor(), System.Reflection.Emit.OpCodes.Initobj, System.Reflection.Emit.OpCodes.Ldc_I4_0, System.Reflection.Emit.OpCodes.Ldc_I4_1, System.Reflection.Emit.OpCodes.Ldloc, System.Reflection.Emit.OpCodes.Ldloca, System.Reflection.Emit.OpCodes.Ldnull, System.Reflection.Emit.ILGenerator.MarkLabel(), System.Reflection.Emit.OpCodes.Newobj, System.Reflection.Emit.OpCodes.Or, and System.Reflection.Emit.OpCodes.Stloc.

Referenced by System.Linq.Expressions.Compiler.LambdaCompiler.EmitBinaryMethod(), and System.Linq.Expressions.Compiler.LambdaCompiler.EmitUnaryMethod().