public override IExpression VisitSimpleLambdaExpression(SimpleLambdaExpressionSyntax node)
        {
            var o = this.semanticModel.GetSymbolInfo(node);
            var s = o.Symbol as MethodSymbol;

            if (s != null)
            {
                var m = (MethodDefinition)this.mapper.TranslateMetadata(s);
                var anonDelParameters = new List <IParameterDefinition>(m.Parameters);
                this.parameters.Add(m, anonDelParameters);

                IBlockStatement body;
                var             b = node.Body;
                if (b is ExpressionSyntax)
                {
                    var e = this.Visit(b);
                    body = new BlockStatement()
                    {
                        Statements = new List <IStatement>()
                        {
                            new ReturnStatement()
                            {
                                Expression = e,
                            }
                        },
                    };
                }
                else if (b is BlockSyntax)
                {
                    var sv = new StatementVisitor(this.host, this.semanticModel, this.mapper, m, this);
                    var b2 = (IBlockStatement)sv.Visit(b);
                    body = b2;
                }
                else
                {
                    throw new InvalidDataException("VisitSimpleLambdaExpression: unknown type of body");
                }
                var anon = new AnonymousDelegate()
                {
                    Body = body,
                    CallingConvention = s.IsStatic ? CallingConvention.HasThis : CallingConvention.Default,
                    Parameters        = anonDelParameters,
                    ReturnType        = m.Type,
                    Type = this.mapper.Map(this.semanticModel.GetTypeInfo(node).ConvertedType),
                };
                return(anon);
            }
            throw new InvalidDataException("VisitSimpleLambdaExpression couldn't find something to return");
        }
        public BlockStatement GetMethodBody(IMethodDefinition cciMethod, BaseMethodDeclarationSyntax roslynMethod, bool extractContracts)
        {
            Contract.Requires(roslynMethod.Body != null);
            var expressionVisitor = new ExpressionVisitor(this.host, this.semanticModel, this.mapper, cciMethod);
            var sv = new StatementVisitor(this.host, this.semanticModel, this.mapper, cciMethod, expressionVisitor);


            var block = roslynMethod.Body;

            var statements = new List <IStatement>();

            if (roslynMethod.Kind == SyntaxKind.ConstructorDeclaration)
            {
                var            roslynCtor = roslynMethod as ConstructorDeclarationSyntax;
                var            es         = new List <IExpression>();
                var            ps         = new List <IParameterTypeInformation>();
                ITypeReference ctorClass  = null;

                if (roslynCtor.Initializer != null)
                {
                    switch (roslynCtor.Initializer.ThisOrBaseKeyword.Kind)
                    {
                    case SyntaxKind.BaseKeyword:
                        ctorClass = cciMethod.ContainingTypeDefinition.BaseClasses.First(); // safe to assume there is always at least one? what if there are more than one?
                        break;

                    case SyntaxKind.ThisKeyword:
                        ctorClass = cciMethod.ContainingType;
                        break;

                    default:
                        var msg = String.Format("Was unable to convert {0} which was used for a base/this ctor call in {1}",
                                                roslynCtor.Initializer.ThisOrBaseKeyword, MemberHelper.GetMethodSignature(cciMethod));
                        throw new ConverterException(msg);
                    }
                    foreach (var a in roslynCtor.Initializer.ArgumentList.Arguments)
                    {
                        var e = expressionVisitor.Visit(a);
                        es.Add(e);
                    }
                }
                else
                {
                    // Create a call to the nullary base constructor
                    ctorClass = cciMethod.ContainingTypeDefinition.BaseClasses.First(); // safe to assume there is always at least one? what if there are more than one?
                }
                var thisRef = new ThisReference()
                {
                    Type = cciMethod.ContainingType,
                };
                var ctorRef = new Microsoft.Cci.MutableCodeModel.MethodReference()
                {
                    CallingConvention     = CallingConvention.HasThis,
                    ContainingType        = ctorClass,
                    GenericParameterCount = 0,
                    InternFactory         = this.host.InternFactory,
                    Name       = nameTable.Ctor,
                    Parameters = ps,
                    Type       = this.host.PlatformType.SystemVoid,
                };
                statements.Add(
                    new ExpressionStatement()
                {
                    Expression = new MethodCall()
                    {
                        MethodToCall = ctorRef,
                        IsStaticCall = false,
                        ThisArgument = thisRef,
                        Type         = this.host.PlatformType.SystemVoid,
                        Arguments    = es,
                    }
                }
                    );
            }

            statements.Add(
                new EmptyStatement()
            {
                Locations = Helper.SourceLocation(this.semanticModel.SyntaxTree, block.OpenBraceToken),
            }
                );

            foreach (var s in block.Statements)
            {
                var s_prime = sv.Visit(s);
                statements.Add(s_prime);
            }

            // REVIEW: need to do this only if debugging info is needed?
            // (But if it isn't done, then there can be unreachable nops
            // corresponding to close curlys for blocks because of return
            // statements within the block. When that happens at the method
            // level, then peverify is unhappy with the assembly.)
            //if (false) {
            //  // commented this out because it is needed only if this is being used
            //  // to generate IL that in the end should pass peverify (and run).
            //  statements = CreateUnifiedReturnPoint(statements, cciMethod.Type);
            //}

            BlockStatement bs = new BlockStatement()
            {
                Statements = statements,
            };

            return(bs);
        }