This is a comparison of the "official" D2 grammar extracted from the website and a proposed grammar that is used by the Visual D parser. Some changes are cosmetic (like removal of empty clauses and preferring optional elements instead), but others make syntactic differences that might need to be discussed.

Some changes make sense for a grammar to be fed into a parser generator, but the website version might be better for understanding the language design (e.g. merging all possible DeclDefs).


ProposedWebsite
Module: = Module:
        ModuleDeclaration DeclDefsopt <>         ModuleDeclaration DeclDefs
        DeclDefsopt           DeclDefs

DeclDefs is never empty.

ProposedWebsite
  =  
     
ModuleDeclaration:   ModuleDeclaration:
        module ModuleFullyQualifiedName ;           module ModuleFullyQualifiedName ;
     
ModuleFullyQualifiedName:   ModuleFullyQualifiedName:
        ModuleName           ModuleName
        Packages . ModuleName           Packages . ModuleName
     
ModuleName:   ModuleName:
        Identifier           Identifier
     
Packages:   Packages:
        PackageName           PackageName
        Packages . PackageName           Packages . PackageName
     
PackageName:   PackageName:
        Identifier           Identifier
     
DeclDefs:   DeclDefs:
        DeclDef           DeclDef
        DeclDef DeclDefs           DeclDef DeclDefs
     
DeclDef:   DeclDef:
        AttributeSpecifier           AttributeSpecifier
        ImportDeclaration           ImportDeclaration
        EnumDeclaration           EnumDeclaration
        ClassDeclaration           ClassDeclaration
        InterfaceDeclaration           InterfaceDeclaration
        AggregateDeclaration           AggregateDeclaration
        Declaration           Declaration
        Constructor           Constructor
        Destructor           Destructor
        Invariant           Invariant
        UnitTest           UnitTest
        DebugSpecification <>         StaticConstructor
        VersionSpecification           StaticDestructor
            SharedStaticConstructor
            SharedStaticDestructor
     
        ConditionalDeclaration =         ConditionalDeclaration
        StaticAssert           StaticAssert
        TemplateDeclaration           TemplateDeclaration
        TemplateMixinDeclaration +-  
        TemplateMixin =         TemplateMixin
        MixinDeclaration           MixinDeclaration
        ClassAllocator +-  
        ClassDeallocator    
        AliasThis    
        ; =         ;

A list of declarations is needed in a lot of places, and it will blow up the grammar a lot to list only allowed declarations inside conditionals and attribute specifier blocks and others depending on usage inside struct, class, interface, etc. A parser can verify whether a DeclDef is allowed depending on the current enclosing scope.

Static and shared constructors have been removed, because they are already covered by the AttributeSpecifier clause. It is unclear whether this should declare a shared static constructor

class Foo
{
    shared {
        static this()		// shared? static constructor
        {
        }
    }
}
 
ProposedWebsite
     
ImportDeclaration:   ImportDeclaration:
        import ImportList ;           import ImportList ;
  -+         static import ImportList ;

static is already covered by AttributeSpecifier. This is missing protection attributes, but these are also covered by the AttributeSpecifier. It's also unclear whether putting an import into a static {} block should also make the imports static.

static
{
    import mod1; // static import?
    import mod2;
}
ProposedWebsite
  =  
ImportList:   ImportList:
        Import           Import
        ImportBindings           ImportBindings
        Import , ImportList           Import , ImportList
     
Import:   Import:
        ModuleFullyQualifiedName           ModuleFullyQualifiedName
        ModuleAliasIdentifier = ModuleFullyQualifiedName           ModuleAliasIdentifier = ModuleFullyQualifiedName
     
ImportBindings:   ImportBindings:
        Import : ImportBindList           Import : ImportBindList
     
ImportBindList:   ImportBindList:
        ImportBind           ImportBind
        ImportBind , ImportBindList           ImportBind , ImportBindList
     
ImportBind:   ImportBind:
        Identifier           Identifier
        Identifier = Identifier           Identifier = Identifier
     
ModuleAliasIdentifier:   ModuleAliasIdentifier:
        Identifier           Identifier
     
MixinDeclaration:   MixinDeclaration:
        mixin ( AssignExpression ) ;           mixin ( AssignExpression ) ;
     
Declaration:   Declaration:
        alias Decl           alias Decl
        typedef Decl /* for legacy code */ +-  
        Decl =         Decl
     
Decl:   Decl:
        StorageClasses Decl           StorageClasses Decl
        BasicType BasicTypes2opt Declarators ; <>         BasicType Declarators ;
        BasicType BasicTypes2opt Declarator FunctionBody           BasicType Declarator FunctionBody
        AutoDeclaration =         AutoDeclaration

The original grammar uses BasicTypes2 as part of Declarator in the Declarators, but this is not allowed in a list of variables.

ProposedWebsite
     
Declarators:   Declarators:
        DeclaratorInitializer           DeclaratorInitializer
        DeclaratorInitializer , DeclaratorIdentifierList           DeclaratorInitializer , DeclaratorIdentifierList
     
DeclaratorInitializer:   DeclaratorInitializer:
        Declarator           Declarator
        Declarator = Initializer           Declarator = Initializer
     
DeclaratorIdentifierList:   DeclaratorIdentifierList:
        DeclaratorIdentifier           DeclaratorIdentifier
        DeclaratorIdentifier , DeclaratorIdentifierList           DeclaratorIdentifier , DeclaratorIdentifierList
     
DeclaratorIdentifier:   DeclaratorIdentifier:
        Identifier           Identifier
        Identifier = Initializer           Identifier = Initializer
     
BasicType:   BasicType:
        BasicTypeX           BasicTypeX
        . IdentifierList <>         .IdentifierList
        IdentifierList =         IdentifierList
        Typeof           Typeof
        Typeof . IdentifierList           Typeof . IdentifierList
        const ( Type )           const( type )
        immutable ( Type )           immutable( type )
        shared ( Type )           shared( type )
        inout ( Type )           inout( type )

Missing space and case correction.

ProposedWebsite
  =  
BasicTypeX:   BasicTypeX:
        bool           bool
        byte           byte
        ubyte           ubyte
        short           short
        ushort           ushort
        int           int
        uint           uint
        long           long
        ulong           ulong
        char           char
        wchar           wchar
        dchar           dchar
        float           float
        double           double
        real           real
        ifloat           ifloat
        idouble           idouble
        ireal           ireal
        cfloat           cfloat
        cdouble           cdouble
        creal           creal
        void           void
     
BasicType2:   BasicType2:
        *           *
        [ ]           [ ]
        [ AssignExpression ]           [ AssignExpression ]
        [ AssignExpression .. AssignExpression ]           [ AssignExpression .. AssignExpression ]
        [ Type ]           [ Type ]
        delegate Parameters FunctionAttributesopt           delegate Parameters FunctionAttributesopt
        function Parameters FunctionAttributesopt           function Parameters FunctionAttributesopt
     
BasicTypes2: +-  
        BasicType2    
        BasicType2 BasicTypes2    
  =  
Declarator:   Declarator:
  <>         BasicType2opt Declarator DeclaratorSuffixesopt
        Identifier DeclaratorSuffixesopt           BasicType2opt Identifier DeclaratorSuffixesopt

Allow multiple BasicType2 modifiers (see also Decl). Does it make sense to have multiple delegate/function suffixes?

ProposedWebsite
  =  
DeclaratorSuffixes:   DeclaratorSuffixes:
        DeclaratorSuffix           DeclaratorSuffix
        DeclaratorSuffix DeclaratorSuffixes           DeclaratorSuffix DeclaratorSuffixes
     
DeclaratorSuffix:   DeclaratorSuffix:
        [ ]           [ ]
        [ AssignExpression ]           [ AssignExpression ]
        [ Type ]           [ Type ]
        TemplateParameterListopt Parameters MemberFunctionAttributesopt Constraintopt <>         TemplateParameterListopt Parameters MemberFunctionAttributesopt

Optional constraint missing for function template declaration.

ProposedWebsite
  =  
GlobalIdentifierList: +-  
        IdentifierList    
        . IdentifierList    

Almost evereywhere an IdentifierList is allowed, starting name lookup at global scope is also allowed.

