public override void LeaveConstructor(Constructor node)
 {
     if (!node.IsVisibilitySet)
     {
         node.Modifiers |= TypeMemberModifiers.Public;
     }
 }

        // create a constructor that delegate to the base class
        private void AddConstructor(ClassDefinition macro)
        {
            var ctor = new Constructor(macro.LexicalInfo);

            ctor.Parameters.Add(
                new ParameterDeclaration("viewEngine",
                                         new SimpleTypeReference("MvcContrib.BrailViewEngine.BooViewEngine"))); // TODO: Update Reference

            //			ctor.Parameters.Add(
            //				new ParameterDeclaration("output",
            //				                         new SimpleTypeReference("System.IO.TextWriter")));
            //			ctor.Parameters.Add(
            //				new ParameterDeclaration("context",
            //				                         new SimpleTypeReference("Castle.MonoRail.Framework.IEngineContext")));
            //
            //			ctor.Parameters.Add(
            //				new ParameterDeclaration("__controller",
            //				                         new SimpleTypeReference("Castle.MonoRail.Framework.IController")));
            //
            //			ctor.Parameters.Add(
            //				new ParameterDeclaration("__controllerContext",
            //										 new SimpleTypeReference("Castle.MonoRail.Framework.IControllerContext")));

            var mie = new MethodInvocationExpression(new SuperLiteralExpression());
            mie.Arguments.Add(AstUtil.CreateReferenceExpression("viewEngine"));
            //			mie.Arguments.Add(AstUtil.CreateReferenceExpression("output"));
            //			mie.Arguments.Add(AstUtil.CreateReferenceExpression("context"));
            //			mie.Arguments.Add(AstUtil.CreateReferenceExpression("__controller"));
            //			mie.Arguments.Add(AstUtil.CreateReferenceExpression("__controllerContext"));

            ctor.Body.Add(mie);

            macro.Members.Add(ctor);
        }

 public static Constructor CreateConstructor(Node lexicalInfoProvider, TypeMemberModifiers modifiers)
 {
     Constructor constructor = new Constructor(lexicalInfoProvider.LexicalInfo);
     constructor.Modifiers = modifiers;
     constructor.IsSynthetic = true;
     return constructor;
 }

 public override void LeaveConstructor(Constructor node)
 {
     MakeStaticIfNeeded(node);
     CantBeMarkedTransient(node);
     CantBeMarkedPartial(node);
     CantBeMarkedFinal(node);
     CannotReturnValue(node);
     ConstructorCannotBePolymorphic(node);
 }

        public override void LeaveConstructor(Constructor node)
        {
            if (node.IsVisibilitySet) return;

            if (!node.IsStatic)
                node.Modifiers |= Context.Parameters.DefaultMethodVisibility;
            else
                node.Modifiers |= TypeMemberModifiers.Private;
        }

		private void GenerateConstructors(TypeDefinition definition)
		{
			ConstructorInfo[] ctors =
				baseClass.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
			foreach (ConstructorInfo ctor in ctors)
			{
				if (ctor.IsPrivate)
					continue;
				Constructor constructor = new Constructor(definition.LexicalInfo);
				definition.Members.Add(constructor);
				MethodInvocationExpression super = new MethodInvocationExpression(new SuperLiteralExpression());
				constructor.Body.Add(super);
				foreach (ParameterInfo info in ctor.GetParameters())
				{
					SimpleTypeReference typeReference =
						new SimpleTypeReference(TypeUtilities.GetFullName(info.ParameterType));
					constructor.Parameters.Add(new ParameterDeclaration(info.Name,
																		typeReference)
						);
					super.Arguments.Add(new ReferenceExpression(info.Name));
				}
			}
		}

        public override bool EnterConstructor(Constructor node)
        {
            base.EnterConstructor(node);

            return EnterMethod(node);
        }

        public override void LeaveConstructor(Constructor node)
        {
            base.LeaveConstructor(node);

            LeaveMethod(node);
        }

 public override void OnConstructor(Constructor node)
 {
     Visit(node.Parameters);
     _emitter.EmitConstructorAttributes(node);
 }

 public override void OnConstructor(Constructor node)
 {
     _parameters.Add(node);
     base.OnConstructor(node);
 }

		public object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data)
		{
			B.Constructor m = new B.Constructor(GetLexicalInfo(constructorDeclaration));
			m.Modifiers = ConvertModifier(constructorDeclaration, B.TypeMemberModifiers.Private);
			ConvertAttributes(constructorDeclaration.Attributes, m.Attributes);
			if (currentType != null) currentType.Members.Add(m);
			ConvertParameters(constructorDeclaration.Parameters, m.Parameters);
			m.EndSourceLocation = GetEndLocation((INode)constructorDeclaration.Body ?? constructorDeclaration);
			m.Body = ConvertMethodBlock(constructorDeclaration.Body);
			ConstructorInitializer ci = constructorDeclaration.ConstructorInitializer;
			if (ci != null && !ci.IsNull) {
				B.Expression initializerBase;
				if (ci.ConstructorInitializerType == ConstructorInitializerType.Base)
					initializerBase = new B.SuperLiteralExpression();
				else
					initializerBase = new B.SelfLiteralExpression();
				B.MethodInvocationExpression initializer = new B.MethodInvocationExpression(initializerBase);
				ConvertExpressions(ci.Arguments, initializer.Arguments);
				m.Body.Insert(0, new B.ExpressionStatement(initializer));
			}
			return m;
		}

 private IMethod EntityFor(Constructor node)
 {
     return (IMethod)EntityFor((TypeMember)node);
 }

        public BooMethodBuilder AddConstructor()
        {
            Constructor constructor = new Constructor();
            constructor.IsSynthetic = true;
            constructor.Modifiers = TypeMemberModifiers.Public;
            constructor.Entity = new InternalConstructor(_codeBuilder.TypeSystemServices, constructor);
            _cd.Members.Add(constructor);

            return new BooMethodBuilder(_codeBuilder, constructor);
        }

 public override void OnConstructor(Constructor node)
 {
     if (null == node.Entity)
     {
         node.Entity = new InternalConstructor(TypeSystemServices, node);
     }
     _parameters.Add(node);
 }

 public override void OnConstructor(Constructor node)
 {
     OnMethod(node);
 }

 public static CompilerError InstanceMethodInvocationBeforeInitialization(Constructor ctor, MemberReferenceExpression mre)
 {
     return Instantiate("BCE0158", mre, mre.Name, SelfKeyword);
 }

		void EmitConstructorAttributes(Constructor node, TypeCreator knownTypes)
		{
			ConstructorBuilder builder = (ConstructorBuilder)GetBuilder(node);
			EmitAttributes(node, builder.SetCustomAttribute, knownTypes);
		}

