diff --git a/.github/workflows/dependencies/GrammarTestingEnv.tgz b/.github/workflows/dependencies/GrammarTestingEnv.tgz index 97e8bd78e..77ef32699 100644 Binary files a/.github/workflows/dependencies/GrammarTestingEnv.tgz and b/.github/workflows/dependencies/GrammarTestingEnv.tgz differ diff --git a/standard/basic-concepts.md b/standard/basic-concepts.md index aa1606ffa..7781e771e 100644 --- a/standard/basic-concepts.md +++ b/standard/basic-concepts.md @@ -402,7 +402,7 @@ As described in [§7.4](basic-concepts.md#74-members), all members of a base cla ### 7.5.4 Protected access -When a `protected` or `private protected` instance member is accessed outside the program text of the class in which it is declared, and when a `protected internal` instance member is accessed outside the program text of the program in which it is declared, the access shall take place within a class declaration that derives from the class in which it is declared. Furthermore, the access is required to take place *through* an instance of that derived class type or a class type constructed from it. This restriction prevents one derived class from accessing protected members of other derived classes, even when the members are inherited from the same base class. Instance interface members defined with `protected` or `private protected` access cannot be accessed from a `class` or `struct` that implements that interface; these can be accessed only from derived interfaces. However, `class` and `struct` types can define overridden `protected` instance members declared in an interface it implements. +When a `protected` or `private protected` instance member is accessed outside the program text of the class in which it is declared, and when a `protected internal` instance member is accessed outside the program text of the program in which it is declared, the access shall take place within a class declaration that derives from the class in which it is declared. Furthermore, the access is required to take place *through* an instance of that derived class type or a class type constructed from it. This restriction prevents one derived class from accessing protected members of other derived classes, even when the members are inherited from the same base class. Instance interface members defined with `protected` or `private protected` access cannot be accessed from a `class` or `struct` that implements that interface; these can be accessed only from derived interfaces. However, `class` and `struct` types can implement `protected` instance members declared in an interface they implement. Let `B` be a base class that declares a protected instance member `M`, and let `D` be a class that derives from `B`. Within the *class_body* of `D`, access to `M` can take one of the following forms: diff --git a/standard/classes.md b/standard/classes.md index 7070443bb..168a70106 100644 --- a/standard/classes.md +++ b/standard/classes.md @@ -236,7 +236,7 @@ The direct base class of a class type shall be at least as accessible as the cla The direct base class of a class type shall not be any of the following types: `System.Array`, `System.Delegate`, `System.Enum`, `System.ValueType` or the `dynamic` type. Furthermore, a generic class declaration shall not use `System.Attribute` as a direct or indirect base class ([§23.2.1](attributes.md#2321-general)). -In determining the meaning of the direct base class specification `A` of a class `B`, the direct base class of `B` is temporarily assumed to be `object`, which ensures that the meaning of a base class specification cannot recursively depend on itself. +In determining the meaning of the direct base class specification `A` of a class `B`, the direct base class of `B` is temporarily assumed to be `object`, which ensures that the meaning of a base class specification cannot recursively depend on itself. Given this definition, the complete set of types upon which a class depends is the transitive closure of the *directly depends on* relationship. > *Example*: The following > @@ -3426,6 +3426,7 @@ For a ref-valued property the *ref_get_accessor_declaration* consists optional a The use of *accessor_modifier*s is governed by the following restrictions: +- An *accessor_modifier* shall not be used in an explicit interface member implementation. - The *accessor_modifier* `readonly` is permitted only in a *property_declaration* or *indexer_declaration* that is contained directly by a *struct_declaration* ([§16.4.11](structs.md#16411-properties), [§16.4.13](structs.md#16413-indexers)). - For a property or indexer that has no `override` modifier, an *accessor_modifier* is permitted only if the property or indexer has both a get and set accessor, and then is permitted only on one of those accessors. - For a property or indexer that includes an `override` modifier, an accessor shall match the *accessor_modifier*, if any, of the accessor being overridden. diff --git a/standard/interfaces.md b/standard/interfaces.md index 2fef96404..88cbcfd86 100644 --- a/standard/interfaces.md +++ b/standard/interfaces.md @@ -4,7 +4,7 @@ An interface defines a contract. A class or struct that implements an interface shall adhere to its contract. An interface may inherit from multiple base interfaces, and a class or struct may implement multiple interfaces. -Interfaces may contain various kinds of members, as described in [§19.4](interfaces.md#194-interface-members). The interface itself may provide an implementation for some or all of the function members that it declares. Members for which the interface does not provide an implementation are abstract. Their implementations must be supplied by classes or structs that implement the interface, or derived interface that provide an overriding definition. +Interfaces may contain various kinds of members, as described in [§19.4](interfaces.md#194-interface-members). The interface itself may provide an implementation for some or all of the function members that it declares. Members for which the interface does not provide an implementation are abstract. Their implementations must be supplied by classes or structs that implement the interface, and may be supplied by derived interfaces through an explicit implementation ([§19.6.2](interfaces.md#1962-explicit-interface-member-implementations)). > *Note*: Historically, adding a new function member to an interface impacted all existing consumers of that interface type; it was a breaking change. The addition of interface function member implementations allowed developers to upgrade an interface while still enabling any implementors to override that implementation. Users of the interface can accept the implementation as a non-breaking change; however, if their requirements are different, they can override the provided implementations. *end note* @@ -233,12 +233,12 @@ interface_member_declaration ; ``` -This clause augments the description of members in classes ([§15.3](classes.md#153-class-members)) with restrictions for interfaces. The Interface members are declared using *member_declaration*s with the following additional rules: +This clause augments the description of members in classes ([§15.3](classes.md#153-class-members)) with the differences and restrictions for interfaces: - A *finalizer_declaration* is not allowed. - Instance constructors, *constructor_declaration*s, are not allowed. - All interface members implicitly have public access; however, an explicit access modifier ([§7.5.2](basic-concepts.md#752-declared-accessibility)) is permitted except on static constructors ([§15.12](classes.md#1512-static-constructors)). -- The `abstract` modifier is implied for interface function members without bodies; that modifier may be given explicitly. +- The `abstract` modifier is implied for interface function members ([§12.6](expressions.md#126-function-members)) without bodies; that modifier may be given explicitly. - An interface instance function member whose declaration includes a body is an implicitly `virtual` member unless the `sealed` or `private` modifier is used. The `virtual` modifier may be given explicitly. - A `private` or `sealed` function member of an interface shall have a body. - A `private` function member shall not have the modifier `sealed`. @@ -476,7 +476,7 @@ Interface indexers are declared using *indexer_declaration*s ([§15.9](classes.m This clause augments the description of *operator_declaration* members in classes [§15.10](classes.md#1510-operators) for operators declared in interfaces. -An *operator_declaration* in an interface is the implementation ([§19.1](interfaces.md#191-general)). +For an *operator_declaration* in an interface the *operator_body* shall only be a block body ([§15.6.1](classes.md#1561-general)) or an expression body ([§15.6.1](classes.md#1561-general)). It is a compile-time error for an interface to declare a conversion, equality, or inequality operator. @@ -514,7 +514,7 @@ It is an error to declare a class type, struct type, or enum type within the sco > > *end example* -### 19.4.10 most specific implementation +### 19.4.10 Most specific implementation Every class and struct shall have a most specific implementation for every virtual member declared in all interfaces implemented by that type among the implementations appearing in the type or its direct and indirect interfaces. The ***most specific implementation*** is a unique implementation that is more specific than every other implementation. @@ -886,7 +886,7 @@ A *type_parameter_constraints_clause* on an explicit interface method implementa > Explicit interface member implementations serve two primary purposes: > > - Because explicit interface member implementations are not accessible through class or struct instances, they allow interface implementations to be excluded from the public interface of a class or struct. This is particularly useful when a class or struct implements an internal interface that is of no interest to a consumer of that class or struct. -> - Explicit interface member implementations allow disambiguation of interface members with the same signature. Without explicit interface member implementations it would be impossible for a class, struct, or interface to have different implementations of interface members with the same signature and return type, as would it be impossible for a class, struct, or interface to have any implementation at all of interface members with the same signature but with different return types. +> - Explicit interface member implementations allow disambiguation of interface members with the same signature. Without explicit interface member implementations it would be impossible for a class, struct, or interface to have different implementations of interface members with the same signature and return type; and it would be impossible for a class, struct, or interface to have any implementation at all of interface members with the same signature but with different return types. > > *end note* @@ -1066,7 +1066,7 @@ When a generic method implicitly implements an interface method, the constraints ### 19.6.5 Interface mapping -A class or struct shall provide implementations of all abstract members of the interfaces that are listed in the base class list of the class or struct. The process of locating implementations of interface members in an implementing class or struct is known as ***interface mapping***. +A class or struct shall provide implementations for all abstract members of the interfaces that are listed in the base class list of the class or struct which do not have a reachable implementation; where an implementation can become unreachable due to reabstraction [§19.4.3](interfaces.md#1943-interface-methods). The process of locating implementations of interface members in an implementing class or struct is known as ***interface mapping***. Interface mapping for a class or struct `C` locates an implementation for each member of each interface specified in the base class list of `C`. The implementation of a particular interface member `I.M`, where `I` is the interface in which the member `M` is declared, is determined by examining each class, interface, or struct `S`, starting with `C` and repeating for each successive base class and implemented interface of `C`, until a match is located: @@ -1463,7 +1463,7 @@ When a class implements an interface, it implicitly also implements all that int ### 19.6.8 Abstract classes and interfaces -Like a non-abstract class, an abstract class shall provide implementations of all abstract members of the interfaces that are listed in the base class list of the class. However, an abstract class is permitted to map interface methods onto abstract methods. +Like a non-abstract class, an abstract class shall provide implementations for all abstract members of the interfaces that are listed in the base class list of the class or struct which do not have a reachable implementation; where an implementation can become unreachable due to reabstraction [§19.4.3](interfaces.md#1943-interface-methods). However, an abstract class is permitted to map interface methods onto abstract methods. > *Example*: > @@ -1479,7 +1479,7 @@ Like a non-abstract class, an abstract class shall provide implementations of al > { > public abstract void F(); > public abstract void G(); -> } +> } > ``` > > Here, the implementation of `IMethods` maps `F` and `G` onto abstract methods, which shall be overridden in non-abstract classes that derive from `C`. diff --git a/tools/GrammarTesting/Tests/Parsing/Samples/v8/Expanded Interfaces/ReadMe.md b/tools/GrammarTesting/Tests/Parsing/Samples/v8/Expanded Interfaces/ReadMe.md new file mode 100644 index 000000000..84e8b2b69 --- /dev/null +++ b/tools/GrammarTesting/Tests/Parsing/Samples/v8/Expanded Interfaces/ReadMe.md @@ -0,0 +1,11 @@ +# Sample: Expanded Interfaces + +Simple test to check that interfaces can now declare more kinds of members and contain +implementations. + +The grammar for all interface members now uses the same productions as for classes, +with any differences being handled in prose, as such this test does not test +these differences. + +Note: No Antlr custom predicates have currently been developed for any interface +semantic rules as they are not key to parsing. \ No newline at end of file diff --git a/tools/GrammarTesting/Tests/Parsing/Samples/v8/Expanded Interfaces/Reference/sample.gruntree.red.txt b/tools/GrammarTesting/Tests/Parsing/Samples/v8/Expanded Interfaces/Reference/sample.gruntree.red.txt new file mode 100644 index 000000000..afaa700c1 --- /dev/null +++ b/tools/GrammarTesting/Tests/Parsing/Samples/v8/Expanded Interfaces/Reference/sample.gruntree.red.txt @@ -0,0 +1,869 @@ +⎛ +⎜ prog +⎜ ⎛ +⎜ ⎜ compilation_unit +⎜ ⎜ ⎛ +⎜ ⎜ ⎜ interface_declaration +⎜ ⎜ ⎜ interface +⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ KAI +⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ interface_body +⎜ ⎜ ⎜ ⎜ { +⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ interface_member_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ constant_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ constant_modifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ public +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ const +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ integral_type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ int +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ constant_declarators +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ constant_declarator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ Constant +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ = +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ constant_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ literal +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ 100 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ; +⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ interface_member_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ field_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ field_modifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ private +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ field_modifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ static +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ integral_type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ int +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ variable_declarators +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ field +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ; +⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ interface_member_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ method_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ method_modifiers +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ return_type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ integral_type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ int +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ method_header +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ member_name +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ M1 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ( +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ) +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ method_body +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ; +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ interface_member_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ method_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ method_modifiers +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ method_modifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ref_method_modifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ protected +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ method_modifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ref_method_modifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ new +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ return_type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ integral_type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ int +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ method_header +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ member_name +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ M2 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ( +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ) +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ method_body +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ block +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ { +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ statement_list +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ return_statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ return +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ literal +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ 42 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ; +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ } +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ interface_member_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ method_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ method_modifiers +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ method_modifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ref_method_modifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ protected +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ method_modifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ref_method_modifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ new +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ return_type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ integral_type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ int +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ method_header +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ member_name +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ M3 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ( +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ) +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ method_body +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ => +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ literal +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ 24 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ; +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ interface_member_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ property_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ integral_type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ int +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ member_name +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ P1 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ property_body +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ { +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ accessor_declarations +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ get_accessor_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ get +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ accessor_body +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ; +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ } +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ interface_member_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ property_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ property_modifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ public +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ property_modifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ new +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ integral_type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ int +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ member_name +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ P2 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ property_body +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ { +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ accessor_declarations +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ get_accessor_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ get +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ accessor_body +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ block +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ { +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ statement_list +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ return_statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ return +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ literal +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ 10 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ; +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ } +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ } +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ interface_member_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ event_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ event +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ EventHandler +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ variable_declarators +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ E1 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ; +⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ interface_member_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ event_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ event_modifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ sealed +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ event +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ EventHandler +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ member_name +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ E2 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ { +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ event_accessor_declarations +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ add_accessor_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ add +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ block +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ { +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ } +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ remove_accessor_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ remove +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ block +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ { +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ } +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ } +⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ interface_member_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ indexer_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ indexer_declarator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ simple_type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ bool +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ this +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ [ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ parameter_list +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ fixed_parameter +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ integral_type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ int +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ix1 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ] +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ indexer_body +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ { +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ accessor_declarations +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ set_accessor_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ set +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ accessor_body +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ; +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ } +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ interface_member_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ indexer_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ indexer_modifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ internal +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ indexer_declarator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ simple_type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ bool +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ this +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ [ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ parameter_list +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ fixed_parameter +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ integral_type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ int +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ix2 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ] +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ indexer_body +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ { +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ accessor_declarations +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ get_accessor_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ get +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ accessor_body +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ block +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ { +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ statement_list +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ return_statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ return +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ boolean_literal +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ true +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ; +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ } +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ } +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ interface_member_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ indexer_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ indexer_modifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ internal +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ indexer_declarator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ simple_type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ bool +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ this +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ [ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ parameter_list +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ fixed_parameter +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ integral_type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ int +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ix3 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ] +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ indexer_body +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ => +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ boolean_literal +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ false +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ; +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ interface_member_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ static_constructor_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ static_constructor_modifiers +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ static +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ KAI +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ( +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ) +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ static_constructor_body +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ block +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ { +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ statement_list +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ expression_statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ statement_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ assignment +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ field +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ assignment_operator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ = +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ literal +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ 50 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ; +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ } +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ interface_member_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ operator_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ operator_modifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ static +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ operator_declarator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_operator_declarator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ KAI +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ operator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ overloadable_unary_operator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ++ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ( +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ fixed_parameter +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ KAI +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ arg1 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ) +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ operator_body +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ; +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ interface_member_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ operator_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ operator_modifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ public +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ operator_modifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ static +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ operator_declarator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_operator_declarator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ KAI +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ operator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ overloadable_unary_operator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ -- +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ( +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ fixed_parameter +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ KAI +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ arg1 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ) +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ operator_body +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ block +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ { +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ statement_list +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ return_statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ return +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ arg1 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ; +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ } +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ interface_member_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ operator_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ operator_modifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ public +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ operator_modifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ static +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ operator_declarator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_operator_declarator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ KAI +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ operator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ overloadable_unary_operator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ -- +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ( +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ fixed_parameter +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ KAI +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ arg1 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ) +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ operator_body +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ => +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ arg1 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ; +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ interface_member_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ interface_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ interface +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ Nested +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ interface_body +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ { +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ interface_member_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ constant_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ constant_modifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ public +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ const +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ integral_type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ int +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ constant_declarators +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ constant_declarator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ FortyTwo +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ = +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ constant_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ literal +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ 42 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ; +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ } +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ } +⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎝ +⎜ ⎝ +⎝ diff --git a/tools/GrammarTesting/Tests/Parsing/Samples/v8/Expanded Interfaces/Reference/sample.stderr.txt b/tools/GrammarTesting/Tests/Parsing/Samples/v8/Expanded Interfaces/Reference/sample.stderr.txt new file mode 100644 index 000000000..e69de29bb diff --git a/tools/GrammarTesting/Tests/Parsing/Samples/v8/Expanded Interfaces/Reference/sample.tokens.txt b/tools/GrammarTesting/Tests/Parsing/Samples/v8/Expanded Interfaces/Reference/sample.tokens.txt new file mode 100644 index 000000000..f2019dc2b --- /dev/null +++ b/tools/GrammarTesting/Tests/Parsing/Samples/v8/Expanded Interfaces/Reference/sample.tokens.txt @@ -0,0 +1,167 @@ +[@0,0:8='interface',<'interface'>,1:0] +[@1,10:12='KAI',,1:10] +[@2,14:14='{',<'{'>,2:0] +[@3,34:39='public',<'public'>,4:3] +[@4,41:45='const',<'const'>,4:10] +[@5,47:49='int',<'int'>,4:16] +[@6,51:58='Constant',,4:20] +[@7,60:60='=',<'='>,4:29] +[@8,62:64='100',,4:31] +[@9,65:65=';',<';'>,4:34] +[@10,83:89='private',<'private'>,7:3] +[@11,91:96='static',<'static'>,7:11] +[@12,98:100='int',<'int'>,7:18] +[@13,102:106='field',,7:22] +[@14,107:107=';',<';'>,7:27] +[@15,130:132='int',<'int'>,10:3] +[@16,134:135='M1',,10:7] +[@17,136:136='(',<'('>,10:9] +[@18,137:137=')',<')'>,10:10] +[@19,138:138=';',<';'>,10:11] +[@20,143:151='protected',<'protected'>,11:3] +[@21,153:155='new',<'new'>,11:13] +[@22,157:159='int',<'int'>,11:17] +[@23,161:162='M2',,11:21] +[@24,163:163='(',<'('>,11:23] +[@25,164:164=')',<')'>,11:24] +[@26,166:166='{',<'{'>,11:26] +[@27,168:173='return',<'return'>,11:28] +[@28,175:176='42',,11:35] +[@29,177:177=';',<';'>,11:37] +[@30,179:179='}',<'}'>,11:39] +[@31,184:192='protected',<'protected'>,12:3] +[@32,194:196='new',<'new'>,12:13] +[@33,198:200='int',<'int'>,12:17] +[@34,202:203='M3',,12:21] +[@35,204:204='(',<'('>,12:23] +[@36,205:205=')',<')'>,12:24] +[@37,207:208='=>',<'=>'>,12:26] +[@38,210:211='24',,12:29] +[@39,212:212=';',<';'>,12:31] +[@40,235:237='int',<'int'>,15:3] +[@41,239:240='P1',,15:7] +[@42,242:242='{',<'{'>,15:10] +[@43,244:246='get',<'get'>,15:12] +[@44,247:247=';',<';'>,15:15] +[@45,249:249='}',<'}'>,15:17] +[@46,254:259='public',<'public'>,16:3] +[@47,261:263='new',<'new'>,16:10] +[@48,265:267='int',<'int'>,16:14] +[@49,269:270='P2',,16:18] +[@50,272:272='{',<'{'>,16:21] +[@51,274:276='get',<'get'>,16:23] +[@52,278:278='{',<'{'>,16:27] +[@53,280:285='return',<'return'>,16:29] +[@54,287:288='10',,16:36] +[@55,289:289=';',<';'>,16:38] +[@56,291:291='}',<'}'>,16:40] +[@57,293:293='}',<'}'>,16:42] +[@58,314:318='event',<'event'>,19:3] +[@59,320:331='EventHandler',,19:9] +[@60,333:334='E1',,19:22] +[@61,335:335=';',<';'>,19:24] +[@62,340:345='sealed',<'sealed'>,20:3] +[@63,347:351='event',<'event'>,20:10] +[@64,353:364='EventHandler',,20:16] +[@65,366:367='E2',,20:29] +[@66,369:369='{',<'{'>,20:32] +[@67,371:373='add',<'add'>,20:34] +[@68,375:375='{',<'{'>,20:38] +[@69,377:377='}',<'}'>,20:40] +[@70,379:384='remove',<'remove'>,20:42] +[@71,386:386='{',<'{'>,20:49] +[@72,388:388='}',<'}'>,20:51] +[@73,390:390='}',<'}'>,20:53] +[@74,413:416='bool',<'bool'>,23:3] +[@75,418:421='this',<'this'>,23:8] +[@76,422:422='[',<'['>,23:12] +[@77,423:425='int',<'int'>,23:13] +[@78,427:429='ix1',,23:17] +[@79,430:430=']',<']'>,23:20] +[@80,432:432='{',<'{'>,23:22] +[@81,434:436='set',<'set'>,23:24] +[@82,437:437=';',<';'>,23:27] +[@83,439:439='}',<'}'>,23:29] +[@84,444:451='internal',<'internal'>,24:3] +[@85,453:456='bool',<'bool'>,24:12] +[@86,458:461='this',<'this'>,24:17] +[@87,462:462='[',<'['>,24:21] +[@88,463:465='int',<'int'>,24:22] +[@89,467:469='ix2',,24:26] +[@90,470:470=']',<']'>,24:29] +[@91,472:472='{',<'{'>,24:31] +[@92,474:476='get',<'get'>,24:33] +[@93,478:478='{',<'{'>,24:37] +[@94,480:485='return',<'return'>,24:39] +[@95,487:490='true',<'true'>,24:46] +[@96,491:491=';',<';'>,24:50] +[@97,493:493='}',<'}'>,24:52] +[@98,495:495='}',<'}'>,24:54] +[@99,500:507='internal',<'internal'>,25:3] +[@100,509:512='bool',<'bool'>,25:12] +[@101,514:517='this',<'this'>,25:17] +[@102,518:518='[',<'['>,25:21] +[@103,519:521='int',<'int'>,25:22] +[@104,523:525='ix3',,25:26] +[@105,526:526=']',<']'>,25:29] +[@106,528:529='=>',<'=>'>,25:31] +[@107,531:535='false',<'false'>,25:34] +[@108,536:536=';',<';'>,25:39] +[@109,570:575='static',<'static'>,28:3] +[@110,577:579='KAI',,28:10] +[@111,580:580='(',<'('>,28:13] +[@112,581:581=')',<')'>,28:14] +[@113,583:583='{',<'{'>,28:16] +[@114,585:589='field',,28:18] +[@115,591:591='=',<'='>,28:24] +[@116,593:594='50',,28:26] +[@117,595:595=';',<';'>,28:28] +[@118,597:597='}',<'}'>,28:30] +[@119,621:626='static',<'static'>,31:3] +[@120,628:630='KAI',,31:10] +[@121,632:639='operator',<'operator'>,31:14] +[@122,640:641='++',<'++'>,31:22] +[@123,642:642='(',<'('>,31:24] +[@124,643:645='KAI',,31:25] +[@125,647:650='arg1',,31:29] +[@126,651:651=')',<')'>,31:33] +[@127,652:652=';',<';'>,31:34] +[@128,657:662='public',<'public'>,32:3] +[@129,664:669='static',<'static'>,32:10] +[@130,671:673='KAI',,32:17] +[@131,675:682='operator',<'operator'>,32:21] +[@132,683:684='--',<'--'>,32:29] +[@133,685:685='(',<'('>,32:31] +[@134,686:688='KAI',,32:32] +[@135,690:693='arg1',,32:36] +[@136,694:694=')',<')'>,32:40] +[@137,696:696='{',<'{'>,32:42] +[@138,698:703='return',<'return'>,32:44] +[@139,705:708='arg1',,32:51] +[@140,709:709=';',<';'>,32:55] +[@141,711:711='}',<'}'>,32:57] +[@142,716:721='public',<'public'>,33:3] +[@143,723:728='static',<'static'>,33:10] +[@144,730:732='KAI',,33:17] +[@145,734:741='operator',<'operator'>,33:21] +[@146,742:743='--',<'--'>,33:29] +[@147,744:744='(',<'('>,33:31] +[@148,745:747='KAI',,33:32] +[@149,749:752='arg1',,33:36] +[@150,753:753=')',<')'>,33:40] +[@151,755:756='=>',<'=>'>,33:42] +[@152,758:761='arg1',,33:45] +[@153,762:762=';',<';'>,33:49] +[@154,782:790='interface',<'interface'>,36:3] +[@155,792:797='Nested',,36:13] +[@156,802:802='{',<'{'>,37:3] +[@157,828:833='public',<'public'>,39:6] +[@158,835:839='const',<'const'>,39:13] +[@159,841:843='int',<'int'>,39:19] +[@160,845:852='FortyTwo',,39:23] +[@161,854:854='=',<'='>,39:32] +[@162,856:857='42',,39:34] +[@163,858:858=';',<';'>,39:36] +[@164,863:863='}',<'}'>,40:3] +[@165,865:865='}',<'}'>,41:0] +[@166,866:865='',,41:1] diff --git a/tools/GrammarTesting/Tests/Parsing/Samples/v8/Expanded Interfaces/Reference/sample.tree.red.txt b/tools/GrammarTesting/Tests/Parsing/Samples/v8/Expanded Interfaces/Reference/sample.tree.red.txt new file mode 100644 index 000000000..bd92d82f3 --- /dev/null +++ b/tools/GrammarTesting/Tests/Parsing/Samples/v8/Expanded Interfaces/Reference/sample.tree.red.txt @@ -0,0 +1 @@ +(prog (compilation_unit (interface_declaration interface (identifier KAI) (interface_body { (interface_member_declaration (constant_declaration (constant_modifier public) const (type (integral_type int)) (constant_declarators (constant_declarator (identifier Constant) = (constant_expression (literal 100)))) ;)) (interface_member_declaration (field_declaration (field_modifier private) (field_modifier static) (type (integral_type int)) (variable_declarators (identifier field)) ;)) (interface_member_declaration (method_declaration method_modifiers (return_type (integral_type int)) (method_header (member_name (identifier M1)) ( )) (method_body ;))) (interface_member_declaration (method_declaration (method_modifiers (method_modifier (ref_method_modifier protected)) (method_modifier (ref_method_modifier new))) (return_type (integral_type int)) (method_header (member_name (identifier M2)) ( )) (method_body (block { (statement_list (return_statement return (expression (literal 42)) ;)) })))) (interface_member_declaration (method_declaration (method_modifiers (method_modifier (ref_method_modifier protected)) (method_modifier (ref_method_modifier new))) (return_type (integral_type int)) (method_header (member_name (identifier M3)) ( )) (method_body => (expression (literal 24)) ;))) (interface_member_declaration (property_declaration (type (integral_type int)) (member_name (identifier P1)) (property_body { (accessor_declarations (get_accessor_declaration get (accessor_body ;))) }))) (interface_member_declaration (property_declaration (property_modifier public) (property_modifier new) (type (integral_type int)) (member_name (identifier P2)) (property_body { (accessor_declarations (get_accessor_declaration get (accessor_body (block { (statement_list (return_statement return (expression (literal 10)) ;)) })))) }))) (interface_member_declaration (event_declaration event (type (identifier EventHandler)) (variable_declarators (identifier E1)) ;)) (interface_member_declaration (event_declaration (event_modifier sealed) event (type (identifier EventHandler)) (member_name (identifier E2)) { (event_accessor_declarations (add_accessor_declaration add (block { })) (remove_accessor_declaration remove (block { }))) })) (interface_member_declaration (indexer_declaration (indexer_declarator (type (simple_type bool)) this [ (parameter_list (fixed_parameter (type (integral_type int)) (identifier ix1))) ]) (indexer_body { (accessor_declarations (set_accessor_declaration set (accessor_body ;))) }))) (interface_member_declaration (indexer_declaration (indexer_modifier internal) (indexer_declarator (type (simple_type bool)) this [ (parameter_list (fixed_parameter (type (integral_type int)) (identifier ix2))) ]) (indexer_body { (accessor_declarations (get_accessor_declaration get (accessor_body (block { (statement_list (return_statement return (expression (boolean_literal true)) ;)) })))) }))) (interface_member_declaration (indexer_declaration (indexer_modifier internal) (indexer_declarator (type (simple_type bool)) this [ (parameter_list (fixed_parameter (type (integral_type int)) (identifier ix3))) ]) (indexer_body => (expression (boolean_literal false)) ;))) (interface_member_declaration (static_constructor_declaration (static_constructor_modifiers static) (identifier KAI) ( ) (static_constructor_body (block { (statement_list (expression_statement (statement_expression (assignment (unary_expression (identifier field)) (assignment_operator =) (expression (literal 50)))) ;)) })))) (interface_member_declaration (operator_declaration (operator_modifier static) (operator_declarator (unary_operator_declarator (type (identifier KAI)) operator (overloadable_unary_operator ++) ( (fixed_parameter (type (identifier KAI)) (identifier arg1)) ))) (operator_body ;))) (interface_member_declaration (operator_declaration (operator_modifier public) (operator_modifier static) (operator_declarator (unary_operator_declarator (type (identifier KAI)) operator (overloadable_unary_operator --) ( (fixed_parameter (type (identifier KAI)) (identifier arg1)) ))) (operator_body (block { (statement_list (return_statement return (expression (identifier arg1)) ;)) })))) (interface_member_declaration (operator_declaration (operator_modifier public) (operator_modifier static) (operator_declarator (unary_operator_declarator (type (identifier KAI)) operator (overloadable_unary_operator --) ( (fixed_parameter (type (identifier KAI)) (identifier arg1)) ))) (operator_body => (expression (identifier arg1)) ;))) (interface_member_declaration (interface_declaration interface (identifier Nested) (interface_body { (interface_member_declaration (constant_declaration (constant_modifier public) const (type (integral_type int)) (constant_declarators (constant_declarator (identifier FortyTwo) = (constant_expression (literal 42)))) ;)) }))) })))) diff --git a/tools/GrammarTesting/Tests/Parsing/Samples/v8/Expanded Interfaces/Reference/sample.tree.svg b/tools/GrammarTesting/Tests/Parsing/Samples/v8/Expanded Interfaces/Reference/sample.tree.svg new file mode 100644 index 000000000..9e6f787db --- /dev/null +++ b/tools/GrammarTesting/Tests/Parsing/Samples/v8/Expanded Interfaces/Reference/sample.tree.svg @@ -0,0 +1,2005 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +[ + + + +operator_declarator + + + +interface_member_declaration + + + +type + + + +type + + + +] + + + +identifier + + + +expression + + + +bool + + + +identifier + + + +type + + + +=> + + + +identifier + + + +identifier + + + +operator_declaration + + + +int + + + +} + + + +operator + + + +static_constructor_body + + + +event_declaration + + + +type + + + +literal + + + +static + + + +boolean_literal + + + +} + + + +{ + + + +; + + + +static_constructor_declaration + + + +expression_statement + + + +variable_declarators + + + +arg1 + + + +] + + + +type + + + +constant_declaration + + + +prog + + + +get_accessor_declaration + + + +) + + + +} + + + +indexer_body + + + +; + + + +ix2 + + + +method_declaration + + + +identifier + + + +get + + + +method_body + + + +M2 + + + +interface_member_declaration + + + += + + + +parameter_list + + + +operator_body + + + +{ + + + +accessor_declarations + + + +method_modifier + + + +50 + + + +member_name + + + +public + + + +constant_declarator + + + +method_body + + + +new + + + +identifier + + + +type + + + +method_modifier + + + +add_accessor_declaration + + + +identifier + + + +{ + + + +) + + + +integral_type + + + +; + + + +event_accessor_declarations + + + +property_declaration + + + +statement_expression + + + +} + + + +fixed_parameter + + + +24 + + + +integral_type + + + +protected + + + +identifier + + + +; + + + +-- + + + +KAI + + + +remove + + + +constant_declarators + + + +E1 + + + +indexer_declarator + + + +overloadable_unary_operator + + + +} + + + +member_name + + + +KAI + + + +type + + + +identifier + + + +accessor_declarations + + + +literal + + + +expression + + + +interface_member_declaration + + + +int + + + +( + + + +42 + + + +} + + + +property_modifier + + + +; + + + +compilation_unit + + + +type + + + +get + + + +assignment_operator + + + +integral_type + + + +type + + + +sealed + + + +; + + + +{ + + + +ref_method_modifier + + + +get_accessor_declaration + + + +property_declaration + + + +expression + + + +method_declaration + + + +10 + + + +operator_modifier + + + +return + + + +protected + + + +} + + + +indexer_body + + + +interface_member_declaration + + + +interface + + + +return + + + +type + + + +return_type + + + +[ + + + +ix3 + + + +literal + + + +literal + + + +interface_member_declaration + + + +{ + + + +identifier + + + +event_modifier + + + +( + + + +expression + + + +simple_type + + + +get_accessor_declaration + + + +; + + + +( + + + +operator_declarator + + + +M3 + + + +identifier + + + +indexer_modifier + + + +} + + + +[ + + + +interface + + + +integral_type + + + +method_header + + + +member_name + + + +method_declaration + + + +identifier + + + +get + + + +method_body + + + +{ + + + +] + + + +type + + + +identifier + + + +M1 + + + +KAI + + + +return_statement + + + +type + + + +private + + + +this + + + +add + + + +integral_type + + + +constant_declarator + + + +arg1 + + + +field + + + +accessor_declarations + + + +int + + + +identifier + + + +field + + + +; + + + +method_modifiers + + + +integral_type + + + +type + + + +operator_body + + + +FortyTwo + + + +operator_modifier + + + +arg1 + + + +integral_type + + + +type + + + +; + + + +expression + + + +literal + + + +this + + + +identifier + + + += + + + +; + + + +; + + + +block + + + +{ + + + +operator_declarator + + + +static + + + +static + + + +operator_modifier + + + +unary_operator_declarator + + + +static + + + +return_type + + + +( + + + +remove_accessor_declaration + + + +{ + + + +identifier + + + +( + + + +integral_type + + + +; + + + +overloadable_unary_operator + + + +fixed_parameter + + + +return + + + +indexer_modifier + + + +integral_type + + + +assignment + + + +fixed_parameter + + + +public + + + +block + + + +member_name + + + +ref_method_modifier + + + +interface_declaration + + + += + + + +static + + + +interface_member_declaration + + + +property_body + + + +EventHandler + + + +interface_member_declaration + + + +field_modifier + + + +indexer_declaration + + + +method_modifier + + + +int + + + +interface_member_declaration + + + +E2 + + + +int + + + +interface_member_declaration + + + +constant_declarators + + + +Constant + + + +type + + + +ref_method_modifier + + + +block + + + +expression + + + +arg1 + + + +) + + + +constant_expression + + + +identifier + + + +operator_modifier + + + +public + + + +event + + + +KAI + + + +; + + + +member_name + + + +int + + + +42 + + + +interface_member_declaration + + + +arg1 + + + +; + + + +accessor_body + + + +identifier + + + +property_modifier + + + +bool + + + +identifier + + + +=> + + + +} + + + +operator + + + +event + + + +method_header + + + +member_name + + + +variable_declarators + + + +{ + + + +simple_type + + + +int + + + +{ + + + +identifier + + + +block + + + +-- + + + +overloadable_unary_operator + + + +property_body + + + +indexer_declarator + + + +expression + + + +public + + + +=> + + + +block + + + +{ + + + +method_header + + + +; + + + +integral_type + + + +type + + + +100 + + + +event_declaration + + + +constant_declaration + + + +return + + + +method_modifier + + + +method_modifiers + + + +interface_body + + + +{ + + + +identifier + + + +interface_member_declaration + + + +new + + + +accessor_body + + + +operator_declaration + + + +field_declaration + + + +int + + + +) + + + +simple_type + + + +statement_list + + + +identifier + + + +} + + + +indexer_declaration + + + +int + + + +ix1 + + + +operator_modifier + + + +constant_modifier + + + +method_modifiers + + + +set + + + +return_statement + + + +constant_expression + + + +static_constructor_modifiers + + + +return_statement + + + +{ + + + +type + + + +indexer_declaration + + + +identifier + + + +interface_body + + + +identifier + + + +expression + + + +interface_declaration + + + +identifier + + + +KAI + + + +P1 + + + +} + + + +interface_member_declaration + + + +accessor_body + + + +interface_member_declaration + + + +int + + + +const + + + +) + + + +statement_list + + + +operator_declaration + + + +const + + + +true + + + +false + + + +new + + + +field_modifier + + + +type + + + +Nested + + + +accessor_declarations + + + +{ + + + +; + + + +unary_expression + + + +literal + + + +KAI + + + +++ + + + +KAI + + + +( + + + +interface_member_declaration + + + +parameter_list + + + +fixed_parameter + + + +) + + + +KAI + + + +block + + + +statement_list + + + +block + + + +EventHandler + + + +P2 + + + +statement_list + + + +boolean_literal + + + +return_statement + + + +fixed_parameter + + + +fixed_parameter + + + +type + + + +interface_member_declaration + + + +} + + + +operator_body + + + +) + + + +set_accessor_declaration + + + +} + + + +this + + + +( + + + +bool + + + +unary_operator_declarator + + + +identifier + + + +indexer_body + + + +ref_method_modifier + + + +identifier + + + +identifier + + + +return_type + + + +public + + + +parameter_list + + + +accessor_body + + + +interface_member_declaration + + + +integral_type + + + +internal + + + +internal + + + +indexer_declarator + + + +} + + + +interface_member_declaration + + + +int + + + +statement_list + + + +identifier + + + +constant_modifier + + + +interface_member_declaration + + + +unary_operator_declarator + + + +identifier + + + +operator + + \ No newline at end of file diff --git a/tools/GrammarTesting/Tests/Parsing/Samples/v8/Expanded Interfaces/_Sample_Options.txt b/tools/GrammarTesting/Tests/Parsing/Samples/v8/Expanded Interfaces/_Sample_Options.txt new file mode 100644 index 000000000..c3810f510 --- /dev/null +++ b/tools/GrammarTesting/Tests/Parsing/Samples/v8/Expanded Interfaces/_Sample_Options.txt @@ -0,0 +1 @@ +-ms Rules -rt \ No newline at end of file diff --git a/tools/GrammarTesting/Tests/Parsing/Samples/v8/Expanded Interfaces/sample.cs b/tools/GrammarTesting/Tests/Parsing/Samples/v8/Expanded Interfaces/sample.cs new file mode 100644 index 000000000..b16d045ec --- /dev/null +++ b/tools/GrammarTesting/Tests/Parsing/Samples/v8/Expanded Interfaces/sample.cs @@ -0,0 +1,41 @@ +interface KAI +{ + // constant + public const int Constant = 100; + + // field + private static int field; + + // methods + int M1(); + protected new int M2() { return 42; } + protected new int M3() => 24; + + // properties + int P1 { get; } + public new int P2 { get { return 10; } } + + // event + event EventHandler E1; + sealed event EventHandler E2 { add { } remove { } } + + // indexer + bool this[int ix1] { set; } + internal bool this[int ix2] { get { return true; } } + internal bool this[int ix3] => false; + + // static constructor + static KAI() { field = 50; } + + // operator + static KAI operator++(KAI arg1); + public static KAI operator--(KAI arg1) { return arg1; } + public static KAI operator--(KAI arg1) => arg1; + + // type + interface Nested + { + // constant + public const int FortyTwo = 42; + } +} \ No newline at end of file