ProposedWebsite
  =  
IdentifierList:   IdentifierList:
        Identifier           Identifier
        Identifier . IdentifierList           Identifier . IdentifierList
        TemplateInstance           TemplateInstance
        TemplateInstance . IdentifierList           TemplateInstance . IdentifierList
     
StorageClasses:   StorageClasses:
        StorageClass           StorageClass
        StorageClass StorageClasses           StorageClass StorageClasses
     
StorageClass:   StorageClass:
        abstract           abstract
        auto           auto
        const           const
        deprecated           deprecated
        extern           extern
        final           final
        immutable           immutable
        inout           inout
        shared           shared
        nothrow           nothrow
        override           override
        pure           pure
        ref <>  
        scope =         scope
        static           static
        synchronized           synchronized
        __gshared +-  
        __thread    

Added missing storage types. I don't know whether "ref" should be here, though.

ProposedWebsite
  =  
Type:   Type:
        BasicType           BasicType
        BasicType Declarator2           BasicType Declarator2
     
Declarator2:   Declarator2:
        BasicTypes2 Declarator2 <>         BasicType2 Declarator2
        ( Declarator2 ) =         ( Declarator2 )
        ( Declarator2 ) DeclaratorSuffixes           ( Declarator2 ) DeclaratorSuffixes

See Declarator.

ProposedWebsite
  +-  
     
TypeWithModifier:    
        Type    
        const TypeWithModifier    
        immutable TypeWithModifier    
        inout TypeWithModifier    
        shared TypeWithModifier    

Needed by cast and TypeSpecification.

ProposedWebsite
  =  
Parameters:   Parameters:
        ( ParameterList )           ( ParameterList )
        ( )           ( )
     
ParameterList:   ParameterList:
        Parameter           Parameter
        Parameter , ParameterList           Parameter , ParameterList
        Parameter ...           Parameter ...
        ...           ...
     
Parameter:   Parameter:
        InOutopt ParameterDeclarator DefaultInitializerExpressionopt <>         Declarator
            Declarator = DefaultInitializerExpression
ParameterDeclarator:           InOut Declarator
        StorageClasses_opt BasicType BasicTypes2_opt Declaratoropt           InOut Declarator = DefaultInitializerExpression
     

Parameters must have a type. Storage classes are used to implement types like "const int[]". Maybe TypeWithModifier could also be used here.

ProposedWebsite
  =  
InOut:   InOut:
        in           in
        out           out
        ref           ref
        lazy           lazy
        scope +-  

scope takes a special meaning here, but could also be considered as part of StorageClass.

ProposedWebsite
  =  
FunctionAttributes:   FunctionAttributes:
        FunctionAttribute           FunctionAttribute
        FunctionAttribute FunctionAttributes           FunctionAttribute FunctionAttributes
     
FunctionAttribute:   FunctionAttribute:
        nothrow           nothrow
        pure           pure
     
MemberFunctionAttributes:   MemberFunctionAttributes:
        MemberFunctionAttribute           MemberFunctionAttribute
        MemberFunctionAttribute MemberFunctionAttributes           MemberFunctionAttribute MemberFunctionAttributes
     
MemberFunctionAttribute:   MemberFunctionAttribute:
        const           const
        immutable           immutable
        inout           inout
        shared           shared
        FunctionAttribute           FunctionAttribute
     
DefaultInitializerExpression:   DefaultInitializerExpression:
        = AssignExpression <>         AssignExpression
            __FILE__
            __LINE__

'=' added due to changed Parameter definition, __FILE__ and __LINE__ are also part of expressions.

ProposedWebsite
  =  
Initializer:   Initializer:
        VoidInitializer           VoidInitializer
        NonVoidInitializer           NonVoidInitializer
     
NonVoidInitializer:   NonVoidInitializer:
        AssignExpression           AssignExpression
        ArrayInitializer           ArrayInitializer
        StructInitializer           StructInitializer
     
ArrayInitializer:   ArrayInitializer:
  <>         [ ]
            [ ArrayMemberInitializations ]
        ArrayLiteral    
    ArrayMemberInitializations:
            ArrayMemberInitialization
            ArrayMemberInitialization ,
            ArrayMemberInitialization , ArrayMemberInitializations
           
    ArrayMemberInitialization:
            NonVoidInitializer
            AssignExpression : NonVoidInitializer
     
StructInitializer: = StructInitializer:
  <>         {  }
            { StructMemberInitializers }
     
    StructMemberInitializers:
        StructLiteral           StructMemberInitializer
            StructMemberInitializer ,
            StructMemberInitializer , StructMemberInitializers
           
    StructMemberInitializer:
            NonVoidInitializer
            Identifier : NonVoidInitializer

A context free parser cannot really make sense of the literal in the initializer, so it might be good enough to parse these as part of the expression. StructInitializer is deprecated, but I moved into the expression as well. Would be nice, if the initializer would not be special-cased.

ProposedWebsite
AutoDeclaration: = AutoDeclaration:
        StorageClasses Identifier = AssignExpression ;           StorageClasses Identifier = AssignExpression ;
     
Typeof:   Typeof:
        typeof ( Expression )           typeof ( Expression )
        typeof ( return )           typeof ( return )
     
VoidInitializer:   VoidInitializer:
        void           void
     
AttributeSpecifier:   AttributeSpecifier:
        Attribute :           Attribute :
        Attribute DeclarationBlock           Attribute DeclarationBlock
     
Attribute:   Attribute:
        LinkageAttribute           LinkageAttribute
        AlignAttribute           AlignAttribute
        Pragma           Pragma
        deprecated           deprecated
        ProtectionAttribute           ProtectionAttribute
        static           static
        final           final
        override           override
        abstract           abstract
        const           const
        auto           auto
        scope           scope
        __gshared           __gshared
        shared           shared
        immutable           immutable
        inout           inout
        ref +-  
        extern    
        synchronized    
        __thread    
        @disable =         @disable
        @property <>  
        @safe      
        @system    
        @trusted    

Added missing attributes. This should probably be using StorageClass.

ProposedWebsite
  =  
DeclarationBlock:   DeclarationBlock:
        DeclDef           DeclDef
  <>         { }
        { DeclDefsopt }           { DeclDefs }
  =  
LinkageAttribute:   LinkageAttribute:
  -+         extern
        extern ( LinkageType ) =         extern ( LinkageType )

extern is not a linkage attibute (i.e. it does not affect calling convention and name mangling), but only where it is defined (a storage class?).

ProposedWebsite
     
LinkageType:   LinkageType:
        C           C
        C ++ <>         C++
        D =         D
        Windows           Windows
        Pascal           Pascal
        System           System
     
AlignAttribute:   AlignAttribute:
        align           align
        align ( Integer )           align ( Integer )
     
ProtectionAttribute:   ProtectionAttribute:
        private           private
        package           package
        protected           protected
        public           public
        export           export
     
  -+ const
     
    override
     
    static
     
    auto
     
    scope
     

Stray grammer entries in the ddoc files. Should spaces and comments be allowed in "C++"?

ProposedWebsite
Pragma: = Pragma:
        pragma ( Identifier )           pragma ( Identifier )
        pragma ( Identifier , TemplateArgumentList ) <>         pragma ( Identifier , ArgumentList )
  =  

pragma(msg) accepts both expression and types.

ProposedWebsite
     
Expression:   Expression:
        CommaExpression +-  
     
CommaExpression:    
        AssignExpression =         AssignExpression
        AssignExpression , CommaExpression <>         AssignExpression , Expression
  =  
