File di origine e spazi dei nomi

Un programma Visual Basic è costituito da uno o più file di origine. Quando un programma viene compilato, tutti i file di origine vengono elaborati insieme; pertanto, i file di origine possono dipendere l'uno dall'altro, possibilmente in modo circolare, senza alcun requisito di dichiarazione di inoltro. L'ordine testuale delle dichiarazioni nel testo del programma è in genere privo di significato.

Un file di origine è costituito da un set facoltativo di istruzioni di opzione, istruzioni import e attributi, seguiti da un corpo dello spazio dei nomi. Gli attributi, che devono avere il Assembly modificatore o Module , si applicano all'assembly o al modulo .NET prodotto dalla compilazione. Il corpo del file di origine funge da dichiarazione dello spazio dei nomi implicito per lo spazio dei nomi globale, ovvero tutte le dichiarazioni al livello superiore di un file di origine vengono inserite nello spazio dei nomi globale. Per esempio:

FileA.vb:

Class A
End Class

FileB.vb:

Class B
End Class

I due file di origine contribuiscono allo spazio dei nomi globale, in questo caso dichiarando due classi con i nomi A completi e B. Poiché i due file di origine contribuiscono allo stesso spazio di dichiarazione, sarebbe stato un errore se ognuna conteneva una dichiarazione di un membro con lo stesso nome.

Nota. L'ambiente di compilazione può eseguire l'override delle dichiarazioni dello spazio dei nomi in cui viene inserito in modo implicito un file di origine.

Se non specificato, le istruzioni all'interno di un programma Visual Basic possono essere terminate da un terminatore di riga o da due punti.

Start
    : OptionStatement* ImportsStatement* AttributesStatement* NamespaceMemberDeclaration*
    ;

StatementTerminator
    : LineTerminator
    | ':'
    ;

AttributesStatement
    : Attributes StatementTerminator
    ;

Avvio e terminazione del programma

L'avvio del programma si verifica quando l'ambiente di esecuzione esegue un metodo designato, denominato punto di ingresso del programma. Questo metodo del punto di ingresso, che deve sempre essere denominato , deve essere condiviso Main, non può essere contenuto in un tipo generico, non può avere il modificatore asincrono e deve avere una delle firme seguenti:

Sub Main()
Sub Main(args() As String)
Function Main() As Integer
Function Main(args() As String) As Integer

L'accessibilità del metodo del punto di ingresso è irrilevante. Se un programma contiene più di un punto di ingresso appropriato, l'ambiente di compilazione deve designarne uno come punto di ingresso. In caso contrario, si verifica un errore in fase di compilazione. L'ambiente di compilazione può anche creare un metodo del punto di ingresso, se non esiste.

All'avvio di un programma, se il punto di ingresso ha un parametro, l'argomento fornito dall'ambiente di esecuzione contiene gli argomenti della riga di comando per il programma rappresentato come stringhe. Se il punto di ingresso ha un tipo restituito di Integer, il valore restituito dalla funzione viene restituito all'ambiente di esecuzione come risultato del programma.

In tutti gli altri aspetti, i metodi del punto di ingresso si comportano nello stesso modo degli altri metodi. Quando l'esecuzione lascia la chiamata del metodo del punto di ingresso eseguito dall'ambiente di esecuzione, il programma termina.

Opzioni di compilazione

Un file di origine può specificare le opzioni di compilazione nel codice sorgente usando istruzioni di opzione.

OptionStatement
    : OptionExplicitStatement
    | OptionStrictStatement
    | OptionCompareStatement
    | OptionInferStatement
    ;

Un'istruzione Option si applica solo al file di origine in cui viene visualizzato e solo uno di ogni tipo di istruzione può essere visualizzato in un file di Option origine. Per esempio:

Option Strict On
Option Compare Text
Option Strict Off    ' Not allowed, Option Strict is already specified.
Option Compare Text  ' Not allowed, Option Compare is already specified.

Sono disponibili quattro opzioni di compilazione: semantica del tipo strict, semantica di dichiarazione esplicita, semantica di confronto e semantica di inferenza del tipo di variabile locale. Se un file di origine non include una particolare Option istruzione, l'ambiente di compilazione determina quale particolare set di semantiche verrà usato. È disponibile anche una quinta opzione di compilazione, controlli di overflow integer, che possono essere specificati solo tramite l'ambiente di compilazione.

