public static CompilationUnit add_Ctor_(this CompilationUnit compilationUnit, string @namespace, string typeName, ConstructorDeclaration constructorDeclaration)
 {
     var myNamespace = compilationUnit.add_Namespace(@namespace);
     var type = myNamespace.add_Type(typeName);
     type.add_Ctor(constructorDeclaration);
     return compilationUnit;
 }

        public override object TrackedVisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data)
        {
            const string initializerBlock = "InitializerBlock";
            if (constructorDeclaration.Name == initializerBlock)
            {
                TypeDeclaration type = (TypeDeclaration) constructorDeclaration.Parent;
                string initName = "Init" + type.Name;
                MethodDeclaration initMethod = GetInitMethod(type);
                initMethod.Body.Children.AddRange(constructorDeclaration.Body.Children);
                Expression initInvocation = new InvocationExpression(new IdentifierExpression(initName));
                ExpressionStatement initInvocationStatement = new ExpressionStatement(initInvocation);

                IList constructors = AstUtil.GetChildrenWithType(type, typeof(ConstructorDeclaration));
                if (constructors.Count > 1)
                {
                    foreach (ConstructorDeclaration constructor in constructors)
                    {
                        if (constructor.Name != initializerBlock && !HasInitInvocation(constructor))
                            constructor.Body.Children.Insert(0, initInvocationStatement);
                    }
                }
                else if (((ConstructorDeclaration) constructors[0]).Name == initializerBlock)
                {
                    ConstructorDeclaration constructor = new ConstructorDeclaration(type.Name, Modifiers.Public, null, null);
                    constructor.Body = new BlockStatement();
                    constructor.Body.AddChild(initInvocationStatement);
                    type.AddChild(constructor);
                }
                RemoveCurrentNode();
            }
            return base.TrackedVisitConstructorDeclaration(constructorDeclaration, data);
        }

 public override object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data)
 {
     if (this.CheckNode(constructorDeclaration)) {
         return null;
     }
     return base.VisitConstructorDeclaration(constructorDeclaration, data);
 }

 public override object TrackedVisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data)
 {
     if (ShouldStubMember(constructorDeclaration.Name))
         return base.TrackedVisitConstructorDeclaration(constructorDeclaration, data);
     else
         return null;
 }

            public override object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data)
            {
                if (constructorDeclaration.ConstructorInitializer.ConstructorInitializerType == ConstructorInitializerType.Base)
                    UnlockWith(constructorDeclaration);

                return base.VisitConstructorDeclaration(constructorDeclaration, data);
            }

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

 public override object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data)
 {
     collectingUsedLabels = true;
     base.VisitConstructorDeclaration(constructorDeclaration, data);
     collectingUsedLabels = false;
     base.VisitConstructorDeclaration(constructorDeclaration, data);
     return null;
 }

 public override object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data)
 {
     if (currentDependencyRelation != null)
     {
         currentDependencyRelation.RecordConstructor(constructorDeclaration);
     }
     return base.VisitConstructorDeclaration(constructorDeclaration, data);
 }

		private void TransformQueryToClass()
		{
			
			CSharpSafeName = "Index_"+ Regex.Replace(Name, @"[^\w\d]", "_");
			var type = new TypeDeclaration(Modifiers.Public, new List<AttributeSection>())
			{
				BaseTypes =
					{
						new TypeReference("AbstractViewGenerator")
					},
				Name = CSharpSafeName,
				Type = ClassType.Class
			};

			var ctor = new ConstructorDeclaration(CSharpSafeName,
			                                      Modifiers.Public,
			                                      new List<ParameterDeclarationExpression>(), null);
			type.Children.Add(ctor);
			ctor.Body = new BlockStatement();
		
			// this.ViewText = "96E65595-1C9E-4BFB-A0E5-80BF2D6FC185"; // Will be replaced later
			ctor.Body.AddChild(new ExpressionStatement(
			                   	new AssignmentExpression(
			                   		new MemberReferenceExpression(new ThisReferenceExpression(), "ViewText"),
			                   		AssignmentOperatorType.Assign,
			                   		new PrimitiveExpression(mapReduceTextToken, mapReduceTextToken))));

			foreach (var map in indexDefinition.Maps)
			{
				HandleMapFunction(ctor, map);
			}

			HandleTransformResults(ctor);

			HandleReduceDefintion(ctor);

		    AddAdditionalInformation(ctor);

			CompiledQueryText = QueryParsingUtils.GenerateText(type, extensions);
			var sb = new StringBuilder("@\"");
			foreach (var map in indexDefinition.Maps)
			{
				sb.AppendLine(map.Replace("\"", "\"\""));
			}
			if (indexDefinition.Reduce != null)
			{
				sb.AppendLine(indexDefinition.Reduce.Replace("\"", "\"\"")).AppendLine();
			}

			if (indexDefinition.TransformResults != null)
			{
				sb.AppendLine(indexDefinition.TransformResults.Replace("\"", "\"\"")).AppendLine();
			}

			sb.Append("\"");
			CompiledQueryText = CompiledQueryText.Replace("\"" + mapReduceTextToken + "\"",
			                                              sb.ToString());
		}

		public override object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data)
		{
			if ((constructorDeclaration.Body.StartLocation < new Location(startColumn + 1, startLine + 1)) &&
			    (constructorDeclaration.Body.EndLocation > new Location(endColumn + 1, endLine + 1))) {
				this.member = constructorDeclaration;
			}
			
			return base.VisitConstructorDeclaration(constructorDeclaration, data);
		}

		public override object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data)
		{
			if ((constructorDeclaration.Body.StartLocation < start) &&
			    (constructorDeclaration.Body.EndLocation > end)) {
				this.member = constructorDeclaration;
			}
			
			return base.VisitConstructorDeclaration(constructorDeclaration, data);
		}

 private ConstructorDeclaration GetConstructor(ExpressionStatement expression, TypeDeclaration typeDeclaration)
 {
     ConstructorDeclaration constructorDeclaration;
     constructorDeclaration = new ConstructorDeclaration(typeDeclaration.Name, Modifiers.Public, null, null);
     constructorDeclaration.Body = new BlockStatement();
     constructorDeclaration.Body.Children.Add(expression);
     typeDeclaration.Children.Add(constructorDeclaration);
     return constructorDeclaration;
 }

 public override object TrackedVisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data)
 {
     TypeDeclaration typeDeclaration = (TypeDeclaration) constructorDeclaration.Parent;
     if (IsDerivedFrom(typeDeclaration, "junit.framework.TestCase"))
     {
         if (constructorDeclaration.Parameters.Count > 0)
             RemoveCurrentNode();
     }
     return null;
 }

		public override object VisitTypeDeclaration(TypeDeclaration typeDeclaration, object data)
		{
			base.VisitTypeDeclaration(typeDeclaration, data); // visit methods
			typeDeclaration.Attributes.Clear();
			typeDeclaration.BaseTypes.Clear();
			
			// add constructor accepting the wrapped object and the field holding the object
			FieldDeclaration fd = new FieldDeclaration(null, // no attributes
			                                           new TypeReference(typeDeclaration.Name),
			                                           Modifiers.Private);
			fd.Fields.Add(new VariableDeclaration("wrappedObject"));
			typeDeclaration.AddChild(fd);
			
			typeDeclaration.Name += "Wrapper";
			if (typeDeclaration.Type == ClassType.Interface) {
				typeDeclaration.Type = ClassType.Class;
				typeDeclaration.Name = typeDeclaration.Name.Substring(1);
			}
			ConstructorDeclaration cd = new ConstructorDeclaration(typeDeclaration.Name,
			                                                       Modifiers.Public,
			                                                       new List<ParameterDeclarationExpression>(),
			                                                       null);
			cd.Parameters.Add(new ParameterDeclarationExpression(fd.TypeReference,
			                                                     "wrappedObject"));
			// this.wrappedObject = wrappedObject;
			Expression fieldReference = new MemberReferenceExpression(new ThisReferenceExpression(),
			                                                         "wrappedObject");
			Expression assignment = new AssignmentExpression(fieldReference,
			                                                 AssignmentOperatorType.Assign,
			                                                 new IdentifierExpression("wrappedObject"));
			cd.Body = new BlockStatement();
			cd.Body.AddChild(new ExpressionStatement(assignment));
			typeDeclaration.AddChild(cd);
			
			for (int i = 0; i < typeDeclaration.Children.Count; i++) {
				object child = typeDeclaration.Children[i];
				if (child is MethodDeclaration) {
					MethodDeclaration method = (MethodDeclaration)child;
					if (method.Parameters.Count == 0 &&
					    (method.Name.StartsWith("Is") || method.Name.StartsWith("Get")))
					{
						// replace the method with a property
						PropertyDeclaration prop = new PropertyDeclaration(method.Modifier,
						                                                   method.Attributes,
						                                                   method.Name,
						                                                   null);
						prop.TypeReference = method.TypeReference;
						prop.GetRegion = new PropertyGetRegion(method.Body, null);
						typeDeclaration.Children[i] = prop;
					}
				}
			}
			
			return null;
		}

        public static ConstructorDeclaration add_Ctor(this TypeDeclaration typeDeclaration)
        {
            var name = "";
            var modifier = Modifiers.Public;
            var _parameters = new List<ParameterDeclarationExpression>();
            var _attributes = new List<AttributeSection>();

            var ctorDeclaration = new ConstructorDeclaration(name, modifier, _parameters, _attributes);
            ctorDeclaration.Body = new BlockStatement();
            typeDeclaration.add_Ctor(ctorDeclaration);
            return ctorDeclaration;
        }

 private bool HasInitInvocation(ConstructorDeclaration constructor)
 {
     IList stms = AstUtil.GetChildrenWithType(constructor.Body, typeof(ExpressionStatement));
     foreach (ExpressionStatement statement in stms)
     {
         Expression expression = statement.Expression;
         if (expression is InvocationExpression && ((InvocationExpression) expression).TargetObject is IdentifierExpression)
         {
             IdentifierExpression identifierExpression = (IdentifierExpression) ((InvocationExpression) expression).TargetObject;
             return identifierExpression.Identifier == "Init" + constructor.Name;
         }
     }
     return false;
 }

		public override void GenerateCode(List<AbstractNode> nodes, IList items)
		{
			ConstructorDeclaration ctor = new ConstructorDeclaration(currentClass.Name, Modifiers.Public, null, null);
			ctor.Body = new BlockStatement();
			foreach (FieldWrapper w in items) {
				string parameterName = codeGen.GetParameterName(w.Field.Name);
				ctor.Parameters.Add(new ParameterDeclarationExpression(ConvertType(w.Field.ReturnType),
				                                                       parameterName));
				Expression left  = new MemberReferenceExpression(new ThisReferenceExpression(), w.Field.Name);
				Expression right = new IdentifierExpression(parameterName);
				Expression expr  = new AssignmentExpression(left, AssignmentOperatorType.Assign, right);
				ctor.Body.AddChild(new ExpressionStatement(expr));
			}
			nodes.Add(ctor);
		}

		/// <summary>
		/// Gets the constructor information from a type declaration. Returns null if there is no 
		/// constructor defined or if there are no fields defined.
		/// </summary>
		public static RubyConstructorInfo GetConstructorInfo(TypeDeclaration type)
		{
			List<FieldDeclaration> fields = new List<FieldDeclaration>();
			ConstructorDeclaration constructor = null;
			foreach (INode node in type.Children) {
				ConstructorDeclaration currentConstructor = node as ConstructorDeclaration;
				FieldDeclaration field = node as FieldDeclaration;
				if (currentConstructor != null) {
					constructor = currentConstructor;
				} else if (field != null) {
					fields.Add(field);
				}
			}
			
			if ((fields.Count > 0) || (constructor != null)) {
				return new RubyConstructorInfo(constructor, fields);
			}
			return null;
		}

 private static bool IsEmptyConstructor(ConstructorDeclaration constructor)
 {
     bool flag;
     flag = (constructor == null ? true : constructor.Body.Children.Count == 0);
     return flag;
 }

		public virtual object TrackedVisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data) {
			return base.VisitConstructorDeclaration(constructorDeclaration, data);
		}