AssignExpression:   AssignExpression:
        ConditionalExpression           ConditionalExpression
        ConditionalExpression = AssignExpression           ConditionalExpression = AssignExpression
        ConditionalExpression += AssignExpression           ConditionalExpression += AssignExpression
        ConditionalExpression -= AssignExpression           ConditionalExpression -= AssignExpression
        ConditionalExpression *= AssignExpression           ConditionalExpression *= AssignExpression
        ConditionalExpression /= AssignExpression           ConditionalExpression /= AssignExpression
        ConditionalExpression %= AssignExpression           ConditionalExpression %= AssignExpression
        ConditionalExpression &= AssignExpression           ConditionalExpression &= AssignExpression
        ConditionalExpression |= AssignExpression           ConditionalExpression |= AssignExpression
        ConditionalExpression ^= AssignExpression           ConditionalExpression ^= AssignExpression
        ConditionalExpression ~= AssignExpression           ConditionalExpression ~= AssignExpression
        ConditionalExpression <<= AssignExpression           ConditionalExpression <<= AssignExpression
        ConditionalExpression >>= AssignExpression           ConditionalExpression >>= AssignExpression
        ConditionalExpression >>>= AssignExpression           ConditionalExpression >>>= AssignExpression
        ConditionalExpression ^^= AssignExpression           ConditionalExpression ^^= AssignExpression
     
ConditionalExpression:   ConditionalExpression:
        OrOrExpression           OrOrExpression
        OrOrExpression ? Expression : ConditionalExpression           OrOrExpression ? Expression : ConditionalExpression
     
OrOrExpression:   OrOrExpression:
        AndAndExpression           AndAndExpression
        OrOrExpression || AndAndExpression           OrOrExpression || AndAndExpression
     
AndAndExpression:   AndAndExpression:
        OrExpression           OrExpression
        AndAndExpression && OrExpression           AndAndExpression && OrExpression
        CmpExpression -+         CmpExpression
        AndAndExpression && CmpExpression           AndAndExpression && CmpExpression
  =  
OrExpression:   OrExpression:
        XorExpression           XorExpression
        OrExpression | XorExpression           OrExpression | XorExpression
     
XorExpression:   XorExpression:
        AndExpression           AndExpression
        XorExpression ^ AndExpression           XorExpression ^ AndExpression
     
AndExpression:   AndExpression:
        ShiftExpression <>         ShiftExpression
        AndExpression & ShiftExpression           AndExpression & ShiftExpression
ProposedWebsite
  =  
CmpExpression:   CmpExpression:
        ShiftExpression           ShiftExpression
        EqualExpression           EqualExpression
        IdentityExpression           IdentityExpression
        RelExpression           RelExpression
        InExpression           InExpression
     
EqualExpression:   EqualExpression:
        ShiftExpression == ShiftExpression           ShiftExpression == ShiftExpression
        ShiftExpression != ShiftExpression           ShiftExpression != ShiftExpression
     
IdentityExpression:   IdentityExpression:
        ShiftExpression is ShiftExpression           ShiftExpression is ShiftExpression
        ShiftExpression !is ShiftExpression           ShiftExpression !is ShiftExpression
     
RelExpression:   RelExpression:
        ShiftExpression < ShiftExpression           ShiftExpression < ShiftExpression
        ShiftExpression <= ShiftExpression           ShiftExpression <= ShiftExpression
        ShiftExpression > ShiftExpression           ShiftExpression > ShiftExpression
        ShiftExpression >= ShiftExpression           ShiftExpression >= ShiftExpression
        ShiftExpression !<>= ShiftExpression           ShiftExpression !<>= ShiftExpression
        ShiftExpression !<> ShiftExpression           ShiftExpression !<> ShiftExpression
        ShiftExpression <> ShiftExpression           ShiftExpression <> ShiftExpression
        ShiftExpression <>= ShiftExpression           ShiftExpression <>= ShiftExpression
        ShiftExpression !> ShiftExpression           ShiftExpression !> ShiftExpression
        ShiftExpression !>= ShiftExpression           ShiftExpression !>= ShiftExpression
        ShiftExpression !< ShiftExpression           ShiftExpression !< ShiftExpression
        ShiftExpression !<= ShiftExpression           ShiftExpression !<= ShiftExpression
     
InExpression:   InExpression:
        ShiftExpression in ShiftExpression           ShiftExpression in ShiftExpression
        ShiftExpression !in ShiftExpression           ShiftExpression !in ShiftExpression

Should !in and !is be single tokens? Right now you can put spaces and comments after the !.

ProposedWebsite
     
ShiftExpression:   ShiftExpression:
        AddExpression           AddExpression
        ShiftExpression << AddExpression           ShiftExpression << AddExpression
        ShiftExpression >> AddExpression           ShiftExpression >> AddExpression
        ShiftExpression >>> AddExpression           ShiftExpression >>> AddExpression
     
AddExpression:   AddExpression:
        MulExpression           MulExpression
        AddExpression + MulExpression           AddExpression + MulExpression
        AddExpression - MulExpression           AddExpression - MulExpression
        CatExpression           CatExpression
     
CatExpression:   CatExpression:
        AddExpression ~ MulExpression           AddExpression ~ MulExpression
     
MulExpression:   MulExpression:
        PowExpression           PowExpression
        MulExpression * PowExpression           MulExpression * PowExpression
        MulExpression / PowExpression           MulExpression / PowExpression
        MulExpression % PowExpression           MulExpression % PowExpression
     
PowExpression:   PowExpression:
        UnaryExpression           UnaryExpression
        UnaryExpression ^^ PowExpression           UnaryExpression ^^ PowExpression
     
UnaryExpression:   UnaryExpression:
        PostfixExpression           PostfixExpression
        & UnaryExpression           & UnaryExpression
        ++ UnaryExpression           ++ UnaryExpression
        -- UnaryExpression           -- UnaryExpression
        * UnaryExpression           * UnaryExpression
        - UnaryExpression           - UnaryExpression
        + UnaryExpression           + UnaryExpression
        ! UnaryExpression           ! UnaryExpression
        ~ UnaryExpression           ~ UnaryExpression
  -+         ( Type ) . Identifier
        NewExpression =         NewExpression
        DeleteExpression           DeleteExpression
        CastExpression           CastExpression
  -+         NewAnonClassExpression

"(Type).Identifier" should be part of PostfixExpression to have the same precedence as BasicType.Identifier. NewAnonClassExpression is already covered by NewExpression.

ProposedWebsite
  =  
NewExpression:   NewExpression:
        NewArguments Type [ AssignExpression ]           NewArguments Type [ AssignExpression ]
        NewArguments Type ( ArgumentList )           NewArguments Type ( ArgumentList )
        NewArguments Type           NewArguments Type
        NewArguments ClassArguments BaseClassesopt { DeclDefsopt } <>         NewArguments ClassArguments BaseClasslistopt { DeclDefs }

DeclDefs is never empty.

ProposedWebsite
  =  
NewArguments:   NewArguments:
        new ( ArgumentList )           new ( ArgumentList )
        new ( )           new ( )
        new           new
     
ClassArguments:   ClassArguments:
        class ( ArgumentList )           class ( ArgumentList )
        class ( )           class ( )
        class           class
     
ArgumentList:   ArgumentList:
        AssignExpression           AssignExpression
        AssignExpression ,           AssignExpression ,
        AssignExpression , ArgumentList           AssignExpression , ArgumentList
     
Arguments: <>  
        ( )    
        ( ArgumentList )    

Arguments used by PrimaryExpression and could simplify a few more rules.

ProposedWebsite
  =  
DeleteExpression:   DeleteExpression:
        delete UnaryExpression           delete UnaryExpression
  -+  
CastExpression: = CastExpression:
        cast ( TypeWithModifier ) UnaryExpression <>         cast ( Type ) UnaryExpression
        cast ( )              UnaryExpression    
        cast ( const )        UnaryExpression    
        cast ( const shared ) UnaryExpression    
        cast ( immutable )    UnaryExpression    
        cast ( inout )        UnaryExpression    
        cast ( inout shared ) UnaryExpression    
        cast ( shared )       UnaryExpression    
        cast ( shared const ) UnaryExpression    
        cast ( shared inout ) UnaryExpression    

Allow casting away or adding modifiers with/without type.

ProposedWebsite
  =  
PostfixExpression:   PostfixExpression:
        PrimaryExpression           PrimaryExpression
        PostfixExpression . IdentifierOrTemplateInstance <>         PostfixExpression . Identifier
        PostfixExpression . NewExpression =         PostfixExpression . NewExpression
        PostfixExpression ++           PostfixExpression ++
        PostfixExpression --           PostfixExpression --
        PostfixExpression ( )           PostfixExpression ( )
        PostfixExpression ( ArgumentList )           PostfixExpression ( ArgumentList )
        IndexExpression           IndexExpression
        SliceExpression           SliceExpression