Istruzione Option Explicit

L'istruzione Option Explicit determina se le variabili locali possono essere dichiarate in modo implicito. Le parole chiave On o Off possono seguire l'istruzione; se non viene specificato nessuno dei due valori, il valore predefinito è On. Se non viene specificata alcuna istruzione in un file, l'ambiente di compilazione determina quale verrà usato.

OptionExplicitStatement
    : 'Option' 'Explicit' OnOff? StatementTerminator
    ;

OnOff
    : 'On' | 'Off'
    ;

Nota. Explicit e Off non sono parole riservate.

Option Explicit Off

Module Test
    Sub Main()
        x = 5 ' Valid because Option Explicit is off.
    End Sub
End Module

In questo esempio la variabile x locale viene dichiarata in modo implicito assegnandola. Il tipo di x è Object.

Istruzione Option Strict

L'istruzione Option Strict determina se le conversioni e le operazioni in Object sono regolate da semantiche di tipo strict o permissive e se i tipi vengono tipizzati in modo implicito come Object se non venga specificata alcuna As clausola. L'istruzione può essere seguita dalle parole chiave On o Off. Se non è specificato nessuno dei due elementi, il valore predefinito è On. Se non viene specificata alcuna istruzione in un file, l'ambiente di compilazione determina quale verrà usato.

OptionStrictStatement
    : 'Option' 'Strict' OnOff? StatementTerminator
    ;

Nota. Strict e Off non sono parole riservate.

Option Strict On

Module Test
    Sub Main()
        Dim x ' Error, no type specified.
        Dim o As Object
        Dim b As Byte = o ' Error, narrowing conversion.

        o.F() ' Error, late binding disallowed.
        o = o + 1 ' Error, addition is not defined on Object.
    End Sub
End Module

In semantica rigorosa, di seguito sono consentite le operazioni seguenti:

• Conversioni di tipo Narrowing senza un operatore cast esplicito.

• Associazione tardiva.

• Operazioni sul tipo Object diverso da TypeOf...Is, Ise IsNot.

• Omettere la As clausola in una dichiarazione che non dispone di un tipo dedotto.

Istruzione Option Compare

L'istruzione Option Compare determina la semantica dei confronti tra stringhe. I confronti tra stringhe vengono eseguiti usando confronti binari (in cui viene confrontato il valore Unicode binario di ogni carattere) o i confronti di testo (in cui il significato lessicale di ogni carattere viene confrontato usando le impostazioni cultura correnti). Se non viene specificata alcuna istruzione in un file, l'ambiente di compilazione controlla quale tipo di confronto verrà usato.

OptionCompareStatement
    : 'Option' 'Compare' CompareOption StatementTerminator
    ;

CompareOption
    : 'Binary' | 'Text'
    ;

Nota.Compare, Binarye Text non sono parole riservate.

Option Compare Text

Module Test
    Sub Main()
        Console.WriteLine("a" = "A")    ' Prints True.
    End Sub
End Module

In questo caso, il confronto tra stringhe viene eseguito usando un confronto di testo che ignora le differenze tra maiuscole e minuscole. Se Option Compare Binary fosse stato specificato, verrà stampato False.

Controlli di overflow integer

Le operazioni integer possono essere controllate o non controllate per verificare le condizioni di overflow in fase di esecuzione. Se vengono controllate condizioni di overflow e viene generata un'eccezione System.OverflowException per un'operazione integer. Se le condizioni di overflow non vengono controllate, gli overflow dell'operazione integer non generano un'eccezione. L'ambiente di compilazione determina se questa opzione è attivata o disattivata.

Istruzione Option Infer

L'istruzione Option Infer determina se le dichiarazioni di variabili locali senza clausola hanno As un tipo dedotto o usano Object. L'istruzione può essere seguita dalle parole chiave On o Off. Se non è specificato nessuno dei due elementi, il valore predefinito è On. Se non viene specificata alcuna istruzione in un file, l'ambiente di compilazione determina quale verrà usato.

OptionInferStatement
    : 'Option' 'Infer' OnOff? StatementTerminator
    ;

Nota. Infer e Off non sono parole riservate.

Option Infer On

Module Test
    Sub Main()
        ' The type of x is Integer
        Dim x = 10

        ' The type of y is String
        Dim y = "abc"
    End Sub
End Module

Istruzione Imports

