public override void OnInterfaceDefinition(InterfaceDefinition node)
 {
     if (null != node.Entity)
     {
         return;
     }
     node.Entity = new InternalInterface(TypeSystemServices, node);
 }

		override public void LeaveInterfaceDefinition(InterfaceDefinition node)
		{
			CantBeMarkedAbstract(node);
			CantBeMarkedTransient(node);
			CantBeMarkedPartialIfNested(node);
			CantBeMarkedFinal(node);
			CantBeMarkedStatic(node);
		}

		override public void OnInterfaceDefinition(InterfaceDefinition node)
		{
			// ignore
		}

 public override void LeaveInterfaceDefinition(InterfaceDefinition node)
 {
     CheckName(node,node.Name);
 }

 public override void OnInterfaceDefinition(InterfaceDefinition node)
 {
     ResolveBaseTypes(new Boo.Lang.List(), node);
     CheckInterfaceBaseTypes(node);
 }

		public override void OnInterfaceDefinition(InterfaceDefinition node)
		{
			OnTypeDefinition(node);
		}

        public override void LeaveInterfaceDefinition(InterfaceDefinition node)
        {
            base.LeaveInterfaceDefinition(node);

            Pop(node.EndSourceLocation.Line);
        }

 public override void LeaveInterfaceDefinition(InterfaceDefinition node)
 {
     _emitter.EmitTypeAttributes(node);
 }

 public override void LeaveInterfaceDefinition(InterfaceDefinition node)
 {
     MarkVisited(node);
 }

 public override void OnInterfaceDefinition(InterfaceDefinition node)
 {
 }

		override public void OnInterfaceDefinition(InterfaceDefinition node)
		{
			EnsureEntityFor(node);
		}	

 public override void OnInterfaceDefinition(InterfaceDefinition node)
 {
     AddMember(node);
 }

 public override void OnInterfaceDefinition(InterfaceDefinition node)
 {
     OnCandidatePartialDefinition(node);
 }

 public override bool EnterInterfaceDefinition(InterfaceDefinition node)
 {
     return false;
 }

 public override void LeaveInterfaceDefinition(InterfaceDefinition node)
 {
     this.SetPublicByDefault(node);
 }

 public override void OnInterfaceDefinition(InterfaceDefinition node)
 {
     base.OnInterfaceDefinition(node);
     _emitter.EmitTypeAttributes(node);
 }

 public override void LeaveInterfaceDefinition(InterfaceDefinition node)
 {
     LeaveTypeDefinition(node);
 }

 public override void LeaveInterfaceDefinition(InterfaceDefinition node)
 {
     CheckMemberName(node);
     CantBeMarkedAbstract(node);
     CantBeMarkedTransient(node);
     CantBeMarkedPartial(node);
     CantBeMarkedFinal(node);
     CantBeMarkedStatic(node);
 }

        //throws RecognitionException, TokenStreamException
        protected void interface_definition(
            TypeMemberCollection container
            )
        {
            IToken  id = null;

                InterfaceDefinition itf = null;
                TypeMemberCollection members = null;
                GenericParameterDeclarationCollection genericParameters = null;

            try {      // for error handling
            match(INTERFACE);
            id = LT(1);
            match(ID);
            if (0==inputState.guessing)
            {

                        itf = new InterfaceDefinition(SourceLocationFactory.ToLexicalInfo(id));
                        itf.Name = id.getText();
                        itf.Modifiers = _modifiers;
                        AddAttributes(itf.Attributes);
                        container.Add(itf);
                        members = itf.Members;
                        genericParameters = itf.GenericParameters;

            }
            {
                switch ( LA(1) )
                {
                case LBRACK:
                {
                    match(LBRACK);
                    {
                        switch ( LA(1) )
                        {
                        case OF:
                        {
                            match(OF);
                            break;
                        }
                        case ID:
                        {
                            break;
                        }
                        default:
                        {
                            throw new NoViableAltException(LT(1), getFilename());
                        }
                         }
                    }
                    generic_parameter_declaration_list(genericParameters);
                    match(RBRACK);
                    break;
                }
                case LPAREN:
                case COLON:
                {
                    break;
                }
                default:
                {
                    throw new NoViableAltException(LT(1), getFilename());
                }
                 }
            }
            {
                switch ( LA(1) )
                {
                case LPAREN:
                {
                    base_types(itf.BaseTypes);
                    break;
                }
                case COLON:
                {
                    break;
                }
                default:
                {
                    throw new NoViableAltException(LT(1), getFilename());
                }
                 }
            }
            begin_with_doc(itf);
            {    // ( ... )*
                for (;;)
                {
                    if ((tokenSet_33_.member(LA(1))))
                    {
                        attributes();
                        {
                            switch ( LA(1) )
                            {
                            case DEF:
                            {
                                interface_method(members);
                                break;
                            }
                            case EVENT:
//.........这里部分代码省略.........

 public override void OnInterfaceDefinition(InterfaceDefinition node)
 {
     EnterNamespace((INamespace)GetEntity(node));
     VisitTypeDefinitionBody(node);
     LeaveNamespace();
 }