Often a template instance can also be used instead of an identifier.

ProposedWebsite
     
IndexExpression:   IndexExpression:
        PostfixExpression [ ArgumentList ]           PostfixExpression [ ArgumentList ]
     
SliceExpression:   SliceExpression:
        PostfixExpression [ ]           PostfixExpression [ ]
        PostfixExpression [ AssignExpression .. AssignExpression ]           PostfixExpression [ AssignExpression .. AssignExpression ]
     
PrimaryExpression:   PrimaryExpression:
        Identifier           Identifier
        . Identifier <>         .Identifier
        TemplateInstance =         TemplateInstance
        this           this
        super           super
        null           null
        true           true
        false           false
        $           $
        __FILE__           __FILE__
        __LINE__           __LINE__
        IntegerLiteral           IntegerLiteral
        FloatLiteral           FloatLiteral
        CharacterLiteral           CharacterLiteral
        StringLiterals           StringLiterals
        ArrayLiteral           ArrayLiteral
        AssocArrayLiteral           AssocArrayLiteral
        FunctionLiteral           FunctionLiteral
        StructLiteral            // deprecated +-  
        AssertExpression =         AssertExpression
        MixinExpression           MixinExpression
        ImportExpression           ImportExpression
        BasicType . IdentifierOrTemplateInstance <>  
        Typeof    . IdentifierOrTemplateInstance    
        ( Type )  . IdentifierOrTemplateInstance    
        BasicType Arguments           BasicType . Identifier
        Typeof    Arguments           Typeof
        ( Type )  Arguments    
        TypeidExpression =         TypeidExpression
        IsExpression           IsExpression
        ( Expression )           ( Expression )
        TraitsExpression           TraitsExpression

Added struct constructor syntax. Typeof on its own is a Type, not an expression.

ProposedWebsite
     
     
StringLiterals:   StringLiterals:
        StringLiteral           StringLiteral
        StringLiterals StringLiteral           StringLiterals StringLiteral
     
ArrayLiteral:   ArrayLiteral:
        [ ArgumentList ]           [ ArgumentList ]
     
AssocArrayLiteral:   AssocArrayLiteral:
        [ KeyValuePairs ]           [ KeyValuePairs ]
     
ArrayValueList: <> KeyValuePairs:
        ArrayValue           KeyValuePair
        ArrayValue , ArrayValue           KeyValuePair , KeyValuePairs
  =  
ArrayValue: <> KeyValuePair:
            KeyExpression : ValueExpression
     
        AssignExpression   KeyExpression:
        AssignExpression : AssignExpression           ConditionalExpression
  =  
  -+ ValueExpression:
            ConditionalExpression

It's not possible for the parser to distinguish a associative array from a dynamic/static array, because they all have the "expr : val" initializer syntax.

ProposedWebsite
     
FunctionLiteral: = FunctionLiteral:
        function Typeopt ParameterAttributesopt FunctionBody <>         function Typeopt ParameterAttributes opt FunctionBody
        delegate Typeopt ParameterAttributesopt FunctionBody           delegate Typeopt ParameterAttributes opt FunctionBody
        ParameterAttributes FunctionBody =         ParameterAttributes FunctionBody
        FunctionBody           FunctionBody
     
ParameterAttributes:   ParameterAttributes:
        Parameters           Parameters
        Parameters FunctionAttributes           Parameters FunctionAttributes
     
StructLiteral: <>  
        { ArrayValueList }    

ProposedWebsite
  =  
AssertExpression:   AssertExpression:
        assert ( AssignExpression )           assert ( AssignExpression )
        assert ( AssignExpression , AssignExpression )           assert ( AssignExpression , AssignExpression )
     
MixinExpression:   MixinExpression:
        mixin ( AssignExpression )           mixin ( AssignExpression )
     
ImportExpression:   ImportExpression:
        import ( AssignExpression )           import ( AssignExpression )
     
TypeidExpression:   TypeidExpression:
        typeid ( Type )           typeid ( Type )
        typeid ( Expression )           typeid ( Expression )
     
IsExpression:   IsExpression:
        is ( Type )           is ( Type )
        is ( Type : TypeSpecialization )           is ( Type : TypeSpecialization )
        is ( Type == TypeSpecialization )           is ( Type == TypeSpecialization )
        is ( Type Identifier )           is ( Type Identifier )
        is ( Type Identifier : TypeSpecialization )           is ( Type Identifier : TypeSpecialization )
        is ( Type Identifier == TypeSpecialization )           is ( Type Identifier == TypeSpecialization )
        is ( Type Identifier : TypeSpecialization , TemplateParameterList )           is ( Type Identifier : TypeSpecialization , TemplateParameterList )
        is ( Type Identifier == TypeSpecialization , TemplateParameterList )           is ( Type Identifier == TypeSpecialization , TemplateParameterList )
     
TypeSpecialization:   TypeSpecialization:
        TypeWithModifier <>         Type
        struct =         struct
        union           union
        class           class
        interface           interface
        enum           enum
        function           function
        delegate           delegate
        super           super
        const           const
        immutable           immutable
        inout           inout
        shared           shared
        return           return
     

TypeSpecialization can have type modifiers. If !is is a token to the lexer, it needs special treatment in the IsExpression.

ProposedWebsite
  =  
TraitsExpression:   TraitsExpression:
        __traits ( TraitsKeyword , TraitsArguments )           __traits ( TraitsKeyword , TraitsArguments )
     
TraitsKeyword:   TraitsKeyword:
        isAbstractClass           isAbstractClass
        isArithmetic           isArithmetic
        isAssociativeArray           isAssociativeArray
        isFinalClass           isFinalClass
        isFloating           isFloating
        isIntegral           isIntegral
        isScalar           isScalar
        isStaticArray           isStaticArray
        isUnsigned           isUnsigned
        isVirtualFunction           isVirtualFunction
        isAbstractFunction           isAbstractFunction
        isFinalFunction           isFinalFunction
        isStaticFunction           isStaticFunction
        isRef           isRef
        isOut           isOut
        isLazy           isLazy
        hasMember           hasMember
        identifier           identifier
        getMember           getMember
        getOverloads           getOverloads
        getVirtualFunctions           getVirtualFunctions
        classInstanceSize           classInstanceSize
        allMembers           allMembers
        derivedMembers           derivedMembers
        isSame           isSame
        compiles           compiles
     
TraitsArguments:   TraitsArguments:
        TraitsArgument           TraitsArgument
        TraitsArgument , TraitsArguments           TraitsArgument , TraitsArguments
     
TraitsArgument:   TraitsArgument:
        AssignExpression           AssignExpression
        Type           Type
     
Statement:   ScopeStatement:
        ScopeStatement +-         NonEmptyStatement
            BlockStatement
     
ScopeStatement:   Statement:
        ; =         ;
        NonEmptyStatement           NonEmptyStatement
        ScopeBlockStatement           ScopeBlockStatement
  +-  
ScopeBlockStatement:   ScopeBlockStatement:
        BlockStatement           BlockStatement
     
ScopeNonEmptyStatement:   NonEmptyOrScopeBlockStatement:
        NonEmptyStatement           NonEmptyStatement
        BlockStatement           ScopeBlockStatement

Tried to make naming clearer, but probably just added to the confusion here...

ProposedWebsite
  =  
NoScopeNonEmptyStatement:   NoScopeNonEmptyStatement:
        NonEmptyStatement           NonEmptyStatement
        BlockStatement           BlockStatement
     
NoScopeStatement:   NoScopeStatement:
        ;           ;
        NonEmptyStatement           NonEmptyStatement
        BlockStatement         BlockStatement

ProposedWebsite
  =  