Imports Le istruzioni importano i nomi delle entità in un file di origine, consentendo di fare riferimento ai nomi senza qualifica o importare uno spazio dei nomi da usare nelle espressioni XML.

ImportsStatement
    : 'Imports' ImportsClauses StatementTerminator
    ;

ImportsClauses
    : ImportsClause ( Comma ImportsClause )*
    ;

ImportsClause
    : AliasImportsClause
    | MembersImportsClause
    | XMLNamespaceImportsClause
    ;

All'interno delle dichiarazioni dei membri in un file di origine che contiene un'istruzione Imports , è possibile fare riferimento direttamente ai tipi contenuti nello spazio dei nomi specificato, come illustrato nell'esempio seguente:

Imports N1.N2

Namespace N1.N2
    Class A
    End Class
End Namespace 

Namespace N3
    Class B
        Inherits A
    End Class
End Namespace

In questo caso, all'interno del file di origine, i membri di tipo dello spazio dei nomi N1.N2 sono direttamente disponibili e quindi la classe N3.B deriva dalla classe N1.N2.A.

Imports Le istruzioni devono essere visualizzate dopo qualsiasi Option istruzione, ma prima di qualsiasi dichiarazione di tipo. L'ambiente di compilazione può anche definire istruzioni implicite Imports .

Imports le istruzioni rendono i nomi disponibili in un file di origine, ma non dichiarano nulla nello spazio di dichiarazione dello spazio dei nomi globale. L'ambito dei nomi importati da un'istruzione Imports si estende sulle dichiarazioni membro dello spazio dei nomi contenute nel file di origine. L'ambito di un'istruzione Imports in particolare non include altre Imports istruzioni, né include altri file di origine. Imports le istruzioni potrebbero non fare riferimento l'una all'altra.

In questo esempio l'ultima Imports istruzione è in errore perché non è interessata dal primo alias di importazione.

Imports R1 = N1 ' OK.
Imports R2 = N1.N2 ' OK.
Imports R3 = R1.N2 ' Error: Can't refer to R1.

Namespace N1.N2
End Namespace

Nota. I nomi dello spazio dei nomi o dei tipi visualizzati nelle Imports istruzioni vengono sempre considerati come se fossero completi. Ovvero, l'identificatore più a sinistra in uno spazio dei nomi o un nome di tipo viene sempre risolto nello spazio dei nomi globale e il resto della risoluzione procede in base alle normali regole di risoluzione dei nomi. Questo è l'unico posto nella lingua che applica tale regola; la regola garantisce che un nome non possa essere completamente nascosto dalla qualifica. Senza la regola, se un nome nello spazio dei nomi globale era nascosto in un particolare file di origine, sarebbe impossibile specificare nomi da tale spazio dei nomi in modo qualificato.

In questo esempio l'istruzione Imports fa sempre riferimento allo spazio dei nomi globale System e non alla classe nel file di origine.

Imports System   ' Imports the namespace, not the class.

Class System
End Class

Importa alias

Un alias di importazione definisce un alias per uno spazio dei nomi o un tipo.

AliasImportsClause
    : Identifier Equals TypeName
    ;

Imports A = N1.N2.A

Namespace N1.N2
    Class A
    End Class
End Namespace

Namespace N3
    Class B
        Inherits A
    End Class
End Namespace

In questo caso, all'interno del file di origine, A è un alias per N1.N2.Ae quindi la classe N3.B deriva dalla classe N1.N2.A. Lo stesso effetto può essere ottenuto creando un alias R per N1.N2 e quindi facendo riferimento a R.A:

Imports R = N1.N2

Namespace N3
    Class B
        Inherits R.A
    End Class
End Namespace