//.........这里部分代码省略.........
											throw new NoViableAltException(LT(1), getFilename());
										}
										 }
									}
								}
								if (0==inputState.guessing)
								{
									
														IToken token = id ?? spliceBegin;
														if (emi != null) {
															m = new Method(emi.LexicalInfo);
														} else {
															m = new Method(ToLexicalInfo(token));
														}
														m.Name = token.getText();
														m.ExplicitInfo  = emi;
														
														if (nameSplice != null) {
															typeMember = new SpliceTypeMember(m, nameSplice);
														} else {
															typeMember = m;
														}
													
								}
							}
							break;
						}
						case CONSTRUCTOR:
						{
							c = LT(1);
							match(CONSTRUCTOR);
							if (0==inputState.guessing)
							{
								typeMember = m = new Constructor(ToLexicalInfo(c));
							}
							break;
						}
						case DESTRUCTOR:
						{
							d = LT(1);
							match(DESTRUCTOR);
							if (0==inputState.guessing)
							{
								typeMember = m = new Destructor(ToLexicalInfo(d));
							}
							break;
						}
						default:
						{
							throw new NoViableAltException(LT(1), getFilename());
						}
						 }
					}
					break;
				}
				case CONSTRUCTOR:
				{
					cc = LT(1);
					match(CONSTRUCTOR);
					if (0==inputState.guessing)
					{
						typeMember = m = new Constructor(ToLexicalInfo(cc));
					}
					break;
				}
				case DESTRUCTOR:

        //ECMA-335 Partition III Section 1.8.1.4
        //cannot call an instance method before super/self.
        void CheckInstanceMethodInvocationsWithinConstructor(Constructor ctor)
        {
            if (ctor.Body.IsEmpty)
                return;

            foreach (Statement st in ctor.Body.Statements)
            {
                ExpressionStatement est = st as ExpressionStatement;
                if (null == est) continue;

                MethodInvocationExpression mie = est.Expression as MethodInvocationExpression;
                if (null == mie) continue;

                if (mie.Target is SelfLiteralExpression
                    || mie.Target is SuperLiteralExpression)
                    break;//okay we're done checking

                if (mie.Target is MemberReferenceExpression)
                {
                    MemberReferenceExpression mre = (MemberReferenceExpression) mie.Target;
                    if (mre.Target is SelfLiteralExpression
                        || mre.Target is SuperLiteralExpression)
                    {
                        Error(CompilerErrorFactory.InstanceMethodInvocationBeforeInitialization(ctor, mre));
                    }
                }
            }
        }

 void ConstructorCannotBePolymorphic(Constructor node)
 {
     if (node.IsAbstract || node.IsOverride || node.IsVirtual)
     {
         Error(CompilerErrorFactory.ConstructorCantBePolymorphic(node, EntityFor(node)));
     }
 }