NonEmptyStatement:   NonEmptyStatement:
        LabeledStatement           LabeledStatement
        ExpressionStatement           ExpressionStatement
        DeclarationStatement           DeclarationStatement
        IfStatement           IfStatement
        WhileStatement           WhileStatement
        DoStatement           DoStatement
        ForStatement           ForStatement
        ForeachStatement           ForeachStatement
        SwitchStatement           SwitchStatement
        FinalSwitchStatement           FinalSwitchStatement
        CaseStatement           CaseStatement
        CaseRangeStatement           CaseRangeStatement
        DefaultStatement           DefaultStatement
        ContinueStatement           ContinueStatement
        BreakStatement           BreakStatement
        ReturnStatement           ReturnStatement
        GotoStatement           GotoStatement
        WithStatement           WithStatement
        SynchronizedStatement           SynchronizedStatement
        TryStatement           TryStatement
        ScopeGuardStatement           ScopeGuardStatement
        ThrowStatement           ThrowStatement
        AsmStatement           AsmStatement
        PragmaStatement           PragmaStatement
        MixinStatement           MixinStatement
        ForeachRangeStatement           ForeachRangeStatement
        ConditionalStatement           ConditionalStatement
        StaticAssert           StaticAssert
        TemplateMixin           TemplateMixin
        EnumDeclaration <>  
        ClassDeclaration    
        InterfaceDeclaration    
        AggregateDeclaration    
        TemplateDeclaration    

Added missing declaration statements. Maybe these should be part of DeclarationStatement.

ProposedWebsite
  =  
LabeledStatement:   LabeledStatement:
        Identifier : NoScopeStatement           Identifier : NoScopeStatement
     
BlockStatement:   BlockStatement:
        { }           { }
        { StatementList }           { StatementList }
     
StatementList:   StatementList:
        Statement           Statement
        Statement StatementList           Statement StatementList
     
ExpressionStatement:   ExpressionStatement:
        Expression ;           Expression ;
     
DeclarationStatement:   DeclarationStatement:
        Declaration           Declaration
     
IfStatement:   IfStatement:
        if ( IfCondition ) ThenStatement           if ( IfCondition ) ThenStatement
        if ( IfCondition ) ThenStatement else ElseStatement           if ( IfCondition ) ThenStatement else ElseStatement
     
IfCondition:   IfCondition:
        Expression           Expression
        auto Identifier = Expression           auto Identifier = Expression
        BasicType BasicTypes2opt Declarator = Expression <>         Declarator = Expression
  =  
ThenStatement:   ThenStatement:
        ScopeNonEmptyStatement <>         ScopeStatement
  =  
ElseStatement:   ElseStatement:
        ScopeNonEmptyStatement <>         ScopeStatement

Missing explicite type in IfCondition.

ProposedWebsite
  =  
     
WhileStatement:   WhileStatement:
        while ( Expression ) ScopeNonEmptyStatement <>         while ( Expression ) ScopeStatement
  =  
DoStatement:   DoStatement:
        do ScopeNonEmptyStatement while ( Expression ) ; <>         do ScopeStatement while ( Expression )

Not forcing ';' is deprecated. Here is an example where it makes a difference:

if(true)
    do {} while(false); // will not parse with current grammar
else

{
}

ProposedWebsite
  =  
ForStatement:   ForStatement:
        for ( Initialize Test ; Increment ) ScopeNonEmptyStatement <>         for (Initialize Test ; Increment) ScopeStatement
     
Initialize: = Initialize:
        ;           ;
        NoScopeNonEmptyStatement           NoScopeNonEmptyStatement
     
Test:   Test:
  <>         empty
        Expressionopt           Expression
  =  
Increment:   Increment:
  <>         empty
        Expressionopt           Expression

ProposedWebsite
  =  
     
ForeachStatement:   ForeachStatement:
        Foreach ( ForeachTypeList ; Aggregate ) NoScopeNonEmptyStatement <>         Foreach (ForeachTypeList ; Aggregate) NoScopeNonEmptyStatement
  =  
Foreach:   Foreach:
        foreach           foreach
        foreach_reverse           foreach_reverse
     
ForeachTypeList:   ForeachTypeList:
        ForeachType           ForeachType
        ForeachType , ForeachTypeList           ForeachType , ForeachTypeList
     
ForeachType:   ForeachType:
        refopt Typeopt Identifier <>         ref Type Identifier
            Type Identifier
            ref Identifier
            Identifier

ProposedWebsite
  =  
Aggregate:   Aggregate:
        Expression           Expression
     
     
SwitchStatement:   SwitchStatement:
        switch ( Expression ) ScopeNonEmptyStatement <>         switch ( Expression ) ScopeStatement
  =  
  +-  
CaseStatement: = CaseStatement:
        case ArgumentList : Statementopt <>         case ArgumentList : Statement
  =  
CaseRangeStatement:   CaseRangeStatement:
        case FirstExp : .. case LastExp : Statementopt <>         case FirstExp : .. case LastExp : Statement
  =  
FirstExp:   FirstExp:
        AssignExpression           AssignExpression
     
LastExp:   LastExp:
        AssignExpression           AssignExpression
     
DefaultStatement:   DefaultStatement:
        default : Statementopt <>         default : Statement

ProposedWebsite
  =  
FinalSwitchStatement:   FinalSwitchStatement:
        final switch ( Expression ) ScopeNonEmptyStatement <>         final switch ( Expression ) ScopeStatement

ProposedWebsite
  =  
ContinueStatement:   ContinueStatement:
        continue ; <>         continue;
        continue Identifier ; =         continue Identifier ;
     
BreakStatement:   BreakStatement:
        break ; <>         break;
        break Identifier ; =         break Identifier ;
     
ReturnStatement:   ReturnStatement:
        return ; <>         return;
        return Expression ; =         return Expression ;
     
GotoStatement:   GotoStatement:
        goto Identifier ;           goto Identifier ;
        goto default ;           goto default ;
        goto case ;           goto case ;
        goto case Expression ;           goto case Expression ;
     
WithStatement:   WithStatement:
        with ( Expression ) ScopeNonEmptyStatement <>         with ( Expression ) ScopeStatement
        with ( Symbol ) ScopeNonEmptyStatement           with ( Symbol ) ScopeStatement
        with ( TemplateInstance ) ScopeNonEmptyStatement           with ( TemplateInstance ) ScopeStatement
  =  
SynchronizedStatement:   SynchronizedStatement:
        synchronized ScopeNonEmptyStatement <>         synchronized ScopeStatement
        synchronized ( Expression ) ScopeNonEmptyStatement           synchronized ( Expression ) ScopeStatement
  =  
TryStatement:   TryStatement:
        try ScopeNonEmptyStatement Catches <>         try ScopeStatement Catches
        try ScopeNonEmptyStatement Catches FinallyStatement           try ScopeStatement Catches FinallyStatement
        try ScopeNonEmptyStatement FinallyStatement           try ScopeStatement FinallyStatement

ProposedWebsite
  =  
Catches:   Catches:
        LastCatch           LastCatch
        Catch           Catch
        Catch Catches           Catch Catches
     
LastCatch:   LastCatch:
        catch NoScopeNonEmptyStatement           catch NoScopeNonEmptyStatement
     
Catch:   Catch:
        catch ( CatchParameter ) NoScopeNonEmptyStatement           catch ( CatchParameter ) NoScopeNonEmptyStatement
     
CatchParameter:   CatchParameter:
        BasicType Identifier           BasicType Identifier
     
FinallyStatement:   FinallyStatement:
        finally NoScopeNonEmptyStatement           finally NoScopeNonEmptyStatement
     
ThrowStatement:   ThrowStatement:
        throw Expression ;           throw Expression ;
     
ScopeGuardStatement:   ScopeGuardStatement:
        scope ( exit ) ScopeNonEmptyStatement <>         scope(exit) NonEmptyOrScopeBlockStatement
        scope ( success ) ScopeNonEmptyStatement           scope(success) NonEmptyOrScopeBlockStatement
        scope ( failure ) ScopeNonEmptyStatement           scope(failure) NonEmptyOrScopeBlockStatement

ProposedWebsite
  =  
AsmStatement:   AsmStatement:
        asm { }           asm { }
        asm { AsmInstructionList }           asm { AsmInstructionList }
     
AsmInstructionList:   AsmInstructionList:
        AsmInstruction ;           AsmInstruction ;
        AsmInstruction ; AsmInstructionList           AsmInstruction ; AsmInstructionList
     