L'identificatore di un alias di importazione deve essere univoco all'interno dello spazio dei nomi globale (non solo la dichiarazione dello spazio dei nomi globale nel file di origine in cui è definito l'alias di importazione), anche se non dichiara un nome nello spazio delle dichiarazioni dello spazio dei nomi globale.

Nota. Le dichiarazioni in un modulo non introducono nomi nello spazio di dichiarazione contenitore. Pertanto, è valido per una dichiarazione in un modulo avere lo stesso nome di un alias di importazione, anche se il nome della dichiarazione sarà accessibile nello spazio di dichiarazione contenitore.

' Error: Alias A conflicts with typename A
Imports A = N3.A

Class A
End Class

Namespace N3
    Class A
    End Class
End Namespace

In questo caso, lo spazio dei nomi globale contiene già un membro A, quindi si tratta di un errore per un alias di importazione per l'uso di tale identificatore. È analogamente un errore per due o più alias di importazione nello stesso file di origine per dichiarare alias con lo stesso nome.

Un alias di importazione può creare un alias per qualsiasi spazio dei nomi o tipo. L'accesso a uno spazio dei nomi o un tipo tramite un alias restituisce esattamente lo stesso risultato dell'accesso allo spazio dei nomi o al tipo tramite il nome dichiarato.

Imports R1 = N1
Imports R2 = N1.N2

Namespace N1.N2
    Class A
    End Class
End Namespace

Namespace N3
    Class B
        Private a As N1.N2.A
        Private b As R1.N2.A
        Private c As R2.A
    End Class
End Namespace

In questo caso, i nomi N1.N2.A, R1.N2.Ae R2.A sono equivalenti e tutti fanno riferimento alla classe il cui nome completo è N1.N2.A.

L'importazione specifica il nome esatto dello spazio dei nomi o del tipo in cui sta creando un alias. Deve trattarsi del nome completo esatto dello spazio dei nomi o del tipo: non usa le normali regole per la risoluzione dei nomi qualificata( che, ad esempio, consentono l'accesso ai membri di una classe di base tramite una classe derivata).

Se un alias di importazione punta a un tipo o a uno spazio dei nomi che non può essere risolto da queste regole, l'istruzione import viene ignorata e il compilatore genera un avviso.

Inoltre, il riferimento non può essere a un tipo generico aperto. Tutti i tipi generici devono avere argomenti di tipo validi specificati e tutti gli argomenti di tipo devono essere risolvibili dalle regole precedenti. Qualsiasi associazione non corretta di un tipo generico è un errore.

Imports A = G              ' error: since G is an open generic type
Imports B = G(Of Integer)  ' okay
Imports C = Derived.Nested ' warning: Derived.Nested isn't itself a type
Imports D = G(Of Derived.Nested) ' error: Derived.Nested isn't found

Class G(Of T) : End Class

Class Base
    Class Nested : End Class
End Class

Class Derived : Inherits Base
End Class

Module Module1
    Sub Main()
        Dim x As C               ' error: "C" wasn't succesfully defined
        Dim y As Derived.Nested  ' okay
    End Sub
End Module

Le dichiarazioni nel file di origine possono nascondere il nome dell'alias di importazione.

Imports R = N1.N2

Namespace N1.N2
    Class A
    End Class
End Namespace

Namespace N3
    Class R
    End Class

    Class B
        Inherits R.A  ' Error, R has no member A
    End Class
End Namespace

Nell'esempio precedente il riferimento a nella dichiarazione di B genera un errore perché R fa riferimento a R.A , non N1.N2a N3.R.

Un alias di importazione rende disponibile un alias all'interno di un determinato file di origine, ma non contribuisce ad alcun nuovo membro allo spazio di dichiarazione sottostante. In altre parole, un alias di importazione non è transitivo, ma influisce solo sul file di origine in cui si verifica.

File1.vb:

Imports R = N1.N2

Namespace N1.N2
    Class A
    End Class
End Namespace

File2.vb:

Class B
    Inherits R.A ' Error, R unknown.
End Class

Nell'esempio precedente, poiché l'ambito dell'alias di importazione che introduce R si estende solo alle dichiarazioni nel file di origine in cui è contenuto, R è sconosciuto nel secondo file di origine.

Importazioni dello spazio dei nomi

Un'importazione dello spazio dei nomi importa tutti i membri di uno spazio dei nomi o di un tipo, consentendo l'identificatore di ogni membro dello spazio dei nomi o del tipo da utilizzare senza qualifica. Nel caso dei tipi, un'importazione dello spazio dei nomi consente solo l'accesso ai membri condivisi del tipo senza richiedere la qualificazione del nome della classe. In particolare, consente l'uso dei membri dei tipi enumerati senza qualifica.

MembersImportsClause
    : TypeName
    ;

Per esempio:

Imports Colors

Enum Colors
    Red
    Green
    Blue
End Enum

Module M1
    Sub Main()
        Dim c As Colors = Red
    End Sub
End Module

