private static NRefactory.ConstructorDeclaration FiltertConstructorStatements(NRefactory.ConstructorDeclaration constructorDeclaration, Type baseType) {
            var block = new NRefactory.BlockStatement();

            foreach (var statement in constructorDeclaration.Body.Statements) {
                var expression = statement as NRefactory.ExpressionStatement;

                if (expression != null) {
                    if (expression.Expression is NRefactory.AssignmentExpression) {
                        continue;
                    }

                    var invocation = expression.Expression as NRefactory.InvocationExpression;

                    block.Add(statement.Clone());

                    if (invocation != null && invocation.HasAnnotationOf<Cecil.MethodReference>()) {
                        var methodReference = invocation.Annotation<Cecil.MethodReference>();

                        if (methodReference.Name.Equals(".ctor") && methodReference.DeclaringType.GetActualType().Equals(baseType)) {
                            block.AddReturnStatement(new NRefactory.ThisReferenceExpression());
                            constructorDeclaration.Body = block;
                            break;
                        }
                    }
                }
                else {
                    block.Add(statement.Clone());
                }
            }

            return constructorDeclaration;
        }

        protected internal Index(NRefactory.IndexerExpression indexerExpression, IScope scope, INRefcatoryExpressionVisitor visitor)
            : base(scope, visitor) {
            bool isAssignment = false;
            PropertyReference propertyReference = null;

            _indexerExpression = indexerExpression;
            isAssignment = IsAssignment();
            Target = indexerExpression.Target.AcceptVisitor(Visitor, ParentScope);
            TryGetArguments();

            if (indexerExpression.HasAnnotationOf<PropertyReference>(out propertyReference)) {
                var propertyInfo = Target.Type.GetProperty(propertyReference.Name);

                InternalType = propertyInfo.PropertyType;
                _indexer = propertyInfo;
            }
            else {
                _isArrayIndex = true;
                var targetType = Target.Type;

                if (targetType.HasElementType) {
                    targetType = Target.Type.GetElementType();
                }

                InternalType = targetType;
                _methodCall = _isAssignment ? Expression.ArrayAccess : (Func<Expression, IEnumerable<Expression>, Expression>)Expression.ArrayAccess;
            }
        }

        protected internal ArrayCreation(NRefactory.ArrayCreateExpression arrayCreateExpression, IScope scope, INRefcatoryExpressionVisitor visitor)
            : base(scope, visitor) {
            
            _arrayCreateExpression = arrayCreateExpression;
            _isJaggeedArray = IsJaggedArray();
            _isVector = IsVector();
            InternalType = GetArrayType();

            if (InternalType.GetArrayRank() == 1 && !_isJaggeedArray) {
                if (TryGetOneDimensionalArrayBounds()) {
                    BuildEmptyOneDimensionalArray();
                }
                else {
                    BuildOneDimensionalArray();
                }
            }
            else {
                if (TryGetBounds()) {
                    BuildEmptyMultiDimensionalArray();
                }
                else {
                    BuildMultiDimensionalArrayAccess();
                }
            }
        }

 protected internal Switch(NRefactory.SwitchStatement switchStatement, IScope scope, INRefcatoryExpressionVisitor visitor)
     : base(scope, visitor) {
     _switchStatement = switchStatement;
     SwitchValue = switchStatement.Expression.AcceptVisitor(Visitor, scope);
     BuildSwitchCases();
     InternalType = TypeSystem.Void;
 }

        protected internal New(NRefactory.ObjectCreateExpression objectCreation, IScope scope, INRefcatoryExpressionVisitor visitor)
            : base(scope, visitor) {
            
            _objectCreation = objectCreation;

            if (!objectCreation.Type.IsNull) {
                InternalType = objectCreation.Type.AcceptVisitor(Visitor, ParentScope).Type;

                if (objectCreation.Initializer != null) {
                    if (objectCreation.Arguments.Count == 2) {
                        Expression expression;
                        NRefactory.Expression @this = objectCreation.Arguments.First();
                        NRefactory.Expression func = objectCreation.Arguments.Last();

                        if (TryHandleAnonymousMethod(@this, func as NRefactory.InvocationExpression, out expression)) {
                            Expression = expression;
                            return;
                        }
                    }

                    if (objectCreation.Initializer != NRefactory.ArrayInitializerExpression.Null) {
                        Expression = objectCreation.Initializer.AcceptVisitor(Visitor, ParentScope);
                        return;
                    }
                }

                Expression = BuildConstructor();
            }
            else {
                Expression = HandleAnonymousType();
            }
        }

 protected internal Direction(NRefactory.DirectionExpression directionExpression, IScope scope, INRefcatoryExpressionVisitor visitor)
     : base(scope, visitor) {
     _directionExpression = directionExpression;
     IdentifierParameter = directionExpression.Expression.AcceptVisitor(Visitor, scope) as Identifier;
     _outParameter = ParentScope.Find(IdentifierParameter.Name);
     InternalType = IdentifierParameter.Type;
 }

 protected internal CaseLabel(NRefactory.CaseLabel caseLabel, IScope scope, INRefcatoryExpressionVisitor visitor)
     : base(scope, visitor) {
     var expression = caseLabel.Expression;
     _caseLabel = caseLabel;
     DefaultValue = expression.AcceptVisitor(Visitor, ParentScope);
     InternalType = DefaultValue.Type;
 }

 protected internal Identifier(NRefactory.IdentifierExpression identifierExpression, IScope scope, INRefcatoryExpressionVisitor visitor)
     : base(scope, visitor) {
     _identifierExpression = identifierExpression;
     Expression = scope.Find(_identifierExpression.Identifier);
     InternalType = Expression.Type;
     Name = _identifierExpression.Identifier;
 }

        protected internal Invocation(NRefactory.InvocationExpression invocationExpression, IScope scope, INRefcatoryExpressionVisitor visitor)
            : base(scope, visitor) {
            
            var methodReference = invocationExpression.Annotation<Mono.Cecil.MethodReference>();

            _invocationExpression = invocationExpression;

            if (methodReference != null) {
                MethodInfo methodInfo = null;
                Member = methodInfo = methodReference.GetActualMethod<MethodInfo>();

                if (IsInitializeArray(methodInfo)) {
                    var first = _invocationExpression.Arguments.First().AcceptVisitor(Visitor, ParentScope);
                    var invocation = _invocationExpression.Arguments.Last() as NRefactory.InvocationExpression;
                    var second = invocation.Arguments.First();
                    var memberReference = invocationExpression.Target as NRefactory.MemberReferenceExpression;
                    var target = memberReference.Target as NRefactory.TypeReferenceExpression;
                    var type = target.Type.GetActualType();
                    var parameters = methodReference.Parameters;
                    return;
                }
            }

            BuildInvocation();
        }

        public MappedInvocation(NRefactory.ConstructorDeclaration ctor, MethodDefinition baseCtor) {
            var parameterTypes = new List<Type>();
            var ctorType = ctor.GetActualType();

            _parameters = ctor.Parameters
                              .Select((p, i) => {
                                  return new Parameter(p.Name, p.GetActualType(), i);
                              })
                              .ToArray();

            _parameterDeclarations = ctor.Parameters.ToArray();
            _visitor.VisitConstructorDeclaration(ctor, null);
            _outParameters = new List<Parameter>();
            parameterTypes = new List<Type>();

            _parameters.ForEach((p, i) => {
                var type = p.Type;

                if (_visitor.Contains(p.Name)) {
                    if (!type.IsByRef) {
                        type = type.MakeByRefType();
                        p = new Parameter(p.Name, type, p.Location);
                    }

                    _outParameters.Add(p);
                }

                parameterTypes.Add(type);
            });

            VerifyUniqueness(ctorType, parameterTypes);
            Parameters = parameterTypes.ToArray();
        }

 protected internal NamedExpression(NRefactory.NamedExpression namedExpression, IScope scope, INRefcatoryExpressionVisitor visitor)
     : base(scope, visitor) {
     Name = namedExpression.Identifier;
     _namedExpression = namedExpression;
     Expression = _namedExpression.Expression.AcceptVisitor(Visitor, ParentScope);
     InternalType = Expression.Type;
 }

        protected internal Init(NRefactory.VariableInitializer variableInitializer, IScope scope, INRefcatoryExpressionVisitor visitor)
            : base(scope, visitor) {
            NRefactory.Expression initializer = null;

            _variableInitializer = variableInitializer;
            initializer = variableInitializer.Initializer;
        }

 public static ConstructorBlock ConstructorBlock(NRefactory.BlockStatement blockStatement,
                                                 ParameterExpression contextParameter,
                                                 IScope scope,
                                                 INRefcatoryExpressionVisitor visitor,
                                                 IEnumerable<ParameterExpression> parameters = null,
                                                 IEnumerable<ParameterExpression> baseConstructorParameters = null) {
     return new ConstructorBlock(blockStatement, contextParameter, parameters: parameters, scope: scope, visitor: visitor, baseConstructorParameters: baseConstructorParameters);
 }

        protected internal Block(NRefactory.BlockStatement blockStatement, IScope scope, INRefcatoryExpressionVisitor visitor, IEnumerable<ParameterExpression> parameters = null)
            : base(scope, visitor) {

            _blockStatement = blockStatement;
            InternalType = ResolveType(blockStatement);
            Parameters = parameters;
            BuildExpressions();
        }

        protected internal AnonymousType(NRefactory.AnonymousTypeCreateExpression anonymousTypeCreateExpression, IScope scope, INRefcatoryExpressionVisitor visitor)
            : base(scope, visitor) {
            var typeInformation = anonymousTypeCreateExpression.Annotation<TypeInformation>();

            _anonymousTypeCreateExpression = anonymousTypeCreateExpression;
            _initializers = _anonymousTypeCreateExpression.Initializers.Select(i => i.AcceptVisitor(Visitor, ParentScope));
            InternalType = typeInformation.InferredType.GetActualType();
        }

        protected internal Base(NRefactory.BaseReferenceExpression baseReferenceExpression, IScope scope, INRefcatoryExpressionVisitor visitor)
            : base(scope, visitor) {
            var memberReference = baseReferenceExpression.Parent.Annotation<Mono.Cecil.MemberReference>();

            _baseReferenceExpression = baseReferenceExpression;
            Context = RootScope.Context.Expression;
            InternalType = memberReference != null ? memberReference.DeclaringType.GetActualType() : Context.Type;
        }

        public MethodBlock(NRefactory.BlockStatement blockStatement, IScope scope, INRefcatoryExpressionVisitor visitor, IEnumerable<ParameterExpression> parameters = null)
            : base(blockStatement, parameters: parameters, scope: scope, visitor: visitor) {
            var registry = RootScope.BranchingRegistry;

            if (registry.HasReturnLabel) {
                AddReturnLabelExpression();
            }
        }

        internal IEnumerable<Parameter> GetOutParameters(NRefactory.ConstructorDeclaration ctor) {
            var mapped = _mappedInvocations.FirstOrDefault(m => m.CanMapTo(ctor));

            if (mapped != null) {
                return mapped.OutParameters;
            }

            return null;
        }

        private Expression ReduceEvent(NRefactory.AssignmentExpression assignmentExpression) {
            ExpressionType expressionType;

            if (!Enum.TryParse<ExpressionType>(assignmentExpression.Operator.ToString(), out expressionType)) {
                throw new InvalidOperationException("Event registration must have an add/subtract operator");
            }

            return AstExpression.Event(Expression, Member as EventInfo, expressionType, ParentScope, Visitor);
        }

        private static NRefactory.ConstructorDeclaration ResolveConstructor(NRefactory.ConstructorDeclaration constructorDeclaration, Type baseType, ILGenerator iLGenerator, List<Cil.Instruction> instructions) {
            ConstructorEmitterVisitor constructorEmitter = null;

            constructorDeclaration = FiltertConstructorStatements(constructorDeclaration, baseType);
            constructorEmitter = new ConstructorEmitterVisitor(constructorDeclaration, new InstructionsIndexer(instructions));
            constructorDeclaration.AcceptVisitor(constructorEmitter, iLGenerator);

            return constructorDeclaration;
        }