PragmaStatement:   PragmaStatement:
        Pragma NoScopeStatement           Pragma NoScopeStatement
     
MixinStatement:   MixinStatement:
        mixin ( AssignExpression ) ;           mixin ( AssignExpression ) ;
     
ForeachRangeStatement:   ForeachRangeStatement:
        Foreach ( ForeachType ; LwrExpression .. UprExpression ) ScopeNonEmptyStatement <>         Foreach (ForeachType ; LwrExpression .. UprExpression ) ScopeStatement

ProposedWebsite
  =  
LwrExpression:   LwrExpression:
        Expression           Expression
     
UprExpression:   UprExpression:
        Expression           Expression
     
AggregateDeclaration:   AggregateDeclaration:
        struct Identifier StructBody           struct Identifier StructBody
        union Identifier StructBody           union Identifier StructBody
        struct Identifier ;           struct Identifier ;
        union Identifier ;           union Identifier ;
        StructTemplateDeclaration           StructTemplateDeclaration
        UnionTemplateDeclaration           UnionTemplateDeclaration
     
StructBody:   StructBody:
        { DeclDefsopt } <>         { }
            { StructBodyDeclarations }
  =  
  -+ StructBodyDeclarations:
            StructBodyDeclaration
            StructBodyDeclaration StructBodyDeclarations
     
    StructBodyDeclaration:
            Declaration
            StaticConstructor
            StaticDestructor
            Invariant
            UnitTest
            StructAllocator
            StructDeallocator
            StructConstructor
            StructPostblit
            StructDestructor
     
            AliasThis
     
     
     
    StructAllocator:
            ClassAllocator
     
    StructDeallocator:
            ClassDeallocator
     
ProposedWebsite
    StructConstructor:
            this ( ParameterList ) FunctionBody
     
    StructPostblit:
            this ( this ) FunctionBody
     
    StructDestructor:
            ~ this ( ) FunctionBody
     
     

Merged with DeclDefs. DeclDefs.

ProposedWebsite
     
     
ClassDeclaration: = ClassDeclaration:
        class Identifier BaseClassListopt ClassBody <>         class Identifier BaseClassList ClassBody
        ClassTemplateDeclaration =         ClassTemplateDeclaration
        class Identifier ; +-  
  =  
BaseClassList:   BaseClassList:
  -+         Empty
        : SuperClass =         : SuperClass
        : SuperClass , InterfaceClasses           : SuperClass , InterfaceClasses

Forward declaration allowed.allowed.

ProposedWebsite
     
SuperClass:   SuperClass:
        GlobalIdentifierList <>         Identifier
        Protection GlobalIdentifierList           Protection Identifier
  =  
InterfaceClasses:   InterfaceClasses:
        InterfaceClass           InterfaceClass
        InterfaceClass , InterfaceClasses           InterfaceClass , InterfaceClasses
     
InterfaceClass:   InterfaceClass:
        GlobalIdentifierList <>         Identifier
        Protection GlobalIdentifierList           Protection Identifier

Base classes are not limited to single identifeirs.

ProposedWebsite
  =  
Protection:   Protection:
        private           private
        package           package
        public           public
        export           export
     
ClassBody:   ClassBody:
        { }           { }
        { DeclDefsopt } <>"><>         { ClassBodyDeclarations }
     
    ClassBodyDeclarations:larations:
            ClassBodyDeclaration
            ClassBodyDeclaration ClassBodyDeclarations
  =  
  -+ ClassBodyDeclaration:
            Declaration
            Constructor
            Destructor
            StaticConstructor
            StaticDestructor
            Invariant
            UnitTest
            ClassAllocator
            ClassDeallocator

ClassDeclarations merged with DeclDefs.

ProposedWebsite
  =  
Constructor:   Constructor:
        this TemplateParametersopt Parameters MemberFunctionAttributesopt Constraintopt FunctionBody <>         this Parameters FunctionBody
        this ( this ) Constraintopt FunctionBody    

Constructors missing template functionality. Added postblit, maybe should be separated.

ProposedWebsite
  =  
Destructor:   Destructor:
        ~ this ( ) FunctionBody <>         ~this() FunctionBody
  =  
StaticConstructor:   StaticConstructor:
        static this ( ) FunctionBody <>         static this() FunctionBody
  =  
StaticDestructor:   StaticDestructor:
        static ~ this ( ) FunctionBody <>         static ~this() FunctionBody
  =  
SharedStaticConstructor:   SharedStaticConstructor:
        shared static this ( ) FunctionBody <>         shared static this() FunctionBody
  =  
SharedStaticDestructor:   SharedStaticDestructor:
        shared static ~ this ( ) FunctionBody <>         shared static ~this() FunctionBody
  =  

Added spaces to separate tokens.

ProposedWebsite
Invariant: = Invariant:
        invariant ( ) BlockStatement <>         invariant() BlockStatement
  =  
ClassAllocator:   ClassAllocator:
        new Parameters FunctionBody           new Parameters FunctionBody
     
ClassDeallocator:   ClassDeallocator:
        delete Parameters FunctionBody           delete Parameters FunctionBody
     
  -+  
     
AliasThis: = AliasThis:
        alias Identifier this;           alias Identifier this;
     
  -+  
     
    NewAnonClassExpression:
            new PerenArgumentListopt class PerenArgumentListopt SuperClassopt InterfaceClassesopt ClassBody
     
    PerenArgumentList:
            (ArgumentList)

NewAnonClassExpression already part of NewExpression.

ProposedWebsite
     
     
     
InterfaceDeclaration: = InterfaceDeclaration:
        interface Identifier BaseInterfaceListopt InterfaceBody <>         interface Identifier  InterfaceBody
        InterfaceTemplateDeclaration =         InterfaceTemplateDeclaration
        interface Identifier ; +-  
  =  
BaseInterfaceList:   BaseInterfaceList:
  -+         Empty
        : InterfaceClasses =         : InterfaceClasses

Baseclasses missing. Forward declaration allowed.

ProposedWebsite
     
InterfaceBody:   InterfaceBody:
        { DeclDefsopt } <>         { DeclDefs }

Declarations can be empty.

ProposedWebsite
     
     
     
EnumDeclaration: = EnumDeclaration:
        enum EnumTag EnumBody           enum EnumTag EnumBody
        enum EnumBody           enum EnumBody
        enum EnumTag : EnumBaseType EnumBody           enum EnumTag : EnumBaseType EnumBody
        enum : EnumBaseType EnumBody           enum : EnumBaseType EnumBody
        enum EnumTag ; +-  
        enum EnumInitializer ;    
        enum Type EnumInitializers ;    

Allow forward declarations and declaration "enum a = 1;" and "enum int b = 2;"

ProposedWebsite
  =  
EnumTag:   EnumTag:
        Identifier           Identifier
     
EnumBaseType:   EnumBaseType:
        Type           Type
     
EnumInitializers: +-  
        EnumInitializer    
        EnumInitializers , EnumInitializer    
     
EnumInitializer:    
        Identifier = AssignExpression    
     

forward declaration might not be needed with proper forward reference handling anymore.

ProposedWebsite
     
EnumBody: = EnumBody:
        ;           ;
        { EnumMembers }           { EnumMembers }
     
EnumMembers:   EnumMembers:
        EnumMember           EnumMember
        EnumMember ,           EnumMember ,
        EnumMember , EnumMembers           EnumMember , EnumMembers
     
EnumMember:   EnumMember:
        Identifier           Identifier
        Identifier = AssignExpression           Identifier = AssignExpression
        Type Identifier = AssignExpression           Type Identifier = AssignExpression
     
FunctionBody:   FunctionBody:
        BlockStatement           BlockStatement
        BodyStatement           BodyStatement
        InStatement BodyStatement           InStatement BodyStatement
        OutStatement BodyStatement           OutStatement BodyStatement
        InStatement OutStatement BodyStatement           InStatement OutStatement BodyStatement
        OutStatement InStatement BodyStatement           OutStatement InStatement BodyStatement
     
InStatement:   InStatement:
        in BlockStatement           in BlockStatement
     
OutStatement:   OutStatement:
        out BlockStatement           out BlockStatement
        out ( Identifier ) BlockStatement           out ( Identifier ) BlockStatement
     