A differenza di un alias di importazione, un'importazione dello spazio dei nomi non ha restrizioni sui nomi importati e può importare spazi dei nomi e tipi i cui identificatori sono già dichiarati all'interno dello spazio dei nomi globale. I nomi importati da un'importazione regolare sono ombreggiati da alias di importazione e dichiarazioni nel file di origine.

Nell'esempio seguente, A fa riferimento a anziché all'interno N3.A delle N1.N2.A dichiarazioni membro nello spazio dei N3 nomi .

Imports N1.N2

Namespace N1.N2
    Class A
    End Class
End Namespace

Namespace N3
    Class A
    End Class

    Class B
        Inherits A
    End Class
End Namespace

Quando più di uno spazio dei nomi importato contiene membri con lo stesso nome (e tale nome non è altrimenti ombreggiato da un alias o una dichiarazione di importazione), un riferimento a tale nome è ambiguo e genera un errore in fase di compilazione.

Imports N1
Imports N2

Namespace N1
    Class A
    End Class
End Namespace 

Namespace N2
    Class A
    End Class
End Namespace 

Namespace N3
    Class B
        Inherits A ' Error, A is ambiguous.
    End Class
End Namespace

Nell'esempio precedente, sia N1 che N2 contengono un membro A. Poiché N3 importa entrambi, il riferimento A a in N3 causa un errore in fase di compilazione. In questo caso, il conflitto può essere risolto tramite la qualificazione dei riferimenti a Ao introducendo un alias di importazione che seleziona un particolare A, come nell'esempio seguente:

Imports N1
Imports N2
Imports A = N1.A

Namespace N3
    Class B
        Inherits A ' A means N1.A.
    End Class
End Namespace

È possibile importare solo spazi dei nomi, classi, strutture, tipi enumerati e moduli standard.

Importazioni di spazi dei nomi XML

Un'importazione dello spazio dei nomi XML definisce uno spazio dei nomi o lo spazio dei nomi predefinito per le espressioni XML non qualificate contenute nell'unità di compilazione.

XMLNamespaceImportsClause
    : '<' XMLNamespaceAttributeName XMLWhitespace? Equals XMLWhitespace?
      XMLNamespaceValue '>'
    ;

XMLNamespaceValue
    : DoubleQuoteCharacter XMLAttributeDoubleQuoteValueCharacter* DoubleQuoteCharacter
    | SingleQuoteCharacter XMLAttributeSingleQuoteValueCharacter* SingleQuoteCharacter
    ;

Per esempio:

Imports <xmlns:db="http://example.org/database">

Module Test
    Sub Main()
        ' db namespace is "http://example.org/database"
        Dim x = <db:customer><db:Name>Bob</></>

        Console.WriteLine(x.<db:Name>)
    End Sub
End Module

Uno spazio dei nomi XML, incluso lo spazio dei nomi predefinito, può essere definito una sola volta per un determinato set di importazioni. Per esempio:

Imports <xmlns:db="http://example.org/database-one">
' Error: namespace db is already defined
Imports <xmlns:db="http://example.org/database-two">

Namespace

I programmi Visual Basic sono organizzati usando spazi dei nomi. Gli spazi dei nomi organizzano internamente un programma e organizzano il modo in cui gli elementi del programma vengono esposti ad altri programmi.

A differenza di altre entità, gli spazi dei nomi sono aperti e possono essere dichiarati più volte all'interno dello stesso programma e in molti programmi, con ogni dichiarazione che contribuisce membri allo stesso spazio dei nomi. Nell'esempio seguente le due dichiarazioni dello spazio dei nomi contribuiscono allo stesso spazio di dichiarazione, dichiarando due classi con i nomi N1.N2.A completi e N1.N2.B.

Namespace N1.N2
    Class A
    End Class
End Namespace

Namespace N1.N2
    Class B
    End Class
End Namespace

Poiché le due dichiarazioni contribuiscono allo stesso spazio di dichiarazione, si tratta di un errore se ognuna contiene una dichiarazione di un membro con lo stesso nome.

Esiste uno spazio dei nomi globale senza nome e i cui spazi dei nomi e tipi annidati possono sempre essere accessibili senza qualifica. L'ambito di un membro dello spazio dei nomi dichiarato nello spazio dei nomi globale è l'intero testo del programma. In caso contrario, l'ambito di un tipo o di uno spazio dei nomi dichiarato in uno spazio dei nomi il cui nome completo è N il testo del programma di ogni spazio dei nomi il cui nome completo dello spazio dei nomi corrispondente inizia con N o è N stesso. Si noti che un compilatore può scegliere di inserire dichiarazioni in uno spazio dei nomi specifico per impostazione predefinita. Ciò non modifica il fatto che esista ancora uno spazio dei nomi globale senza nome.

