B. Grammar

This appendix contains summaries of the lexical and syntactic grammars found in the main text, and of the grammar extensions for unsafe code. Grammar productions appear here in the same order that they appear in the main text.

B.1 Lexical Grammar

    input:
            input-section_opt

    input-section:
            input-section-part
            input-section  input-section-part

    input-section-part:
            input-elements_opt new-line
            pp-directive

    input-elements:
            input-element
            input-elements  input-element

    input-element:
            whitespace
            comment
            token

B.1.1 Line Terminators

    new-line:
            Carriage return character (U+000D)
            Line feed character (U+000A)
            Carriage return character (U+000D) followed by line feed character (U+000A)
            Next line character (U+0085)
            Line separator character (U+2028)
            Paragraph separator character (U+2029)

B.1.2 Comments

    comment:
            single-line-comment
            delimited-comment

    single-line-comment:
            //  input-characters_opt

    input-characters:
            input-character
            input-characters  input-character

    input-character:
            Any Unicode character except a new-line-character

    new-line-character:
            Carriage return character (U+000D)
            Line feed character (U+000A)
            Next line character (U+0085)
            Line separator character (U+2028)
            Paragraph separator character (U+2029)

    delimited-comment:
            /*  delimited-comment-text_opt        asterisks  /

    delimited-comment-text:
            delimited-comment-section
            delimited-comment-text  delimited-comment-section

    delimited-comment-section:
            /
            asterisks_opt  not-slash-or-asterisk

    asterisks:
            *
            asterisks  *

    not-slash-or-asterisk:
            Any Unicode character except / or *

B.1.3 White Space

    whitespace:
            Any character with Unicode class Zs
            Horizontal tab character (U+0009)
            Vertical tab character (U+000B)
            Form feed character (U+000C)

B.1.4 Tokens

    token:
            identifier
            keyword
            integer-literal
            real-literal
            character-literal
            string-literal
            operator-or-punctuator

B.1.5 Unicode Character Escape Sequences

    unicode-escape-sequence:
            u  hex-digit  hex-digit  hex-digit  hex-digit
            U  hex-digit  hex-digit  hex-digit  hex-digit  hex-digit  hex-digit  hex-digit  hex-digit

B.1.6 Identifiers

    identifier:
            available-identifier
            @  identifier-or-keyword

    available-identifier:
            An identifier-or-keyword that is not a keyword

    identifier-or-keyword:
            identifier-start-character  identifier-part-characters_opt

    identifier-start-character:
            letter-character
            _ (the underscore character U+005F)

    identifier-part-characters:
            identifier-part-character
            identifier-part-characters  identifier-part-character

    identifier-part-character:
            letter-character
            decimal-digit-character
            connecting-character
            combining-character
            formatting-character

    letter-character:
            A Unicode character of class Lu, Ll, Lt, Lm, Lo, or Nl
            A unicode-escape-sequence representing a character of class Lu, Ll, Lt, Lm, Lo, or Nl

    combining-character:
            A Unicode character of class Mn or Mc
            A unicode-escape-sequence representing a character of class Mn or Mc

    decimal-digit-character:
            A Unicode character of the class Nd
            A unicode-escape-sequence representing a character of class Nd

    connecting-character:
            A Unicode character of the class Pc
            A unicode-escape-sequence representing a character of class Pc

    formatting-character:
            A Unicode character of the class Cf
            A unicode-escape-sequence representing a character of class Cf

B.1.7 Keywords

    keyword: one of

B.1.8 Literals

    literal:
            boolean-literal
            integer-literal
            real-literal
            character-literal
            string-literal
            null-literal

    boolean-literal:
            true
            false

    integer-literal:
            decimal-integer-literal
            hexadecimal-integer-literal

    decimal-integer-literal:
            decimal-digits  integer-type-suffix_opt

    decimal-digits:
            decimal-digit
            decimal-digits  decimal-digit

    decimal-digit:  one of
            0  1  2  3  4  5  6  7  8  9

    integer-type-suffix: one of
            U  u  L  l  UL  Ul  uL  ul  LU  Lu  lU  lu

    hexadecimal-integer-literal:
            0x  hex-digits  integer-type-suffix_opt
            0X  hex-digits  integer-type-suffix_opt

    hex-digits:
            hex-digit
            hex-digits  hex-digit

    hex-digit:  one of
            0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F  a  b  c  d  e  f

    real-literal:
            decimal-digits  .  decimal-digits  exponent-part_opt  real-type-suffix_opt
            .  decimal-digits  exponent-part_opt  real-type-suffix_opt
            decimal-digits  exponent-part  real-type-suffix_opt
            decimal-digits  real-type-suffix

    exponent-part:
            e  sign_opt        decimal-digits
            E  sign_opt  decimal-digits

    sign:  one of
            +  -

    real-type-suffix:  one of
            F  f  D  d  M  m

    character-literal:
            '  character  '

    character:
            single-character
            simple-escape-sequence
            hexadecimal-escape-sequence
            unicode-escape-sequence

    single-character:
            Any character except ' (U+0027), (U+005C), and new-line-character

    simple-escape-sequence:  one of
            '  "  \    a    f           v

    hexadecimal-escape-sequence:
            x  hex-digit  hex-digit_opt  hex-digit_opt  hex-digit_opt

    string-literal:
            regular-string-literal
            verbatim-string-literal

    regular-string-literal:
            "  regular-string-literal-characters_opt  "

    regular-string-literal-characters:
            regular-string-literal-character
            regular-string-literal-characters  regular-string-literal-character

    regular-string-literal-character:
            single-regular-string-literal-character
            simple-escape-sequence
            hexadecimal-escape-sequence
            unicode-escape-sequence

    single-regular-string-literal-character:
            Any character except " (U+0022), (U+005C), and new-line-character

    verbatim-string-literal:
            @"  verbatim -string-literal-characters_opt  "

    verbatim-string-literal-characters:
            verbatim-string-literal-character
            verbatim-string-literal-characters  verbatim-string-literal-character

    verbatim-string-literal-character:
            single-verbatim-string-literal-character
            quote-escape-sequence

    single-verbatim-string-literal-character:
            any character except "

    quote-escape-sequence:
            ""

    null-literal:
            null

B.1.9 Operators and Punctuators

B.1.10 Preprocessing Directives

    pp-directive:
            pp-declaration
            pp-conditional
            pp-line
            pp-diagnostic
            pp-region
            pp-pragma

    conditional-symbol:
            Any identifier-or-keyword except true or false

    pp-expression:
            whitespace_opt  pp-or-expression  whitespace_opt

    pp-or-expression:
            pp-and-expression
            pp-or-expression  whitespace_opt  ||  whitespace_opt  pp-and-expression

    pp-and-expression:
            pp-equality-expression
            pp-and-expression  whitespace_opt  &&  whitespace_opt  pp-equality-expression

    pp-equality-expression:
            pp-unary-expression
            pp-equality-expression  whitespace_opt  ==  whitespace_opt  pp-unary-expression
            pp-equality-expression  whitespace_opt  !=  whitespace_opt  pp-unary-expression

    pp-unary-expression:
            pp-primary-expression
            !  whitespace_opt  pp-unary-expression

    pp-primary-expression:
            true
            false
            conditional-symbol
            (  whitespace_opt  pp-expression  whitespace_opt  )

    pp-declaration:
            whitespace_opt  #  whitespace_opt  define  whitespace  conditional-symbol  pp-new-line
            whitespace_opt  #  whitespace_opt  undef  whitespace  conditional-symbol  pp-new-line

    pp-new-line:
            whitespace_opt  single-line-comment_opt  new-line

    pp-conditional:
            pp-if-section  pp-elif-sections_opt  pp-else-section_opt  pp-endif

    pp-if-section:
            whitespace_opt  #  whitespace_opt  if  whitespace  pp-expression  pp-new-line
            conditional-section_opt

    pp-elif-sections:
            pp-elif-section
            pp-elif-sections  pp-elif-section

    pp-elif-section:
            whitespace_opt  #  whitespace_opt  elif  whitespace  pp-expression  pp-new-line
            conditional-section_opt

    pp-else-section:
            whitespace_opt  #  whitespace_opt  else  pp-new-line  conditional-section_opt

    pp-endif:
            whitespace_opt  #  whitespace_opt  endif  pp-new-line

    conditional-section:
            input-section
            skipped-section

    skipped-section:
            skipped-section-part
            skipped-section  skipped-section-part

    skipped-section-part:
            skipped-characters_opt  new-line
            pp-directive

    skipped-characters:
            whitespace_opt  not-number-sign  input-characters_opt

    not-number-sign:
            Any input-character except #

    pp-diagnostic:
            whitespace_opt  #  whitespace_opt  error  pp-message
            whitespace_opt  #  whitespace_opt  warning  pp-message

    pp-message:
            new-line:
            whitespace  input-characters_opt  new-line

    pp-region:
            pp-start-region  conditional-section_opt  pp-end-region

    pp-start-region:
            whitespace_opt  #  whitespace_opt  region  pp-message

    pp-end-region:
            whitespace_opt  #  whitespace_opt  endregion  pp-message

    pp-line:
            whitespace_opt  #  whitespace_opt  line  whitespace        line-indicator        pp-new-line

    line-indicator:
            decimal-digits  whitespace        file-name
            decimal-digits
            default
            hidden

    file-name:
            "  file-name-characters  "

    file-name-characters:
            file-name-character
            file-name-characters  file-name-character

    file-name-character:
            Any input-character except "

    pp-pragma:
            whitespace_opt  #  whitespace_opt  pragma  whitespace  pragma-body  pp-new-line

    pragma-body:
            pragma-warning-body

    pragma-warning-body
            warning  whitespace  warning-action
            warning  whitespace  warning-action  whitespace  warning-list

    warning-action:
            disable
            restore

    warning-list:
            decimal-digits
            warning-list  whitespace_opt  ,  whitespace_opt  decimal-digits

B.2 Syntactic Grammar

B.2.1 Basic Concepts

    namespace-name:
            namespace-or-type-name

    type-name:
            namespace-or-type-name

    namespace-or-type-name:
            identifier  type-argument-list_opt
            namespace-or-type-name  .  identifier  type-argument-list_op
              qualified-alias-member

B.2.2 Types

    type:
            value-type
            reference-type
            type-parameter

    value-type:
            struct-type
            enum-type

    struct-type:
            type-name
            simple-type
            nullable-type

    simple-type:
            numeric-type
            bool

    numeric-type:
            integral-type
            floating-point-type
            decimal

    integral-type:
            sbyte
            byte
            short
            ushort
            int
            uint
            long
            ulong
            char

    floating-point-type:
            float
            double

    nullable-type:
            non-nullable-value-type  ?

    non-nullable-value-type:
            type

    enum-type:
            type-name

    reference-type:
            class-type
            interface-type
            array-type
            delegate-type

    class-type:
            type-name
            object
            string

    interface-type:
            type-name

    array-type:
            non-array-type  rank-specifiers

    non-array-type:
            type

    rank-specifiers:
            rank-specifier
            rank-specifiers  rank-specifier

    rank-specifier:
            [  dim-separators_opt  ]
            dim-separators
            ,
            dim-separators  ,

    delegate-type:
            type-name

    type-argument-list:
            <  type-arguments  >

    type-arguments:
            type-argument
            type-arguments  ,  type-argument

    type-argument:
            type

    type-parameter:
            identifier

B.2.3 Variables

    variable-reference:
            expression

B.2.4 Expressions

    argument-list:
            argument
            argument-list  ,  argument

    argument:
            expression
            ref  variable-reference
            out  variable-reference

    primary-expression:
            primary-no-array-creation-expression
            array-creation-expression

    primary-no-array-creation-expression:
            literal
            simple-name
            parenthesized-expression
            member-access
            invocation-expression
            element-access
            this-access
            base-access
            post-increment-expression
            post-decrement-expression
            object-creation-expression
            delegate-creation-expression
            anonymous-object-creation-expression
            typeof-expression
            checked-expression
            unchecked-expression
            default-value-expression
            anonymous-method-expression

    simple-name:
            identifier  type-argument-list_opt

    parenthesized-expression:
            (  expression  )

    member-access:
            primary-expression  .  identifier  type-argument-list_opt
            predefined-type  .  identifier  type-argument-list_opt
            qualified-alias-member  .  identifier

    predefined-type:  one of

    invocation-expression:
            primary-expression  (  argument-list_opt  )

    element-access:
            primary-no-array-creation-expression  [  expression-list  ]

    expression-list:
            expression
            expression-list  ,  expression

    this-access:
            this

    base-access:
            base  .  identifier
            base  [  expression-list  ]

    post-increment-expression:
            primary-expression  ++

    post-decrement-expression:
            primary-expression  --

    object-creation-expression:
            new  type  (  argument-list_opt  )  object-or-collection-initializer_opt
            new  type  object-or-collection-initializer

    object-or-collection-initializer:
            object-initializer
            collection-initializer

    object-initializer:
            {  member-initializer-list_opt  }
            {  member-initializer-list  ,  }

    member-initializer-list:
            member-initializer
            member-initializer-list  ,  member-initializer

    member-initializer:
            identifier  =        initializer-value

    initializer-value:
            expression
            object-or-collection-initializer

    collection-initializer:
            {  element-initializer-list  }
            {  element-initializer-list  ,  }

    element-initializer-list:
            element-initializer
            element-initializer-list  ,  element-initializer

    element-initializer:
            non-assignment-expression
            {  expression-list  }

    array-creation-expression:
            new  non-array-type  [  expression-list  ]  rank-specifiers_opt  array-initializer_opt
            new  array-type  array-initializer
            new  rank-specifier  array-initializer

    delegate-creation-expression:
            new  delegate-type  (  expression  )

    anonymous-object-creation-expression:
            new  anonymous-object-initializer

    anonymous-object-initializer:
            {  member-declarator-list_opt  }
            {  member-declarator-list  ,  }

    member-declarator-list:
            member-declarator
            member-declarator-list  ,  member-declarator

    member-declarator:
            simple-name
            member-access
            identifier  =  expression

    typeof-expression:
            typeof  (  type  )
            typeof  (  unbound-type-name  )
            typeof ( void )

    unbound-type-name:
            identifier  generic-dimension-specifier_opt
            identifier  ::  identifier  generic-dimension-specifier_opt
            unbound-type-name  .  identifier  generic-dimension-specifier_opt

    generic-dimension-specifier:
            <  commas_opt  >

    commas:
            ,
            commas  ,

    checked-expression:
            checked  (  expression  )

    unchecked-expression:
            unchecked  (  expression  )

    default-value-expression:
            default  (  type  )

    unary-expression:
            primary-expression
            +  unary-expression
            -  unary-expression
            !  unary-expression
            ~unary-expression
            pre-increment-expression
            pre-decrement-expression
            cast-expression

    pre-increment-expression:
            ++  unary-expression

    pre-decrement-expression:
            --  unary-expression

    cast-expression:
            (  type  )  unary-expression

    multiplicative-expression:
            unary-expression
            multiplicative-expression  *  unary-expression
            multiplicative-expression  /  unary-expression
            multiplicative-expression  %  unary-expression

    additive-expression:
            multiplicative-expression
            additive-expression  +  multiplicative-expression
            additive-expression  –  multiplicative-expression

    shift-expression:
            additive-expression
            shift-expression  <<  additive-expression
            shift-expression  right-shift  additive-expression

    relational-expression:
            shift-expression
            relational-expression  <  shift-expression
            relational-expression  >  shift-expression
            relational-expression  <=  shift-expression
            relational-expression  >=  shift-expression
            relational-expression  is  type
            relational-expression  as  type

    equality-expression:
            relational-expression
            equality-expression  ==  relational-expression
            equality-expression  !=  relational-expression

    and-expression:
            equality-expression
            and-expression  &  equality-expression

    exclusive-or-expression
            and-expression
            exclusive-or-expression  ^  and-expression

    inclusive-or-expression:
            exclusive-or-expression:
            inclusive-or-expression  |  exclusive-or-expression

    conditional-and-expression:
            inclusive-or-expression
            conditional-and-expression  &&  inclusive-or-expression

    conditional-or-expression:
            conditional-and-expression
            conditional-or-expression  ||  conditional-and-expression

    null-coalescing-expression:
            conditional-or-expression
            conditional-or-expression  ??  null-coalescing-expression

    conditional-expression:
            null-coalescing-expression
            null-coalescing-expression  ?  expression  :  expression

    lambda-expression:
            anonymous-function-signature  =>  anonymous-function-body

    anonymous-method-expression:
            delegate  explicit-anonymous-function-signature_opt  block

    anonymous-function-signature:
            explicit-anonymous-function-signature
            implicit-anonymous-function-signature

    explicit-anonymous-function-signature:
            (  explicit-anonymous-function-parameter-list_opt  )

    explicit-anonymous-function-parameter-list:
            explicit-anonymous-function-parameter
            explicit-anonymous-function-parameter-list  ,  explicit-anonymous-function-parameter

    explicit-anonymous-function-parameter:
            anonymous-function-parameter-modifier_opt  type  identifier

    anonymous-function-parameter-modifier:
            ref
            out

    implicit-anonymous-function-signature:
            (  implicit-anonymous-function-parameter-list_opt  )
            implicit-anonymous-function-parameter

    implicit-anonymous-function-parameter-list
            implicit-anonymous-function-parameter
            implicit-anonymous-function-parameter-list  ,  implicit-anonymous-function-parameter

    implicit-anonymous-function-parameter:
            identifier

    anonymous-function-body:
            expression
            block

    query-expression:
            from-clause  query-body

    from-clause:
            from  type_opt  identifier  in  expression

    query-body:
            query-body-clauses_opt  select-or-group-clause  query-continuation_opt

    query-body-clauses:
            query-body-clause
            query-body-clauses  query-body-clause

    query-body-clause:
            from-clause
            let-clause
            where-clause
            join-clause
            join-into-clause
            orderby-clause

    let-clause:
            let  identifier  =  expression

    where-clause:
            where  boolean-expression

    join-clause:
            join  type_opt  identifier  in  expression  on  expression  equals  expression

    join-into-clause:
            join  type_opt  identifier  in  expression  on  expression  equals  expression  
            into  identifier

    orderby-clause:
            orderby  orderings

    orderings:
            ordering
            orderings  ,  ordering

    ordering:
            expression  ordering-direction_opt

    ordering-direction:
            ascending
            descending

    select-or-group-clause:
            select-clause
            group-clause

    select-clause:
            select  expression

    group-clause:
            group  expression  by  expression

    query-continuation:
            into  identifier  query-body

    assignment:
            unary-expression  assignment-operator  expression

    assignment-operator:
            =
            +=
            -=
            *=
            /=
            %=
            &=
            |=
            ^=
            <<=
            right-shift-assignment

    expression:
            non-assignment-expression
            assignment

    non-assignment-expression:
            conditional-expression
            lambda-expression
            query-expression

    constant-expression:
            expression

    boolean-expression:
            expression

B.2.5 Statements

    statement:
            labeled-statement
            declaration-statement
            embedded-statement

    embedded-statement:
            block
            empty-statement
            expression-statement
            selection-statement
            iteration-statement
            jump-statement
            try-statement
            checked-statement
            unchecked-statement
            lock-statement
            using-statement
            yield-statement

    block:
            {  statement-list_opt  }

    statement-list:
            statement
            statement-list  statement

    empty-statement:
            ;

    labeled-statement:
            identifier  :  statement

    declaration-statement:
            local-variable-declaration  ;
            local-constant-declaration  ;

    local-variable-declaration
            local-variable-type  local-variable-declarators

    local-variable-type:
            type
            var

    local-variable-declarators:
            local-variable-declarator
            local-variable-declarators  ,  local-variable-declarator

    local-variable-declarator:
            identifier
            identifier  =        local-variable-initializer

    local-variable-initializer:
            expression
            array-initializer

    local-constant-declaration:
            const  type  constant-declarators

    constant-declarators:
            constant-declarator
            constant-declarators  ,  constant-declarator

    constant-declarator:
            identifier  =  constant-expression

    expression-statement:
            statement-expression  ;

    statement-expression:
            invocation-expression
            object-creation-expression
            assignment
            post-increment-expression
            post-decrement-expression
            pre-increment-expression
            pre-decrement-expression

    selection-statement:
            if-statement
            switch-statement

    if-statement:
            if  (  boolean-expression  )  embedded-statement
            if  (  boolean-expression  )  embedded-statement  else  embedded-statement

    switch-statement:
            switch  (  expression  )  switch-block

    switch-block:
            {  switch-sections_opt  }

    switch-sections:
            switch-section
            switch-sections  switch-section

    switch-section:
            switch-labels  statement-list

    switch-labels:
            switch-label
            switch-labels  switch-label

    switch-label:
            case  constant-expression  :
            default  :

    iteration-statement:
            while-statement
            do-statement
            for-statement
            foreach-statement

    while-statement:
            while  (  boolean-expression  )  embedded-statement

    do-statement:
            do  embedded-statement  while  (  boolean-expression  )  ;

    for-statement:
            for  (  for-initializer_opt  ;  for-condition_opt  ;  for-iterator_opt  )  embedded-statement

    for-initializer:
            local-variable-declaration:
            statement-expression-list

    for-condition:
            boolean-expression

    for-iterator:
            statement-expression-list

    statement-expression-list:
            statement-expression
            statement-expression-list  ,  statement-expression

    foreach-statement:
            foreach  (  local-variable-type  identifier  in  expression  )  embedded-statement

    jump-statement:
            break-statement
            continue-statement
            goto-statement
            return-statement
            throw-statement

    break-statement:
            break  ;

    continue-statement:
            continue  ;

    goto-statement:
            goto  identifier  ;
            goto  case  constant-expression  ;
            goto  default  ;

    return-statement:
            return  expression_opt  ;

    throw-statement:
            throw  expression_opt  ;

    try-statement:
            try  block  catch-clauses
            try  block  finally-clause
            try  block  catch-clauses  finally-clause

    catch-clauses:
            specific-catch-clauses  general-catch-clause_opt
            specific-catch-clauses_opt  general-catch-clause

    specific-catch-clauses:
            specific-catch-clause
            specific-catch-clauses  specific-catch-clause

    specific-catch-clause:
            catch  (  class-type  identifier_opt  )  block

    general-catch-clause:
            catch  block

    finally-clause:
            finally  block

    checked-statement:
            checked  block

    unchecked-statement:
            unchecked  block

    lock-statement:
            lock  (  expression  )  embedded-statement

    using-statement:
            using  (  resource-acquisition  )  embedded-statement

    resource-acquisition:
            local-variable-declaration
            expression

    yield-statement:
            yield  return  expression  ;
            yield  break  ;

B.2.6 Namespaces

    compilation-unit:
            extern-alias-directives_opt  using-directives_opt  global-attributes_opt
                          namespace-member-declarations_opt

    namespace-declaration:
            namespace  qualified-identifier  namespace-body  ;_opt

    qualified-identifier:
            identifier
            qualified-identifier  .  identifier

    namespace-body:
            {  extern-alias-directives_opt  using-directives_opt  namespace-member-declarations_opt  }

    extern-alias-directives:
            extern-alias-directive
            extern-alias-directives  extern-alias-directive

    extern-alias-directive:
            extern  alias  identifier  ;

    using-directives:
            using-directive
            using-directives  using-directive

    using-directive:
            using-alias-directive
            using-namespace-directive

    using-alias-directive:
            using  identifier  =  namespace-or-type-name  ;

    using-namespace-directive:
            using  namespace-name  ;

    namespace-member-declarations:
            namespace-member-declaration
            namespace-member-declarations  namespace-member-declaration

    namespace-member-declaration:
            namespace-declaration
            type-declaration

    type-declaration:
            class-declaration
            struct-declaration
            interface-declaration
            enum-declaration
            delegate-declaration

    qualified-alias-member:
            identifier  ::  identifier  type-argument-list_opt

B.2.7 Classes

    class-declaration:
            attributes_opt  class-modifiers_opt  partial_opt  class  identifier  type-parameter-list_opt
                          class-base_opt  type-parameter-constraints-clauses_opt  class-body;_opt

    class-modifiers:
            class-modifier
            class-modifiers  class-modifier

    class-modifier:
            new
            public
            protected
            internal
            private
            abstract
            sealed
            static

    type-parameter-list:
            <  type-parameters  >

    type-parameters:
            attributes_opt  type-parameter
            type-parameters  ,  attributes_opt  type-parameter

    type-parameter:
            identifier

    class-base:
            :  class-type
            :  interface-type-list
            :  class-type  ,  interface-type-list

    interface-type-list:
            interface-type
            interface-type-list  ,  interface-type

    type-parameter-constraints-clauses:
            type-parameter-constraints-clause
            type-parameter-constraints-clauses  type-parameter-constraints-clause

    type-parameter-constraints-clause:
            where  type-parameter  :  type-parameter-constraints

    type-parameter-constraints:
            primary-constraint
            secondary-constraints
            constructor-constraint
            primary-constraint  ,  secondary-constraints
            primary-constraint  ,  constructor-constraint
            secondary-constraints  ,  constructor-constraint
            primary-constraint  ,  secondary-constraints  ,  constructor-constraint

    primary-constraint:
            class-type
            class
            struct

    secondary-constraints:
            interface-type
            type-parameter
            secondary-constraints  ,  interface-type
            secondary-constraints  ,  type-parameter

    constructor-constraint:
            new  (  )

    class-body:
            {  class-member-declarations_opt  }

    class-member-declarations:
            class-member-declaration
            class-member-declarations  class-member-declaration

    class-member-declaration:
            constant-declaration
            field-declaration
            method-declaration
            property-declaration
            event-declaration
            indexer-declaration
            operator-declaration
            constructor-declaration
            destructor-declaration
            static-constructor-declaration
            type-declaration

    constant-declaration:
            attributes_opt  constant-modifiers_opt  const  type  constant-declarators  ;

    constant-modifiers:
            constant-modifier
            constant-modifiers  constant-modifier

    constant-modifier:
            new
            public
            protected
            internal
            private

    constant-declarators:
            constant-declarator
            constant-declarators  ,  constant-declarator

    constant-declarator:
            identifier  =  constant-expression

    field-declaration:
            attributes_opt  field-modifiers_opt  type  variable-declarators  ;

    field-modifiers:
            field-modifier
            field-modifiers  field-modifier

    field-modifier:
            new
            public
            protected
            internal
            private
            static
            readonly
            volatile

    variable-declarators:
            variable-declarator
            variable-declarators  ,  variable-declarator

    variable-declarator:
            identifier
            identifier  =  variable-initializer

    variable-initializer:
            expression
            array-initializer

    method-declaration:
            method-header  method-body

    method-header:
            attributes_opt  method-modifiers_opt  partial_opt  return-type  member-name  
                  type-parameter-list_opt
                        (  formal-parameter-list_opt  )  type-parameter-constraints-clauses_opt

    method-modifiers:
            method-modifier
            method-modifiers  method-modifier

    method-modifier:
            new
            public
            protected
            internal
            private
            static
            virtual
            sealed
            override
            abstract
            extern

    return-type:
            type
            void

    member-name:
            identifier
            interface-type  .  identifier

    method-body:
            block
            ;

    formal-parameter-list:
            fixed-parameters
            fixed-parameters  ,  parameter-array
            parameter-array

    fixed-parameters:
            fixed-parameter
            fixed-parameters  ,  fixed-parameter

    fixed-parameter:
            attributes_opt  parameter-modifier_opt  type  identifier

    parameter-modifier:
            ref
            out
            this

    parameter-array:
            attributes_opt  params  array-type  identifier

    property-declaration:
            attributes_opt  property-modifiers_opt  type  member-name  {  accessor-declarations  }

    property-modifiers:
            property-modifier
            property-modifiers  property-modifier

    property-modifier:
            new
            public
            protected
            internal
            private
            static
            virtual
            sealed
            override
            abstract
            extern

    member-name:
            identifier
            interface-type  .  identifier

    accessor-declarations:
            get-accessor-declaration  set-accessor-declaration_opt
            set-accessor-declaration  get-accessor-declaration_opt

    get-accessor-declaration:
            attributes_opt  accessor-modifier_opt  get  accessor-body

    set-accessor-declaration:
            attributes_opt  accessor-modifier_opt  set  accessor-body

    accessor-modifier:
            protected
            internal
            private
            protected  internal
            internal  protected

    accessor-body:
            block
            ;

    event-declaration:
            attributes_opt  event-modifiers_opt  event  type  variable-declarators  ;
            attributes_opt  event-modifiers_opt  event  type  member-name  {  event-accessor-declarations  }

    event-modifiers:
            event-modifier
            event-modifiers  event-modifier

    event-modifier:
            new
            public
            protected
            internal
            private
            static
            virtual
            sealed
            override
            abstract
            extern

    event-accessor-declarations:
            add-accessor-declaration  remove-accessor-declaration
            remove-accessor-declaration  add-accessor-declaration

    add-accessor-declaration:
            attributes_opt  add  block

    remove-accessor-declaration:
            attributes_opt  remove  block

    indexer-declaration:
            attributes_opt  indexer-modifiers_opt  indexer-declarator  {  accessor-declarations  }

    indexer-modifiers:
            indexer-modifier
            indexer-modifiers  indexer-modifier

    indexer-modifier:
            new
            public
            protected
            internal
            private
            virtual
            sealed
            override
            abstract
            extern

    indexer-declarator:
            type  this  [  formal-parameter-list  ]
            type  interface-type  .  this  [  formal-parameter-list  ]

    operator-declaration:
            attributes_opt  operator-modifiers  operator-declarator  operator-body

    operator-modifiers:
            operator-modifier
            operator-modifiers  operator-modifier

    operator-modifier:
            public
            static
            extern

    operator-declarator:
            unary-operator-declarator
            binary-operator-declarator
            conversion-operator-declarator

    unary-operator-declarator:
            type  operator  overloadable-unary-operator  (  type  identifier  )

    overloadable-unary-operator: one of
            +  -  !  ~  ++  --  true  false

    binary-operator-declarator:
            type  operator  overloadable-binary-operator  (  type  identifier  ,  type  identifier  )

    overloadable-binary-operator:
            +
            -
            *
            /
            %
            &
            |
            ^
            <<
            right-shift
            ==
            !=
            >
            <
            >=
            <=

    conversion-operator-declarator:
            implicit  operator  type  (  type  identifier  )
            explicit  operator  type  (  type  identifier  )

    operator-body:
            block
            ;

    constructor-declaration:
            attributes_opt  constructor-modifiers_opt  constructor-declarator  constructor-body

    constructor-modifiers:
            constructor-modifier
            constructor-modifiers  constructor-modifier

    constructor-modifier:
            public:
            protected
            internal
            private
            extern

    constructor-declarator:
            identifier  (  formal-parameter-list_opt  )  constructor-initializer_opt

    constructor-initializer:
            :  base  (  argument-list_opt  )
            :  this  (  argument-list_opt  )

    constructor-body:
            block
            ;

    static-constructor-declaration:
            attributes_opt  static-constructor-modifiers  identifier  (  )  static-constructor-body

    static-constructor-modifiers:
            extern_opt static
            static extern_opt

    static-constructor-body:
            block
            ;

    destructor-declaration:
            attributes_opt  extern_opt  ~  identifier  (  )  destructor-body

    destructor-body:
            block
            ;

B.2.8 Structs

    struct-declaration:
            attributes_opt  struct-modifiers_opt  partial_opt  struct  identifier  type-parameter-list_opt
                          struct-interfaces_opt  type-parameter-constraints-clauses_opt  struct-body  ;_opt

    struct-modifiers:
            struct-modifier
            struct-modifiers  struct-modifier

    struct-modifier:
            new
            public
            protected
            internal
            private

    struct-interfaces:
            :  interface-type-list

    struct-body:
            {  struct-member-declarations_opt  }

    struct-member-declarations:
            struct-member-declaration
            struct-member-declarations  struct-member-declaration

    struct-member-declaration:
            constant-declaration
            field-declaration
            method-declaration
            property-declaration
            event-declaration
            indexer-declaration
            operator-declaration
            constructor-declaration
            static-constructor-declaration
            type-declaration

B.2.9 Arrays

    array-type:
            non-array-type  rank-specifiers

    non-array-type:
            type

    rank-specifiers:
            rank-specifier
            rank-specifiers  rank-specifier

    rank-specifier:
            [  dim-separators_opt  ]

    dim-separators:
            ,
            dim-separators  ,

    array-initializer:
            {  variable-initializer-list_opt  }
            {  variable-initializer-list  ,  }

    variable-initializer-list:
            variable-initializer
            variable-initializer-list  ,  variable-initializer

    variable-initializer:
            expression
            array-initializer

B.2.10 Interfaces

    interface-declaration:
            attributes_opt  interface-modifiers_opt  partial_opt  interface  identifier  type-parameter-list_opt
                          interface-base_opt  type-parameter-constraints-clauses_opt  interface-body  ;_opt

    interface-modifiers:
            interface-modifier
            interface-modifiers  interface-modifier

    interface-modifier:
            new
            public
            protected
            internal
            private

    interface-base:
            :  interface-type-list

    interface-body:
            {  interface-member-declarations_opt  }

    interface-member-declarations:
            interface-member-declaration
            interface-member-declarations  interface-member-declaration

    interface-member-declaration:
            interface-method-declaration
            interface-property-declaration
            interface-event-declaration
            interface-indexer-declaration

    interface-method-declaration:
            attributes_opt  new_opt  return-type  identifier  type-parameter-list
                          (  formal-parameter-list_opt  )  type-parameter-constraints-clauses_opt  ;

    interface-property-declaration:
            attributes_opt  new_opt  type  identifier  {  interface-accessors  }

    interface-accessors:
            attributes_opt  get  ;
            attributes_opt  set  ;
            attributes_opt  get  ;  attributes_opt  set  ;
            attributes_opt  set  ;  attributes_opt  get  ;

    interface-event-declaration:
            attributes_opt  new_opt  event  type  identifier  ;

    interface-indexer-declaration:
            attributes_opt  new_opt  type  this  [  formal-parameter-list  ]  {  interface-accessors  }

B.2.11 Enums

    enum-declaration:
            attributes_opt  enum-modifiers_opt  enum  identifier  enum-base_opt  enum-body  ;_opt

    enum-base:
            :  integral-type

    enum-body:
            {  enum-member-declarations_opt  }
            {  enum-member-declarations  ,  }

    enum-modifiers:
            enum-modifier
            enum-modifiers  enum-modifier

    enum-modifier:
            new
            public
            protected
            internal
            private

    enum-member-declarations:
            enum-member-declaration
            enum-member-declarations  ,  enum-member-declaration

    enum-member-declaration:
            attributes_opt  identifier:
            attributes_opt  identifier  =  constant-expression

B.2.12 Delegates

    delegate-declaration:
            attributes_opt  delegate-modifiers_opt  delegate  return-type  identifier
                    type-parameter-list_opt  
                         (  formal-parameter-list_opt  )  type-parameter-constraints-clauses_opt  ;

    delegate-modifiers:
            delegate-modifier
            delegate-modifiers  delegate-modifier

    delegate-modifier:
            new
            public
            protected
            internal
            private

B.2.13 Attributes

    global-attributes:
            global-attribute-sections

    global-attribute-sections:
            global-attribute-section
            global-attribute-sections  global-attribute-section

    global-attribute-section:
            [  global-attribute-target-specifier  attribute-list  ]
            [  global-attribute-target-specifier  attribute-list  ,  ]

    global-attribute-target-specifier:
            global-attribute-target  :

    global-attribute-target:
            assembly
            module

    attributes:
            attribute-sections

    attribute-sections:
            attribute-section
            attribute-sections  attribute-section

    attribute-section:
            [  attribute-target-specifier_opt  attribute-list  ]
            [  attribute-target-specifier_opt  attribute-list  ,  ]

    attribute-target-specifier:
            attribute-target  :

    attribute-target:
            field
            event
            method
            param
            property
            return
            type

    attribute-list:
            attribute
            attribute-list  ,  attribute

    attribute:
            attribute-name  attribute-arguments_opt

    attribute-name:
            type-name

    attribute-arguments:
            (  positional-argument-list_opt  )
            (  positional-argument-list  ,  named-argument-list  )
            (  named-argument-list  )

    positional-argument-list:
            positional-argument
            positional-argument-list  ,  positional-argument

    positional-argument:
            attribute-argument-expression

    named-argument-list:
            named-argument
            named-argument-list  ,  named-argument

    named-argument:
            identifier  =  attribute-argument-expression

    attribute-argument-expression:
            expression

B.3 Grammar Extensions for Unsafe Code

    class-modifier:
            …
            unsafe

    struct-modifier:
            …
            unsafe

    interface-modifier:
            …
            unsafe

    delegate-modifier:
            …
            unsafe

    field-modifier:
            …
            unsafe

    method-modifier:
            …
            unsafe

    property-modifier:
            …
            unsafe

    event-modifier:
            …
            unsafe

    indexer-modifier:
            …
            unsafe

    operator-modifier:
            …
            unsafe

    constructor-modifier:
            …
            unsafe

    destructor-declaration:
            attributes_opt  extern_opt  unsafe_opt  ~  identifier  (  )  destructor-body
            attributes_opt  unsafe_opt  extern_opt  ~  identifier  (  )  destructor-body

    static-constructor-modifiers:
            extern_opt  unsafe_opt  static
            unsafe_opt  extern_opt  static
            extern_opt  static  unsafe_opt
            unsafe_opt  static  extern_opt
            static  extern_opt  unsafe_opt
            static  unsafe_opt  extern_opt

    embedded-statement:
            …
            unsafe-statement

    unsafe-statement:
            unsafe  block

    type:
            …
            pointer-type

    pointer-type:
            unmanaged-type  *
            void  *

    unmanaged-type:
            type

    primary-no-array-creation-expression:
            …
            pointer-member-access
            pointer-element-access
            sizeof-expression

    unary-expression:
            …
            pointer-indirection-expression
            addressof-expression

    pointer-indirection-expression:
            *  unary-expression

    pointer-member-access:
            primary-expression  ->  identifier

    pointer-element-access:
            primary-no-array-creation-expression  [  expression  ]

    addressof-expression:
            &  unary-expression

    sizeof-expression:
            sizeof  (  unmanaged-type  )

    embedded-statement:
            …
            fixed-statement

    fixed-statement:
            fixed  (  pointer-type  fixed-pointer-declarators  )  embedded-statement

    fixed-pointer-declarators:
            fixed-pointer-declarator
            fixed-pointer-declarators  ,  fixed-pointer-declarator

    fixed-pointer-declarator:
            identifier  =  fixed-pointer-initializer

    fixed-pointer-initializer:
            &  variable-reference
            expression

    struct-member-declaration:
            …
            fixed-size-buffer-declaration

    fixed-size-buffer-declaration:
            attributes_opt  fixed-size-buffer-modifiers_opt  fixed  buffer-element-type
                          fixed-size-buffer-declarators  ;

    fixed-size-buffer-modifiers:
            fixed-size-buffer-modifier
            fixed-size-buffer-modifier  fixed-size-buffer-modifiers

    fixed-size-buffer-modifier:
            new
            public
            protected
            internal
            private
            unsafe

    buffer-element-type:
            type

    fixed-size-buffer-declarators:
            fixed-size-buffer-declarator
            fixed-size-buffer-declarator  fixed-size-buffer-declarators

    fixed-size-buffer-declarator:
            identifier  [  const-expression  ]

    local-variable-initializer:
            …
            stackalloc-initializer

    stackalloc-initializer:
            stackalloc  unmanaged-type  [  expression  ]