BodyStatement:   BodyStatement:
        body BlockStatement           body BlockStatement
     

body statement might be missing in interface contracts. Would it be disirable to allow different orderings in contracts: in-body-out or body-in-out?

ProposedWebsite
     
ConditionalDeclaration:   ConditionalDeclaration:
        Condition DeclarationBlock <>         Condition CCDeclarationBlock
        Condition DeclarationBlock else DeclarationBlock           Condition CCDeclarationBlock else CCDeclarationBlock
            Condition : Declarations
     
    CCDeclarationBlock:
            Declaration
            { Declarations }
            { }
     
    Declarations:
            Declaration
            Declaration Declarations

The "Condition :" never existed and probably does not make good sense. The contents of a conditional block must not be limited to Declarations.

ProposedWebsite
  =  
ConditionalStatement:   ConditionalStatement:
        Condition NoScopeNonEmptyStatement           Condition NoScopeNonEmptyStatement
        Condition NoScopeNonEmptyStatement else NoScopeNonEmptyStatement           Condition NoScopeNonEmptyStatement else NoScopeNonEmptyStatement
     
Condition:   Condition:
        VersionCondition           VersionCondition
        DebugCondition           DebugCondition
        StaticIfCondition           StaticIfCondition
     
VersionCondition:   VersionCondition:
        version ( Integer )           version ( Integer )
        version ( Identifier )           version ( Identifier )
        version ( unittest )           version ( unittest )
     
VersionSpecification:   VersionSpecification:
        version = Identifier ;           version = Identifier ;
        version = Integer ;           version = Integer ;
     
DebugCondition:   DebugCondition:
        debug           debug
        debug ( Integer )           debug ( Integer )
        debug ( Identifier )           debug ( Identifier )
     
DebugSpecification:   DebugSpecification:
        debug = Identifier ;           debug = Identifier ;
        debug = Integer ;           debug = Integer ;
     
StaticIfCondition:   StaticIfCondition:
        static if ( AssignExpression )           static if ( AssignExpression )
     
StaticAssert:   StaticAssert:
        static assert ( AssignExpression ) ; <>         static assert ( AssignExpression );
        static assert ( AssignExpression , AssignExpression ) ;           static assert ( AssignExpression , AssignExpression );

ProposedWebsite
  =  
TemplateDeclaration:   TemplateDeclaration:
        template TemplateIdentifier ( TemplateParameterList ) Constraintopt { DeclDefs } <>         template TemplateIdentifier ( TemplateParameterList ) Constraint { DeclDefs }
  =  
TemplateIdentifier:   TemplateIdentifier:
        Identifier           Identifier
  +-  
TemplateParameters:    
        ( TemplateParameterList )    

ProposedWebsite
  =  
TemplateParameterList:   TemplateParameterList:
        TemplateParameter           TemplateParameter
        TemplateParameter ,           TemplateParameter ,
        TemplateParameter , TemplateParameterList           TemplateParameter , TemplateParameterList
     
TemplateParameter:   TemplateParameter:
        TemplateTypeParameter           TemplateTypeParameter
        TemplateValueParameter           TemplateValueParameter
        TemplateAliasParameter           TemplateAliasParameter
        TemplateTupleParameter           TemplateTupleParameter
        TemplateThisParameter           TemplateThisParameter
     
TemplateTupleParameter: +- TemplateTupleParameter:
        Identifier ...           Identifier ...
  =  
IdentifierOrTemplateInstance: +-  
        Identifier    
        TemplateInstance    

ProposedWebsite
  =  
TemplateInstance:   TemplateInstance:
        TemplateIdentifier ! ( TemplateArgumentList ) <>         TemplateIdentifier !( TemplateArgumentList )
        TemplateIdentifier ! TemplateSingleArgument =         TemplateIdentifier ! TemplateSingleArgument

ProposedWebsite
     
TemplateArgumentList:   TemplateArgumentList:
        TemplateArgument           TemplateArgument
        TemplateArgument ,           TemplateArgument ,
        TemplateArgument , TemplateArgumentList           TemplateArgument , TemplateArgumentList
     
TemplateArgument:   TemplateArgument:
        Type           Type
        AssignExpression           AssignExpression
        Symbol <>         Symbol
  =  
Symbol:   Symbol:
        SymbolTail           SymbolTail
        . SymbolTail           . SymbolTail
     

SymbolTail identical to IdentifierList

ProposedWebsite
  +-  
SymbolTail: = SymbolTail:
        Identifier           Identifier
        Identifier . SymbolTail           Identifier . SymbolTail
        TemplateInstance           TemplateInstance
        TemplateInstance . SymbolTail           TemplateInstance . SymbolTail
     
TemplateSingleArgument:   TemplateSingleArgument:
        Identifier           Identifier
        BasicTypeX           BasicTypeX
        CharacterLiteral           CharacterLiteral
        StringLiteral           StringLiteral
        IntegerLiteral           IntegerLiteral
        FloatLiteral           FloatLiteral
        true           true
        false           false
        null           null
        __FILE__           __FILE__
        __LINE__           __LINE__
     
TemplateTypeParameter:   TemplateTypeParameter:
        Identifier           Identifier
        Identifier TemplateTypeParameterSpecialization           Identifier TemplateTypeParameterSpecialization
        Identifier TemplateTypeParameterDefault           Identifier TemplateTypeParameterDefault
        Identifier TemplateTypeParameterSpecialization TemplateTypeParameterDefault           Identifier TemplateTypeParameterSpecialization TemplateTypeParameterDefault
     
TemplateTypeParameterSpecialization:   TemplateTypeParameterSpecialization:
        : Type           : Type
     
TemplateTypeParameterDefault:   TemplateTypeParameterDefault:
        = Type           = Type
     
  -+ TemplateThisParameter:
            this TemplateTypeParameter
     
TemplateValueParameter: = TemplateValueParameter:
        TemplateValueDeclaration <>         Declaration
        TemplateValueDeclaration TemplateValueParameterSpecialization           Declaration TemplateValueParameterSpecialization
        TemplateValueDeclaration TemplateValueParameterDefault           Declaration TemplateValueParameterDefault
        TemplateValueDeclaration TemplateValueParameterSpecialization TemplateValueParameterDefault           Declaration TemplateValueParameterSpecialization TemplateValueParameterDefault
  =  
TemplateValueDeclaration: +-  
        ParameterDeclarator /* without storage classes */    

ProposedWebsite
     
TemplateValueParameterSpecialization: = TemplateValueParameterSpecialization:
        : ConditionalExpression           : ConditionalExpression
     
TemplateValueParameterDefault:   TemplateValueParameterDefault:
        = __FILE__ /* already part of ConditionalExpression */ <>         = __FILE__
        = __LINE__ /* already part of ConditionalExpression */           = __LINE__
ProposedWebsite
        = ConditionalExpression =         = ConditionalExpression
     
TemplateAliasParameter:   TemplateAliasParameter:
        alias Typeopt Identifier TemplateAliasParameterSpecializationopt TemplateAliasParameterDefaultopt <>         alias Identifier TemplateAliasParameterSpecialization TemplateAliasParameterDefault

ProposedWebsite
  =  
TemplateAliasParameterSpecialization:   TemplateAliasParameterSpecialization:
        : Type           : Type
     
TemplateAliasParameterDefault:   TemplateAliasParameterDefault:
        = TypeOrExpression <>         = Type
  =  
  -+  
     

ProposedWebsite
     
ClassTemplateDeclaration: = ClassTemplateDeclaration:
        class Identifier ( TemplateParameterList ) Constraintopt BaseClassList_opt ClassBody <>         class Identifier ( TemplateParameterList ) BaseClassList ClassBody
  =  
StructTemplateDeclaration:   StructTemplateDeclaration:
        struct Identifier ( TemplateParameterList ) Constraintopt StructBody <>         struct Identifier ( TemplateParameterList ) Constraint StructBody
   
  =  
UnionTemplateDeclaration:   UnionTemplateDeclaration:
        union Identifier ( TemplateParameterList ) Constraintopt StructBody <>         union Identifier ( TemplateParameterList ) Constraint StructBody
  =  