In questo esempio la classe può visualizzare la classe BA perché Blo spazio dei nomi è concettualmente annidato all'interno dello spazio N1.N2.N3 dei nomi N1.N2.

Namespace N1.N2
    Class A
    End Class
End Namespace

Namespace N1.N2.N3
    Class B
        Inherits A
    End Class
End Namespace

Dichiarazioni dello spazio dei nomi

Esistono tre forme di dichiarazione dello spazio dei nomi.

NamespaceDeclaration
    : 'Namespace' NamespaceName StatementTerminator
      NamespaceMemberDeclaration*
      'End' 'Namespace' StatementTerminator
    ;

NamespaceName
    : RelativeNamespaceName
    | 'Global'
    | 'Global' '.' RelativeNamespaceName
    ;

RelativeNamespaceName
    : Identifier ( Period IdentifierOrKeyword )*
    ;

La prima maschera inizia con la parola chiave Namespace seguita da un nome dello spazio dei nomi relativo. Se il nome dello spazio dei nomi relativo è qualificato, la dichiarazione dello spazio dei nomi viene considerata come se fosse annidata in modo lessicale all'interno delle dichiarazioni dello spazio dei nomi corrispondenti a ogni nome nel nome completo. Ad esempio, i due spazi dei nomi seguenti sono semanticamente equivalenti:

Namespace N1.N2
    Class A
    End Class

    Class B
    End Class
End Namespace 

Namespace N1
    Namespace N2
        Class A
        End Class

        Class B
        End Class
    End Namespace
End Namespace

Il secondo modulo inizia con le parole chiave Namespace Global. Viene considerato come se tutte le dichiarazioni membro fossero inserite lessicalmente nello spazio dei nomi globale senza nome, indipendentemente dalle impostazioni predefinite fornite dall'ambiente di compilazione. Questa forma di dichiarazione dello spazio dei nomi potrebbe non essere annidata in modo lessicale all'interno di qualsiasi altra dichiarazione dello spazio dei nomi.

Il terzo modulo inizia con le parole chiave Namespace Global seguite da un identificatore Ncompleto. Viene considerato come se fosse una dichiarazione dello spazio dei nomi del primo formato "Namespace N" che è stata inserita in modo lessicale nello spazio dei nomi senza nome globale, indipendentemente dalle impostazioni predefinite fornite dall'ambiente di compilazione. Questa forma di dichiarazione dello spazio dei nomi potrebbe non essere annidata in modo lessicale all'interno di qualsiasi altra dichiarazione dello spazio dei nomi.

Namespace Global       ' Puts N1.A in the global namespace
    Namespace N1
        Class A
        End Class
    End Namespace
End Namespace

Namespace Global.N1    ' Equivalent to the above
    Class A
    End Class
End Namespace

Namespace N1           ' May or may not be equivalent to the above,
    Class A            ' depending on defaults provided by the
    End Class          ' compilation environment
End Namespace

Quando si gestiscono i membri di uno spazio dei nomi, non è importante dove viene dichiarato un particolare membro. Se due programmi definiscono un'entità con lo stesso nome nello stesso spazio dei nomi, il tentativo di risolvere il nome nello spazio dei nomi causa un errore di ambiguità.

Gli spazi dei nomi sono per definizione Public, pertanto una dichiarazione dello spazio dei nomi non può includere modificatori di accesso.

Membri dello spazio dei nomi

I membri dello spazio dei nomi possono essere solo dichiarazioni di spazio dei nomi e dichiarazioni di tipo. Le dichiarazioni di tipo possono avere Public o Friend accedere. L'accesso predefinito per i tipi è Friend accesso.

NamespaceMemberDeclaration
    : NamespaceDeclaration
    | TypeDeclaration
    ;

TypeDeclaration
    : ModuleDeclaration
    | NonModuleDeclaration
    ;

NonModuleDeclaration
    : EnumDeclaration
    | StructureDeclaration
    | InterfaceDeclaration
    | ClassDeclaration
    | DelegateDeclaration
    ;