public override void VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration)
        {
            AddMethod(true, constructorDeclaration, constructorDeclaration.Parameters);

            // call base to forward execution
            base.VisitConstructorDeclaration(constructorDeclaration);
        }

 public override void VisitConstructorDeclaration(ConstructorDeclaration declaration)
 {
     Tupel t = new Tupel(declaration.StartLocation.Line, declaration.EndLocation.Line);
     addToMap(declaration.Name, t);
     //_methodRanges.Add(constructorDeclaration.Name, new Tupel(constructorDeclaration.StartLocation.Line,
     //                                                         constructorDeclaration.EndLocation.Line));
 }

            public override object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data)
            {
                if(constructorDeclaration.Parameters.Count > 0)
                    UnlockWith(constructorDeclaration);

                return base.VisitConstructorDeclaration(constructorDeclaration, data);
            }

            public override object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data)
            {
                if (!constructorDeclaration.Initializer.IsNull && constructorDeclaration.Initializer.ConstructorInitializerType == ConstructorInitializerType.Base)
                    UnlockWith(constructorDeclaration);

                return base.VisitConstructorDeclaration(constructorDeclaration, data);
            }

 public override void VisitConstructorDeclaration(ConstructorDeclaration methodDeclaration)
 {
     if (methodDeclaration.HasModifier(Modifiers.Static))
     {
         base.VisitConstructorDeclaration(methodDeclaration);
     }
 }

        public IEnumerable<CodeAction> GetActions(RefactoringContext context)
        {
            var createExpression = context.GetNode<Expression>() as ObjectCreateExpression;
            if (createExpression == null)
                yield break;

            var resolveResult = context.Resolve(createExpression) as CSharpInvocationResolveResult;
            if (resolveResult == null || !resolveResult.IsError || resolveResult.Member.DeclaringTypeDefinition == null || resolveResult.Member.DeclaringTypeDefinition.IsSealed || resolveResult.Member.DeclaringTypeDefinition.Region.IsEmpty)
                yield break;

            yield return new CodeAction(context.TranslateString("Create constructor"), script => {
                var decl = new ConstructorDeclaration() {
                    Name = resolveResult.Member.DeclaringTypeDefinition.Name,
                    Modifiers = Modifiers.Public,
                    Body = new BlockStatement() {
                        new ThrowStatement(new ObjectCreateExpression(context.CreateShortType("System", "NotImplementedException")))
                    }
                };
                decl.Parameters.AddRange(CreateMethodDeclarationAction.GenerateParameters(context, createExpression.Arguments));

                script.InsertWithCursor(
                    context.TranslateString("Create constructor"),
                    resolveResult.Member.DeclaringTypeDefinition,
                    decl
                );
            }, createExpression);
        }

		public override object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data)
		{
			Push();
			object result = base.VisitConstructorDeclaration(constructorDeclaration, data);
			Pop();
			return result;
		}

 public override void VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration)
 {
     string prefix = "";
     if ((constructorDeclaration.Modifiers & Modifiers.Static) == Modifiers.Static)
         prefix = "static.";
     VisitMember(prefix + constructorDeclaration.Name, constructorDeclaration.Parameters.Select(p => p.Type.ToString()));
     base.VisitConstructorDeclaration(constructorDeclaration);
 }

 public override void VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration)
 {
     if (isSealedType)
         return;
     var body = constructorDeclaration.Body;
     if (body == null || body.IsNull)
         return;
     body.AcceptVisitor(CallFinder);
 }

        public static OverloadsCollection Create(IEmitter emitter, ConstructorDeclaration constructorDeclaration)
        {
            string key = constructorDeclaration.GetHashCode().ToString();
            if (emitter.OverloadsCache.ContainsKey(key))
            {
                return emitter.OverloadsCache[key];
            }

            return new OverloadsCollection(emitter, constructorDeclaration);
        }

			public override void VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration)
			{
				if (isSealedType)
					return;
				var body = constructorDeclaration.Body;
				if (body == null || body.IsNull)
					return;
				var callFinder = new VirtualCallFinderVisitor(context);
				body.AcceptVisitor(callFinder);
				FoundIssues.AddRange(callFinder.FoundIssues);
			}

 private OverloadsCollection(IEmitter emitter, ConstructorDeclaration constructorDeclaration)
 {
     this.Emitter = emitter;
     this.Name = constructorDeclaration.Name;
     this.JsName = this.Emitter.GetEntityName(constructorDeclaration, false, true);
     this.Inherit = false;
     this.Constructor = true;
     this.Static = constructorDeclaration.HasModifier(Modifiers.Static);
     this.Member = this.FindMember(constructorDeclaration);
     this.TypeDefinition = this.Member.DeclaringTypeDefinition;
     this.Type = this.Member.DeclaringType;
     this.InitMembers();
     this.Emitter.OverloadsCache[constructorDeclaration.GetHashCode().ToString()] = this;
 }

        public override void VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration)
        {
            bool isStatic = constructorDeclaration.HasModifier(Modifiers.Static);

            this.FixMethodParameters(constructorDeclaration.Parameters, constructorDeclaration.Body);

            if (isStatic)
            {
                this.CurrentType.StaticCtor = constructorDeclaration;
            }
            else
            {
                this.CurrentType.Ctors.Add(constructorDeclaration);
            }
        }

        public override void VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration)
        {
            FixAttributesAndDocComment(constructorDeclaration);

            ForceSpacesBefore(constructorDeclaration.LParToken, policy.SpaceBeforeConstructorDeclarationParentheses);
            if (constructorDeclaration.Parameters.Any()) {
                ForceSpacesAfter(constructorDeclaration.LParToken, policy.SpaceWithinConstructorDeclarationParentheses);
                FormatArguments(constructorDeclaration);
            } else {
                ForceSpacesAfter(constructorDeclaration.LParToken, policy.SpaceBetweenEmptyConstructorDeclarationParentheses);
                ForceSpacesBefore(constructorDeclaration.RParToken, policy.SpaceBetweenEmptyConstructorDeclarationParentheses);
            }

            if (!constructorDeclaration.Body.IsNull) {
                FixOpenBrace(policy.ConstructorBraceStyle, constructorDeclaration.Body.LBraceToken);
                VisitBlockWithoutFixingBraces(constructorDeclaration.Body, policy.IndentMethodBody);
                FixClosingBrace(policy.ConstructorBraceStyle, constructorDeclaration.Body.RBraceToken);
            }
        }

			public override void Visit(Constructor c)
			{
				var newConstructor = new ConstructorDeclaration();
				AddAttributeSection(newConstructor, c);
				var location = LocationsBag.GetMemberLocation(c);
				AddModifiers(newConstructor, location);
				newConstructor.AddChild(Identifier.Create(c.MemberName.Name, Convert(c.MemberName.Location)), Roles.Identifier);
				if (location != null && location.Count > 0)
					newConstructor.AddChild(new CSharpTokenNode(Convert(location [0]), Roles.LPar), Roles.LPar);
				
				AddParameter(newConstructor, c.ParameterInfo);
				if (location != null && location.Count > 1)
					newConstructor.AddChild(new CSharpTokenNode(Convert(location [1]), Roles.RPar), Roles.RPar);
				
				if (c.Initializer != null) {
					var initializer = new ConstructorInitializer();
					initializer.ConstructorInitializerType = c.Initializer is ConstructorBaseInitializer ? ConstructorInitializerType.Base : ConstructorInitializerType.This;
					var initializerLocation = LocationsBag.GetLocations(c.Initializer);
					
					if (initializerLocation != null)
						newConstructor.AddChild(new CSharpTokenNode(Convert(initializerLocation [0]), Roles.Colon), Roles.Colon);
					
					if (initializerLocation != null && initializerLocation.Count > 1) {
						// this and base has the same length
						var r = initializer.ConstructorInitializerType == ConstructorInitializerType.This ? ConstructorInitializer.ThisKeywordRole : ConstructorInitializer.BaseKeywordRole;
						initializer.AddChild(new CSharpTokenNode(Convert(c.Initializer.Location), r), r);
						initializer.AddChild(new CSharpTokenNode(Convert(initializerLocation [1]), Roles.LPar), Roles.LPar);
						AddArguments(initializer, c.Initializer.Arguments);
						initializer.AddChild(new CSharpTokenNode(Convert(initializerLocation [2]), Roles.RPar), Roles.RPar);
						newConstructor.AddChild(initializer, ConstructorDeclaration.InitializerRole);
					}
				}
				
				if (c.Block != null)
					newConstructor.AddChild((BlockStatement)c.Block.Accept(this), Roles.Body);
				typeStack.Peek().AddChild(newConstructor, Roles.TypeMemberRole);
			}

		public override void VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration)
		{
			FormatAttributedNode(constructorDeclaration);
			
			ForceSpacesBefore(constructorDeclaration.LParToken, policy.SpaceBeforeConstructorDeclarationParentheses);
			if (constructorDeclaration.Parameters.Any()) {
				ForceSpacesAfter(constructorDeclaration.LParToken, policy.SpaceWithinConstructorDeclarationParentheses);
				ForceSpacesBefore(constructorDeclaration.RParToken, policy.SpaceWithinConstructorDeclarationParentheses);
			} else {
				ForceSpacesAfter(constructorDeclaration.LParToken, policy.SpaceBetweenEmptyConstructorDeclarationParentheses);
				ForceSpacesBefore(constructorDeclaration.RParToken, policy.SpaceBetweenEmptyConstructorDeclarationParentheses);
			}
			FormatCommas(constructorDeclaration, policy.SpaceBeforeConstructorDeclarationParameterComma, policy.SpaceAfterConstructorDeclarationParameterComma);
			
			if (!constructorDeclaration.Body.IsNull) {
				EnforceBraceStyle(policy.ConstructorBraceStyle, constructorDeclaration.Body.LBraceToken, constructorDeclaration.Body.RBraceToken);
				VisitBlockWithoutFixingBraces(constructorDeclaration.Body, policy.IndentMethodBody);
			}
			if (IsMember(constructorDeclaration.NextSibling)) {
				EnsureBlankLinesAfter(constructorDeclaration, policy.BlankLinesBetweenMembers);
			}
		}

			public override void VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration)
			{
				currentMethodName = constructorDeclaration.Name;
				base.VisitConstructorDeclaration(constructorDeclaration);
			}

 ConstructorDeclaration ConvertConstructor(IMethod ctor)
 {
     ConstructorDeclaration decl = new ConstructorDeclaration();
     decl.Modifiers = GetMemberModifiers(ctor);
     if (ctor.DeclaringTypeDefinition != null)
         decl.Name = ctor.DeclaringTypeDefinition.Name;
     foreach (IParameter p in ctor.Parameters) {
         decl.Parameters.Add(ConvertParameter(p));
     }
     decl.Body = GenerateBodyBlock();
     return decl;
 }

 private void MaybeCompileAndAddConstructorToType(JsClass jsClass, ConstructorDeclaration node, IMethod constructor, ConstructorScriptSemantics options)
 {
     if (options.GenerateCode) {
         var mc = CreateMethodCompiler();
         var compiled = mc.CompileConstructor(node, constructor, TryGetInstanceInitStatements(jsClass), options);
         OnMethodCompiled(constructor, compiled, mc);
         AddCompiledConstructorToType(jsClass, constructor, options, compiled);
     }
 }

        private void HandleConstructorDeclaration(ConstructorDeclaration constructorDeclaration)
        {
            var resolveResult = _resolver.Resolve(constructorDeclaration);
            if (!(resolveResult is MemberResolveResult)) {
                _errorReporter.Region = constructorDeclaration.GetRegion();
                _errorReporter.InternalError("Method declaration " + constructorDeclaration.Name + " does not resolve to a member.");
                return;
            }
            var method = ((MemberResolveResult)resolveResult).Member as IMethod;
            if (method == null) {
                _errorReporter.Region = constructorDeclaration.GetRegion();
                _errorReporter.InternalError("Method declaration " + constructorDeclaration.Name + " does not resolve to a method (resolves to " + resolveResult.ToString() + ")");
                return;
            }

            var jsClass = GetJsClass(method.DeclaringTypeDefinition);
            if (jsClass == null)
                return;

            if (method.IsStatic) {
                jsClass.StaticInitStatements.AddRange(CompileMethod(constructorDeclaration, constructorDeclaration.Body, method, MethodScriptSemantics.NormalMethod("X")).Body.Statements);
            }
            else {
                MaybeCompileAndAddConstructorToType(jsClass, constructorDeclaration, method, _metadataImporter.GetConstructorSemantics(method));
            }
        }