InterfaceTemplateDeclaration:   InterfaceTemplateDeclaration:
        interface Identifier ( TemplateParameterList ) Constraintopt BaseInterfaceList_opt InterfaceBody <>         interface Identifier ( TemplateParameterList ) Constraint BaseInterfaceList InterfaceBody
  =  
TemplateMixinDeclaration:   TemplateMixinDeclaration:
        mixin template TemplateIdentifier ( TemplateParameterList ) Constraintopt { DeclDefs } <>         mixin template TemplateIdentifier ( TemplateParameterList ) Constraint { DeclDefs }
  =  
Constraint:   Constraint:
        if ( ConstraintExpression )           if ( ConstraintExpression )
     
ConstraintExpression:   ConstraintExpression:
        Expression           Expression

Contraints are optional.

ProposedWebsite
     
TemplateMixin:lateMixin: = TemplateMixin:
  <>         mixin TemplateIdentifier ;
        mixin GlobalIdentifierList MixinIdentifieropt ;           mixin TemplateIdentifier MixinIdentifier ;
        mixin Typeof . IdentifierList MixinIdentifier_opt ;           mixin TemplateIdentifier !( TemplateArgumentList ) ;
            mixin TemplateIdentifier !( TemplateArgumentList ) MixinIdentifier ;
  =  
  <> MixinIdentifier:
            Identifier

template mixin declarations can be referenced in other types and modules.

ProposedWebsite
     
     
Unittest:   UnitTest:
        unittest BlockStatement           unittest FunctionBody

No in/out/body for unittest.

ProposedWebsite
  =  
     
     
AsmInstruction:   AsmInstruction:
        Identifier : AsmInstruction           Identifier : AsmInstruction
        align IntegerExpression           align IntegerExpression
        even           even
        naked           naked
        db Operands           db Operands
        ds Operands           ds Operands
        di Operands           di Operands
        dl Operands           dl Operands
        df Operands           df Operands
        dd Operands           dd Operands
        de Operands           de Operands
        Opcode           Opcode
        Opcode Operands           Opcode Operands
     
Operands:   Operands:
        Operand           Operand
        Operand , Operands           Operand , Operands
     
IntegerExpression:   IntegerExpression:
        IntegerLiteral           IntegerLiteral
        Identifier           Identifier
     
Register:   Register:
        AL AH AX EAX           AL AH AX EAX
        BL BH BX EBX           BL BH BX EBX
        CL CH CX ECX           CL CH CX ECX
        DL DH DX EDX           DL DH DX EDX
        BP EBP           BP EBP
        SP ESP           SP ESP
        DI EDI           DI EDI
        SI ESI           SI ESI
        ES CS SS DS GS FS           ES CS SS DS GS FS
        CR0 CR2 CR3 CR4           CR0 CR2 CR3 CR4
        DR0 DR1 DR2 DR3 DR6 DR7           DR0 DR1 DR2 DR3 DR6 DR7
        TR3 TR4 TR5 TR6 TR7           TR3 TR4 TR5 TR6 TR7
        ST           ST
        ST(0) ST(1) ST(2) ST(3) ST(4) ST(5) ST(6) ST(7)           ST(0) ST(1) ST(2) ST(3) ST(4) ST(5) ST(6) ST(7)
        MM0 MM1 MM2 MM3 MM4 MM5 MM6 MM7           MM0 MM1 MM2 MM3 MM4 MM5 MM6 MM7
        XMM0 XMM1 XMM2 XMM3 XMM4 XMM5 XMM6 XMM7           XMM0 XMM1 XMM2 XMM3 XMM4 XMM5 XMM6 XMM7
     
     
Operand:   Operand:
        AsmExp           AsmExp
     
AsmExp:   AsmExp:
        AsmLogOrExp           AsmLogOrExp
        AsmLogOrExp ? AsmExp : AsmExp           AsmLogOrExp ? AsmExp : AsmExp
     
AsmLogOrExp:   AsmLogOrExp:
        AsmLogAndExp           AsmLogAndExp
        AsmLogOrExp || AsmLogAndExp <>         AsmLogAndExp || AsmLogAndExp
  =  
AsmLogAndExp:   AsmLogAndExp:
        AsmOrExp           AsmOrExp
        AsmLogAndExp && AsmOrExp <>         AsmOrExp && AsmOrExp
  =  
AsmOrExp:   AsmOrExp:
        AsmXorExp           AsmXorExp
        AsmOrExp | AsmXorExp <>         AsmXorExp | AsmXorExp
  =  
AsmXorExp:   AsmXorExp:
        AsmAndExp           AsmAndExp
        AsmXorExp ^ AsmAndExp <>         AsmAndExp ^ AsmAndExp
  =  
AsmAndExp:   AsmAndExp:
        AsmEqualExp           AsmEqualExp
        AsmAndExp & AsmEqualExp <>         AsmEqualExp & AsmEqualExp
  =  
AsmEqualExp:   AsmEqualExp:
        AsmRelExp           AsmRelExp
        AsmRelExp == AsmRelExp           AsmRelExp == AsmRelExp
        AsmRelExp != AsmRelExp           AsmRelExp != AsmRelExp
     
AsmRelExp:   AsmRelExp:
        AsmShiftExp           AsmShiftExp
        AsmShiftExp < AsmShiftExp           AsmShiftExp < AsmShiftExp
        AsmShiftExp <= AsmShiftExp           AsmShiftExp <= AsmShiftExp
        AsmShiftExp > AsmShiftExp           AsmShiftExp > AsmShiftExp
        AsmShiftExp >= AsmShiftExp           AsmShiftExp >= AsmShiftExp
     
AsmShiftExp:   AsmShiftExp:
        AsmAddExp           AsmAddExp
        AsmShiftExp << AsmAddExp <>         AsmAddExp << AsmAddExp
        AsmShiftExp >> AsmAddExp           AsmAddExp >> AsmAddExp
        AsmShiftExp >>> AsmAddExp           AsmAddExp >>> AsmAddExp
  =  
AsmAddExp:   AsmAddExp:
        AsmMulExp           AsmMulExp
        AsmAddExp + AsmMulExp <>         AsmMulExp + AsmMulExp
        AsmAddExp - AsmMulExp           AsmMulExp - AsmMulExp
  =  
AsmMulExp:   AsmMulExp:
        AsmBrExp           AsmBrExp
        AsmMulExp * AsmBrExp <>         AsmBrExp * AsmBrExp
        AsmMulExp / AsmBrExp           AsmBrExp / AsmBrExp
        AsmMulExp % AsmBrExp           AsmBrExp % AsmBrExp

Expression not recursive, so "1 + 2 + 3" would not be allowed.

ProposedWebsite
  =  
AsmBrExp:   AsmBrExp:
        AsmUnaExp           AsmUnaExp
        AsmBrExp [ AsmExp ]           AsmBrExp [ AsmExp ]
     
AsmUnaExp:   AsmUnaExp:
        AsmTypePrefix AsmExp           AsmTypePrefix AsmExp
        offsetof AsmExp           offsetof AsmExp
        seg AsmExp           seg AsmExp
        + AsmUnaExp           + AsmUnaExp
        - AsmUnaExp           - AsmUnaExp
        ! AsmUnaExp           ! AsmUnaExp
        ~ AsmUnaExp           ~ AsmUnaExp
        AsmPrimaryExp           AsmPrimaryExp
     
AsmPrimaryExp:   AsmPrimaryExp:
        IntegerLiteral           IntegerLiteral
        FloatLiteral           FloatLiteral
        __LOCAL_SIZE           __LOCAL_SIZE
        $           $
        Register           Register
        DotIdentifier           DotIdentifier
     
DotIdentifier:   DotIdentifier:
        Identifier           Identifier
        Identifier . DotIdentifier           Identifier . DotIdentifier
     
AsmTypePrefix:   AsmTypePrefix:
        near ptr           near ptr
        far ptr           far ptr
        byte ptr           byte ptr
        short ptr           short ptr
        int ptr           int ptr
        word ptr           word ptr
        dword ptr           dword ptr
        qword ptr           qword ptr
        float ptr           float ptr
        double ptr           double ptr
        real ptr           real ptr
  -+