diff --git a/.github/workflows/dependencies/GrammarTestingEnv.tgz b/.github/workflows/dependencies/GrammarTestingEnv.tgz index aa65ce27b..932ae59a9 100644 Binary files a/.github/workflows/dependencies/GrammarTestingEnv.tgz and b/.github/workflows/dependencies/GrammarTestingEnv.tgz differ diff --git a/standard/README.md b/standard/README.md index 453433a13..43ddec457 100644 --- a/standard/README.md +++ b/standard/README.md @@ -784,6 +784,10 @@ - [§23.8.3](unsafe-code.md#2383-fixed-size-buffers-in-expressions) Fixed-size buffers in expressions - [§23.8.4](unsafe-code.md#2384-definite-assignment-checking) Definite assignment checking - [§23.9](unsafe-code.md#239-stack-allocation) Stack allocation +- [§24](ranges.md#24-ranges-and-slicing) Ranges and Slicing + - [§24.1](ranges.md#241-general) General + - [§24.2](ranges.md#242-the-index-type) The Index type + - [§24.3](ranges.md#243-the-range-type) The Range type - [§A](grammar.md#annex-a-grammar) Grammar - [§A.1](grammar.md#a1-general) General - [§A.2](grammar.md#a2-lexical-grammar) Lexical grammar diff --git a/standard/arrays.md b/standard/arrays.md index ccfcfe278..1fda69889 100644 --- a/standard/arrays.md +++ b/standard/arrays.md @@ -112,7 +112,9 @@ Elements of arrays created by *array_creation_expression*s are always initialize ## 17.4 Array element access -Array elements are accessed using *element_access* expressions ([§12.8.12.2](expressions.md#128122-array-access)) of the form `A[I₁, I₂, ..., Iₓ]`, where `A` is an expression of an array type and each `Iₑ` is an expression of type `int`, `uint`, `long`, `ulong`, or can be implicitly converted to one or more of these types. The result of an array element access is a variable, namely the array element selected by the indices. +Array elements are accessed using the *array access* variant of *element_access* expressions ([§12.8.12.2](expressions.md#128122-array-access)) of the form `A[I₁, I₂, ..., Iₓ]`, where `A` is an expression of an array type and each `Iₑ` is an expression of type `int`, `uint`, `long`, `ulong`, or can be implicitly converted to one or more of these types. The result of an array access is a variable reference (§9.5) to the array element selected by the indices. + +Array elements of single-dimensional arrays can also be accessed using an array access expression where the sole index, `I₁`, is an expression of type `Index`, `Range`, or can be implicitly converted to one or both of these types. If `I₁` is of type `Index`, or has been implicitly converted to it, then the result of the array access is a variable reference to the array element selected by the index value. If `I₁` is of type `Range`, or has been implicitly converted to it, then the result of the element access is a new array formed from a shallow copy of the array elements with indices in the `Range`, maintaining the element order. The elements of an array can be enumerated using a `foreach` statement ([§13.9.5](statements.md#1395-the-foreach-statement)). diff --git a/standard/clauses.json b/standard/clauses.json index acff96b61..740c816da 100644 --- a/standard/clauses.json +++ b/standard/clauses.json @@ -32,7 +32,8 @@ "attributes.md" ], "UnsafeClauses": [ - "unsafe-code.md" + "unsafe-code.md", + "ranges.md" ], "Annexes": [ "grammar.md", diff --git a/standard/expressions.md b/standard/expressions.md index 15e98f08e..6a62a93e5 100644 --- a/standard/expressions.md +++ b/standard/expressions.md @@ -148,7 +148,8 @@ The precedence of an operator is established by the definition of its associated > | **Subclause** | **Category** | **Operators** | > | ----------------- | ------------------------------- | -------------------------------------------------------| > | [§12.8](expressions.md#128-primary-expressions) | Primary | `x.y` `x?.y` `f(x)` `a[x]` `a?[x]` `x++` `x--` `x!` `new` `typeof` `default` `checked` `unchecked` `delegate` `stackalloc` | -> | [§12.9](expressions.md#129-unary-operators) | Unary | `+` `-` `!x` `~` `++x` `--x` `(T)x` `await x` | +> | [§12.9](expressions.md#129-unary-operators) | Unary | `+` `-` `!x` `~` `^` `++x` `--x` `(T)x` `await x` | +> | §range-operator | Range | `..` | > | [§12.10](expressions.md#1210-arithmetic-operators) | Multiplicative | `*` `/` `%` | > | [§12.10](expressions.md#1210-arithmetic-operators) | Additive | `+` `-` | > | [§12.11](expressions.md#1211-shift-operators) | Shift | `<<` `>>` | @@ -167,10 +168,12 @@ The precedence of an operator is established by the definition of its associated When an operand occurs between two operators with the same precedence, the ***associativity*** of the operators controls the order in which the operations are performed: -- Except for the assignment operators and the null coalescing operator, all binary operators are ***left-associative***, meaning that operations are performed from left to right. +- Except for the assignment operators, the range operator, and the null coalescing operator, all binary operators are ***left-associative***, meaning that operations are performed from left to right. > *Example*: `x + y + z` is evaluated as `(x + y) + z`. *end example* - The assignment operators, the null coalescing operator and the conditional operator (`?:`) are ***right-associative***, meaning that operations are performed from right to left. > *Example*: `x = y = z` is evaluated as `x = (y = z)`. *end example* +- The range operator is ***non-associative***, meaning that neither the left nor right operand of a range operator may be a *range_expression*. + > *Example*: Both `x..y..z` and `x..(y..z)` are invalid as `..` is non-associative. *end example* Precedence and associativity can be controlled using parentheses. @@ -182,21 +185,17 @@ All unary and binary operators have predefined implementations. In addition, use The ***overloadable unary operators*** are: -`+ - !` (logical negation only) `~ ++ -- true false` +> `+ - !` (logical negation only) `~ ++ -- true false` -> *Note*: Although `true` and `false` are not used explicitly in expressions (and therefore are not included in the precedence table in [§12.4.2](expressions.md#1242-operator-precedence-and-associativity)), they are considered operators because they are invoked in several expression contexts: Boolean expressions ([§12.24](expressions.md#1224-boolean-expressions)) and expressions involving the conditional ([§12.18](expressions.md#1218-conditional-operator)) and conditional logical operators ([§12.14](expressions.md#1214-conditional-logical-operators)). *end note* - +Only the operators listed above can be overloaded. In particular, it is not possible to overload the null-forgiving operator (postfix `!`, [§12.8.9](expressions.md#1289-null-forgiving-expressions)) or the unary hat operator (prefix `^`, (§hat-operator)). - -> *Note*: The null-forgiving operator (postfix `!`, [§12.8.9](expressions.md#1289-null-forgiving-expressions)) is not an overloadable operator. *end note* +> *Note*: Although `true` and `false` are not used explicitly in expressions (and therefore are not included in the precedence table in [§12.4.2](expressions.md#1242-operator-precedence-and-associativity)), they are considered operators because they are invoked in several expression contexts: Boolean expressions ([§12.24](expressions.md#1224-boolean-expressions)) and expressions involving the conditional ([§12.18](expressions.md#1218-conditional-operator)) and conditional logical operators ([§12.14](expressions.md#1214-conditional-logical-operators)). *end note* The ***overloadable binary operators*** are: -```csharp -+ - * / % & | ^ << >> == != > < <= >= -``` +> `+ - * / % & | ^ << >> == != > < <= >=` -Only the operators listed above can be overloaded. In particular, it is not possible to overload member access, method invocation, or the `=`, `&&`, `||`, `??`, `?:`, `=>`, `checked`, `unchecked`, `new`, `typeof`, `default`, `as`, and `is` operators. +Only the operators listed above can be overloaded. In particular, it is not possible to overload member access, method invocation, or the `..`, `=`, `&&`, `||`, `??`, `?:`, `=>`, `checked`, `unchecked`, `new`, `typeof`, `default`, `as`, and `is` operators. When a binary operator is overloaded, the corresponding compound assignment operator, if any, is also implicitly overloaded. @@ -348,8 +347,8 @@ In both of the above cases, a cast expression can be used to explicitly convert ***Lifted operators*** permit predefined and user-defined operators that operate on non-nullable value types to also be used with nullable forms of those types. Lifted operators are constructed from predefined and user-defined operators that meet certain requirements, as described in the following: -- For the unary operators `+`, `++`, `-`, `--`, `!`(logical negation), and `~`, a lifted form of an operator exists if the operand and result types are both non-nullable value types. The lifted form is constructed by adding a single `?` modifier to the operand and result types. The lifted operator produces a `null` value if the operand is `null`. Otherwise, the lifted operator unwraps the operand, applies the underlying operator, and wraps the result. -- For the binary operators `+`, `-`, `*`, `/`, `%`, `&`, `|`, `^`, `<<`, and `>>`, a lifted form of an operator exists if the operand and result types are all non-nullable value types. The lifted form is constructed by adding a single `?` modifier to each operand and result type. The lifted operator produces a `null` value if one or both operands are `null` (an exception being the `&` and `|` operators of the `bool?` type, as described in [§12.13.5](expressions.md#12135-nullable-boolean--and--operators)). Otherwise, the lifted operator unwraps the operands, applies the underlying operator, and wraps the result. +- For the unary operators `+`, `++`, `-`, `--`, `!` (logical negation), `^`, and `~`, a lifted form of an operator exists if the operand and result types are both non-nullable value types. The lifted form is constructed by adding a single `?` modifier to the operand and result types. The lifted operator produces a `null` value if the operand is `null`. Otherwise, the lifted operator unwraps the operand, applies the underlying operator, and wraps the result. +- For the binary operators `+`, `-`, `*`, `/`, `%`, `&`, `|`, `^`, `..`, `<<`, and `>>`, a lifted form of an operator exists if the operand and result types are all non-nullable value types. The lifted form is constructed by adding a single `?` modifier to each operand and result type. The lifted operator produces a `null` value if one or both operands are `null` (an exception being the `&` and `|` operators of the `bool?` type, as described in [§12.13.5](expressions.md#12135-nullable-boolean--and--operators)). Otherwise, the lifted operator unwraps the operands, applies the underlying operator, and wraps the result. - For the equality operators `==` and `!=`, a lifted form of an operator exists if the operand types are both non-nullable value types and if the result type is `bool`. The lifted form is constructed by adding a single `?` modifier to each operand type. The lifted operator considers two `null` values equal, and a `null` value unequal to any non-`null` value. If both operands are non-`null`, the lifted operator unwraps the operands and applies the underlying operator to produce the `bool` result. - For the relational operators `<`, `>`, `<=`, and `>=`, a lifted form of an operator exists if the operand types are both non-nullable value types and if the result type is `bool`. The lifted form is constructed by adding a single `?` modifier to each operand type. The lifted operator produces the value `false` if one or both operands are `null`. Otherwise, the lifted operator unwraps the operands and applies the underlying operator to produce the `bool` result. @@ -1657,7 +1656,7 @@ The *qualified_alias_member* production is defined in [§14.8](namespaces.md#148 A *member_access* is either of the form `E.I` or of the form `E.I`, where `E` is a *primary_expression*, *predefined_type* or *qualified_alias_member,* `I` is a single identifier, and `` is an optional *type_argument_list*. When no *type_argument_list* is specified, consider `e` to be zero. -A *member_access* with a *primary_expression* of type `dynamic` is dynamically bound ([§12.3.3](expressions.md#1233-dynamic-binding)). In this case, the compiler classifies the member access as a property access of type `dynamic`. The rules below to determine the meaning of the *member_access* are then applied at run-time, using the run-time type instead of the compile-time type of the *primary_expression*. If this run-time classification leads to a method group, then the member access shall be the *primary_expression* of an *invocation_expression*. +A *member_access* with a *primary_expression* of type `dynamic` is dynamically bound ([§12.3.3](expressions.md#1233-dynamic-binding)). In this case, the member access is classified as a property access of type `dynamic`. The rules below to determine the meaning of the *member_access* are then applied at run-time, using the run-time type instead of the compile-time type of the *primary_expression*. If this run-time classification leads to a method group, then the member access shall be the *primary_expression* of an *invocation_expression*. The *member_access* is evaluated and classified as follows: @@ -1733,7 +1732,7 @@ In a member access of the form `E.I`, if `E` is a single identifier, and if the A *null_conditional_member_access* is a conditional version of *member_access* ([§12.8.7](expressions.md#1287-member-access)) and it is a binding time error if the result type is `void`. For a null conditional expression where the result type may be `void` see ([§12.8.11](expressions.md#12811-null-conditional-invocation-expression)). -A *null_conditional_member_access* consists of a *primary_expression* followed by the two tokens “`?`” and “`.`”, followed by an *identifier* with an optional *type_argument_list*, followed by zero or more *dependent_access*es any of which can be preceeded by a *null_forgiving_operator*. +A *null_conditional_member_access* consists of a *primary_expression* followed by the two tokens “`?`” and “`.`”, followed by an *identifier* with an optional *type_argument_list*, followed by zero or more *dependent_access*es any of which can be preceded by a *null_forgiving_operator*. ```ANTLR null_conditional_member_access @@ -1823,7 +1822,7 @@ null_forgiving_operator ; ``` -*Note*: The postfix null-forgiving and prefix logical negation operators ([§12.9.4](expressions.md#1294-logical-negation-operator)), while represented by the same lexical token (`!`), are distinct. Only the latter may be overriden ([§15.10](classes.md#1510-operators)), the definition of the null-forgiving operator is fixed. *end note* +*Note*: The postfix null-forgiving and prefix logical negation operators ([§12.9.4](expressions.md#1294-logical-negation-operator)), while represented by the same lexical token (`!`), are distinct. Only the latter may be overridden ([§15.10](classes.md#1510-operators)), the definition of the null-forgiving operator is fixed. *end note* It is a compile-time error to apply the null-forgiving operator more than once to the same expression, intervening parentheses notwithstanding. @@ -1952,7 +1951,7 @@ An *invocation_expression* is dynamically bound ([§12.3.3](expressions.md#1233- - The *primary_expression* has compile-time type `dynamic`. - At least one argument of the optional *argument_list* has compile-time type `dynamic`. -In this case, the compiler classifies the *invocation_expression* as a value of type `dynamic`. The rules below to determine the meaning of the *invocation_expression* are then applied at run-time, using the run-time type instead of the compile-time type of those of the *primary_expression* and arguments that have the compile-time type `dynamic`. If the *primary_expression* does not have compile-time type `dynamic`, then the method invocation undergoes a limited compile-time check as described in [§12.6.5](expressions.md#1265-compile-time-checking-of-dynamic-member-invocation). +In this case, the *invocation_expression* is classified as a value of type `dynamic`. The rules below to determine the meaning of the *invocation_expression* are then applied at run-time, using the run-time type instead of the compile-time type of those of the *primary_expression* and arguments that have the compile-time type `dynamic`. If the *primary_expression* does not have compile-time type `dynamic`, then the method invocation undergoes a limited compile-time check as described in [§12.6.5](expressions.md#1265-compile-time-checking-of-dynamic-member-invocation). The *primary_expression* of an *invocation_expression* shall be a method group or a value of a *delegate_type*. If the *primary_expression* is a method group, the *invocation_expression* is a method invocation ([§12.8.10.2](expressions.md#128102-method-invocations)). If the *primary_expression* is a value of a *delegate_type*, the *invocation_expression* is a delegate invocation ([§12.8.10.4](expressions.md#128104-delegate-invocations)). If the *primary_expression* is neither a method group nor a value of a *delegate_type*, a binding-time error occurs. @@ -2118,7 +2117,7 @@ The preceding rules mean that instance methods take precedence over extension me > C.H(3) > ``` > -> `D.G` takes precendece over `C.G`, and `E.F` takes precedence over both `D.F` and `C.F`. +> `D.G` takes precedence over `C.G`, and `E.F` takes precedence over both `D.F` and `C.F`. > > *end example* @@ -2157,7 +2156,7 @@ in terms of what is included the text will probably be fine but this will need t The optional *null_forgiving_operator* may be included if and only if the *null_conditional_member_access* or *null_conditional_element_access* has a *delegate_type*. -A *null_conditional_invocation_expression* expression `E` is of the form `P?A`; where `A` is the remainder of the syntactically equivalent *null_conditional_member_access* or *null_conditional_element_access*, `A` will therefore start with `.` or `[`. Let `PA` signify the concatention of `P` and `A`. +A *null_conditional_invocation_expression* expression `E` is of the form `P?A`; where `A` is the remainder of the syntactically equivalent *null_conditional_member_access* or *null_conditional_element_access*, `A` will therefore start with `.` or `[`. Let `PA` signify the concatenation of `P` and `A`. When `E` occurs as a *statement_expression* the meaning of `E` is the same as the meaning of the *statement*: @@ -2198,8 +2197,6 @@ element_access When recognising a *primary_expression* if both the *element_access* and *pointer_element_access* ([§23.6.4](unsafe-code.md#2364-pointer-element-access)) alternatives are applicable then the latter shall be chosen if the embedded *primary_expression* is of pointer type ([§23.3](unsafe-code.md#233-pointer-types)). -The *argument_list* of an *element_access* shall not contain `out` or `ref` arguments. - The *primary_expression* of an *element_access* shall not be an *array_creation_expression* unless it includes an *array_initializer*, or a *stackalloc_expression* unless it includes a *stackalloc_initializer*. > *Note*: This restriction exists to disallow potentially confusing code such as: @@ -2221,29 +2218,94 @@ The *primary_expression* of an *element_access* shall not be an *array_creation_ An *element_access* is dynamically bound ([§12.3.3](expressions.md#1233-dynamic-binding)) if at least one of the following holds: - The *primary_expression* has compile-time type `dynamic`. -- At least one expression of the *argument_list* has compile-time type `dynamic` and the *primary_expression* does not have an array type. +- At least one expression of the *argument_list* has compile-time type `dynamic`. -In this case, the compiler classifies the *element_access* as a value of type `dynamic`. The rules below to determine the meaning of the *element_access* are then applied at run-time, using the run-time type instead of the compile-time type of those of the *primary_expression* and *argument_list* expressions which have the compile-time type `dynamic`. If the *primary_expression* does not have compile-time type `dynamic`, then the element access undergoes a limited compile-time check as described in [§12.6.5](expressions.md#1265-compile-time-checking-of-dynamic-member-invocation). +In this case the compile-time type of the *element_access* depends on the compile-time type of its *primary_expression*: if it has an array type then the compile-time type is the element type of that array type; otherwise the compile-time type is `dynamic` and the *element_access* is classified as a value of type `dynamic`. The rules below to determine the meaning of the *element_access* are then applied at run-time, using the run-time type instead of the compile-time type of those of the *primary_expression* and *argument_list* expressions which have the compile-time type `dynamic`. If the *primary_expression* does not have compile-time type `dynamic`, then the element access undergoes a limited compile-time check as described in [§12.6.5](expressions.md#1265-compile-time-checking-of-dynamic-member-invocation). -If the *primary_expression* of an *element_access* is a value of an *array_type*, the *element_access* is an array access ([§12.8.12.2](expressions.md#128122-array-access)). Otherwise, the *primary_expression* shall be a variable or value of a class, struct, or interface type that has one or more indexer members, in which case the *element_access* is an indexer access ([§12.8.12.3](expressions.md#128123-indexer-access)). +> *Example*: +> +> ```csharp +> var index = (dynamic)1; // index has compile-time type dynamic +> int[] a = {0, 1, 2}; +> var a_elem = a[index]; // dynamically bound, a_elem has compile-time type int +> string s = "012"; +> var s_elem = s[index]; // dynamcially bound, s_elem has compile-time type dynamic +> ``` +> +> *end example* + +If the *primary_expression* of an *element_access* is: + +- a value of *array_type*, the *element_access* is an array access ([§12.8.12.2](expressions.md#128122-array-access)); +- a value of `string` type, the *element_access* is a string access (§string-access); +- otherwise, the *primary_expression* shall be a variable or value of a class, struct, or interface type that has one or more indexer members, in which case the *element_access* is an indexer access ([§12.8.12.3](expressions.md#128123-indexer-access)). #### 12.8.12.2 Array access -For an array access, the *primary_expression* of the *element_access* shall be a value of an *array_type*. Furthermore, the *argument_list* of an array access shall not contain named arguments. The number of expressions in the *argument_list* shall be the same as the rank of the *array_type*, and each expression shall be of type `int`, `uint`, `long`, or `ulong,` or shall be implicitly convertible to one or more of these types. +For an array access the *argument_list* shall not contain named arguments or by-reference arguments (§15.6.2.3). + +The number of expressions in the *argument_list* shall be the same as the rank of the *array_type*, and each expression shall be: + +- of type `int`, `uint`, `long`, or `ulong`; or +- for single rank array access only, of type `Index` or `Range`; or +- be implicitly convertible to one or more of the above types. -The result of evaluating an array access is a variable of the element type of the array, namely the array element selected by the values of the expressions in the *argument_list*. +The run-time processing of an array access of the form `P[A]`, where `P` is a *primary_expression* of an *array_type* and `A` is an *argument_list* of index expressions, consists of the following steps: -The run-time processing of an array access of the form `P[A]`, where `P` is a *primary_expression* of an *array_type* and `A` is an *argument_list*, consists of the following steps: +- `P` is evaluated. If this evaluation causes an exception, no further steps are executed. +- For each index expression in the *argument_list* in order, from left to right: + - The index expression is evaluated, let the type of the resultant value be *T*; + - This value is then converted to the first of the types: `int`, `uint`, `long`, `ulong`, or for single rank array access only, `Index` or `Range`; for which an implicit conversion ([§10.2](conversions.md#102-implicit-conversions)) from *T* exists. + - If evaluation of an index expression or the subsequent implicit conversion causes an exception, then no further index expressions are evaluated and no further steps are executed. +- The value of `P` is checked to be valid. If the value of `P` is `null`, a `System.NullReferenceException` is thrown and no further steps are executed. +- If the preceding steps have produced a single index value of type `Range` then: + - Let *L* be the length of the array referenced by `P`. + - `A` is checked to be valid with respect to *L* (§24.3), if it is not then a `System.ArgumentOutOfRangeException` is thrown and no further steps are executed. + - The starting offset, *S*, and number of items, *N*, for `A` with respect to *L* are determined as described for `GetOffsetAndLength` (§24.3). + - A new array is created from a shallow copy of the *N* elements of `P` starting at index *S*, if *N* is zero the new array has zero elements. This array becomes the result of the array access. + +> > > *Note:* Both *S* and *N* may be zero ($24.3). Indexing an empty array is usually invalid, however indexing with an empty range starting at zero is valid and returns an empty array. The defintion also allows *S* to be *L*, the past-end index (§24.1), in which case *N* will be zero and an empty array returned. *end note* + + + +> > > *Note:* A range of elements of an array cannot be assigned to using an array access. This differs from indexer accesses (§12.8.12.3) which may, but need not, support assignment to a range of indices specified by a `Range` value. *end note* + +- Otherwise: + - The result of evaluating the array access is a variable reference (§9.5) of the element type of the array. + - The value of each expression in the *argument_list* is checked against the actual bounds of each dimension of the array instance referenced by `P`. If one or more values are out of range, a `System.IndexOutOfRangeException` is thrown and no further steps are executed. + - The variable reference of the array element given by the index expressions is computed, and this becomes the result of the array access. + +#### §string-access String access + +For a string access the *argument_list* of the *element_access* shall contain a single unnamed value argument (§15.6.2.2) which shall be: + +- of type `int`, `Index` or `Range`; or +- implicitly convertible to one or more of the above types. + +The run-time processing of a string access of the form `P[A]`, where `P` is a *primary_expression* of `string` type and `A` is a single expression, consists of the following steps: - `P` is evaluated. If this evaluation causes an exception, no further steps are executed. -- The index expressions of the *argument_list* are evaluated in order, from left to right. Following evaluation of each index expression, an implicit conversion ([§10.2](conversions.md#102-implicit-conversions)) to one of the following types is performed: `int`, `uint`, `long`, `ulong`. The first type in this list for which an implicit conversion exists is chosen. For instance, if the index expression is of type `short` then an implicit conversion to `int` is performed, since implicit conversions from `short` to `int` and from `short` to `long` are possible. If evaluation of an index expression or the subsequent implicit conversion causes an exception, then no further index expressions are evaluated and no further steps are executed. +- The index expression is evaluated, let the type of the resultant value be *T*; +- This value is then converted to the first of the types: `int`, `Index` or `Range`; for which an implicit conversion ([§10.2](conversions.md#102-implicit-conversions)) from *T* exists. +- If evaluation of an index expression or the subsequent implicit conversion causes an exception, then no further index expressions are evaluated and no further steps are executed. - The value of `P` is checked to be valid. If the value of `P` is `null`, a `System.NullReferenceException` is thrown and no further steps are executed. -- The value of each expression in the *argument_list* is checked against the actual bounds of each dimension of the array instance referenced by `P`. If one or more values are out of range, a `System.IndexOutOfRangeException` is thrown and no further steps are executed. -- The location of the array element given by the index expressions is computed, and this location becomes the result of the array access. +- If the preceding steps have produced an index value of type `Range` then: + - The result of evaluating the string access is a value of `string` type. + - Let *L* be the length of the string referenced by `P`. + - `A` is checked to be valid with respect to *L* (§24.3), if it is not then a `System.ArgumentOutOfRangeException` is thrown and no further steps are executed. + - The starting offset, *S*, and number of items, *N*, for `A` with respect to *L* are determined as described for `GetOffsetAndLength` (§24.3). + - The result of the string access is a new string formed by copying the *N* characters of `P` starting from *S*, if *N* is zero the new string is empty. + +> > > *Note:* Both *S* and *N* may be zero (§24.3). Indexing an empty string is usually invalid, however indexing with an empty range starting at zero is valid and returns an empty string. The defintion also allows *S* to be *L*, the past-end index (§24.1), in which case *N* will be zero and an empty string returned. *end note* + +- Otherwise: + - The result of evaluating the string access is a value of `char` type. + - The value of the converted index expression is checked against the actual bounds of the string instance referenced by `P`. If the value is out of range, a `System.IndexOutOfRangeException` is thrown and no further steps are executed. + - The value of character at the offset of the converted index expression with the string `P` becomes the result of the string access. #### 12.8.12.3 Indexer access -For an indexer access, the *primary_expression* of the *element_access* shall be a variable or value of a class, struct, or interface type, and this type shall implement one or more indexers that are applicable with respect to the *argument_list* of the *element_access*. +For an indexer access, the *primary_expression* of the *element_access* shall be a variable or value of a class, struct, or interface type, and this type shall implement one or more indexers that are applicable with respect to the *argument_list* of the *element_access*. The *argument_list* shall not cannot contain `out` or `ref` arguments. The binding-time processing of an indexer access of the form `P[A]`, where `P` is a *primary_expression* of a class, struct, or interface type `T`, and `A` is an *argument_list*, consists of the following steps: @@ -2254,9 +2316,17 @@ The binding-time processing of an indexer access of the form `P[A]`, where `P` i - If `I` is applicable with respect to `A` ([§12.6.4.2](expressions.md#12642-applicable-function-member)) and `S` is a class type other than `object`, all indexers declared in an interface are removed from the set. - If the resulting set of candidate indexers is empty, then no applicable indexers exist, and a binding-time error occurs. - The best indexer of the set of candidate indexers is identified using the overload resolution rules of [§12.6.4](expressions.md#1264-overload-resolution). If a single best indexer cannot be identified, the indexer access is ambiguous, and a binding-time error occurs. -- The index expressions of the *argument_list* are evaluated in order, from left to right. The result of processing the indexer access is an expression classified as an indexer access. The indexer access expression references the indexer determined in the step above, and has an associated instance expression of `P` and an associated argument list of `A`, and an associated type that is the type of the indexer. If `T` is a class type, the associated type is picked from the first declaration or override of the indexer found when starting with `T` and searching through its base classes. +- The accessors of the best indexer are checked: + - If the indexer access is the target of an assignment then the indexer shall have a set or ref get accessor, if not a binding-time error occurs; + - Otherwise the indexer shall have a get or ref get accessor, otherwise a binding-time error occurs. -Depending on the context in which it is used, an indexer access causes invocation of either the get accessor or the set accessor of the indexer. If the indexer access is the target of an assignment, the set accessor is invoked to assign a new value ([§12.21.2](expressions.md#12212-simple-assignment)). In all other cases, the get accessor is invoked to obtain the current value ([§12.2.2](expressions.md#1222-values-of-expressions)). +The runtime processing of the indexer access consists of the following steps: + +- The target *primary_expression* `P` is evaluated. +- The index expressions of the *argument_list* `A` are evaluated in order, from left to right. +- Using the best indexer determined at binding-time: + - If the indexer access is the target of an assignment, the set accessor or ref get accessor is invoked to assign a new value ([§12.21.2](expressions.md#12212-simple-assignment)). + - In all other cases, the get accessor or ref get accessor is invoked to obtain the current value ([§12.2.2](expressions.md#1222-values-of-expressions)). ### 12.8.13 Null Conditional Element Access @@ -2518,6 +2588,8 @@ An object initializer consists of a sequence of member initializers, enclosed by Each *initializer_target* is followed by an equals sign and either an expression, an object initializer or a collection initializer. It is not possible for expressions within the object initializer to refer to the newly created object it is initializing. +In the *argument_list* of an *initializer_target* there is no implicit support for arguments of type `Index` (§24.4.2) or `Range` (§24.4.3). + A member initializer that specifies an expression after the equals sign is processed in the same way as an assignment ([§12.21.2](expressions.md#12212-simple-assignment)) to the target. A member initializer that specifies an object initializer after the equals sign is a ***nested object initializer***, i.e., an initialization of an embedded object. Instead of assigning a new value to the field or property, the assignments in the nested object initializer are treated as assignments to members of the field or property. Nested object initializers cannot be applied to properties with a value type, or to read-only fields with a value type. @@ -3462,7 +3534,7 @@ An *anonymous_method_expression* is one of two ways of defining an anonymous fun ### 12.9.1 General -The `+`, `-`, `!` (logical negation [§12.9.4](expressions.md#1294-logical-negation-operator) only), `~`, `++`, `--`, cast, and `await` operators are called the unary operators. +The `+`, `-`, `!` (logical negation [§12.9.4](expressions.md#1294-logical-negation-operator) only), `~`, `^`, `++`, `--`, cast, and `await` operators are called the unary operators. > *Note*: The postfix null-forgiving operator ([§12.8.9](expressions.md#1289-null-forgiving-expressions)), `!`, due to its compile-time and non-overloadable only nature, is excluded from the above list. *end note* @@ -3473,6 +3545,7 @@ unary_expression | '-' unary_expression | logical_negation_operator unary_expression | '~' unary_expression + | '^' unary_expression | pre_increment_expression | pre_decrement_expression | cast_expression @@ -3484,7 +3557,12 @@ unary_expression *pointer_indirection_expression* ([§23.6.2](unsafe-code.md#2362-pointer-indirection)) and *addressof_expression* ([§23.6.5](unsafe-code.md#2365-the-address-of-operator)) are available only in unsafe code ([§23](unsafe-code.md#23-unsafe-code)). -If the operand of a *unary_expression* has the compile-time type `dynamic`, it is dynamically bound ([§12.3.3](expressions.md#1233-dynamic-binding)). In this case, the compile-time type of the *unary_expression* is `dynamic`, and the resolution described below will take place at run-time using the run-time type of the operand. +If the operand of a *unary_expression* has the compile-time type `dynamic`, it is dynamically bound ([§12.3.3](expressions.md#1233-dynamic-binding)). In this case: + +- the compile-time type of the *unary_expression* is: + - `Index` for the `^` hat operator (§hat-operator) + - `dynamic` for all other unary operators; and +- the resolution described below will take place at run-time using the run-time type of the operand. ### 12.9.2 Unary plus operator @@ -3575,6 +3653,24 @@ The result of evaluating `~x`, where `X` is an expression of an enumeration ty Lifted ([§12.4.8](expressions.md#1248-lifted-operators)) forms of the unlifted predefined bitwise complement operators defined above are also predefined. +### §hat-operator Hat operator + +The unary `^` operator is called the *hat* operator. The hat operator is not overloadable (§12.4.3) and there is a single predefined hat operator: + +```csharp +Index operator ^(int x); +``` + +The result of an operation of the form `^x` is a from-end `Index` (§24.2) value equivalent to the result of the expression: + +```csharp +new Index(x, true) +``` + +As with the other *unary_expression*s the operand may have a compile-time type of `dynamic` (§12.9.1) and be dynamically bound (§12.3.3). The compile-time type of the result is always `Index`. + +A lifted ([§12.4.8](expressions.md#1248-lifted-operators)) form of the hat operator is also predefined. + ### 12.9.6 Prefix increment and decrement operators ```ANTLR @@ -3706,6 +3802,42 @@ At run-time, the expression `await t` is evaluated as follows: An awaiter’s implementation of the interface methods `INotifyCompletion.OnCompleted` and `ICriticalNotifyCompletion.UnsafeOnCompleted` should cause the delegate `r` to be invoked at most once. Otherwise, the behavior of the enclosing async function is undefined. +## §range-operator Range operator + +The `..` operator is called the *range* operator. + +```ANTLR +range_expression + : unary_expression + | unary_expression? '..' unary_expression? + ; +``` + +The predefined range operator is: + +```csharp +Range operator ..(Index x, Index y); +``` + +The range operator is not overloadable (§12.4.3). + +All range expressions are treated as having the form `x..y`, where: + +- `x` is the left operand if present, otherwise the expression `0`; and +- `y` is the right operand if present, otherwise the expression `^0`. + +The result of the operation is a `Range` (§24.3) value equivalent to the result of the expression: + +```csharp +new Range(x, y) +``` + +If either or both operands in a range expression have the compile-time type `dynamic`, then the expression is dynamically bound ([§12.3.3](expressions.md#1233-dynamic-binding)). The compile-time type of the result is always `Range`. + +A lifted ([§12.4.8](expressions.md#1248-lifted-operators)) form of the range operator is also predefined. + +The range operator is non-associative (§12.4.2). + ## 12.10 Arithmetic operators ### 12.10.1 General @@ -3714,10 +3846,10 @@ The `*`, `/`, `%`, `+`, and `-` operators are called the arithmetic operators. ```ANTLR multiplicative_expression - : unary_expression - | multiplicative_expression '*' unary_expression - | multiplicative_expression '/' unary_expression - | multiplicative_expression '%' unary_expression + : range_expression + | multiplicative_expression '*' range_expression + | multiplicative_expression '/' range_expression + | multiplicative_expression '%' range_expression ; additive_expression @@ -4574,7 +4706,7 @@ User defined conversions are not considered by the `is` operator. > - If the compile-time type of `e` is the same as `T`, or if an implicit reference conversion ([§10.2.8](conversions.md#1028-implicit-reference-conversions)), boxing conversion ([§10.2.9](conversions.md#1029-boxing-conversions)), wrapping conversion ([§10.6](conversions.md#106-conversions-involving-nullable-types)), or an explicit unwrapping conversion ([§10.6](conversions.md#106-conversions-involving-nullable-types)) exists from the compile-time type of `E` to `T`: > - If `C` is of a non-nullable value type, the result of the operation is `true`. > - Otherwise, the result of the operation is equivalent to evaluating `E != null`. -> - Otherwise, if an explicit reference conversion ([§10.3.5](conversions.md#1035-explicit-reference-conversions)) or unboxing conversion ([§10.3.7](conversions.md#1037-unboxing-conversions)) exists from `C` to `T`, or if `C` or `T` is an open type ([§8.4.3](types.md#843-open-and-closed-types)), then runtime checks as above shall be peformed. +> - Otherwise, if an explicit reference conversion ([§10.3.5](conversions.md#1035-explicit-reference-conversions)) or unboxing conversion ([§10.3.7](conversions.md#1037-unboxing-conversions)) exists from `C` to `T`, or if `C` or `T` is an open type ([§8.4.3](types.md#843-open-and-closed-types)), then runtime checks as above shall be performed. > - Otherwise, no reference, boxing, wrapping, or unwrapping conversion of `E` to type `T` is possible, and the result of the operation is `false`. > A compiler may implement optimisations based on the compile-time type. > @@ -5318,7 +5450,7 @@ A local variable is considered to be ***instantiated*** when execution enters th > > *end example* -When not captured, there is no way to observe exactly how often a local variable is instantiated—because the lifetimes of the instantiations are disjoint, it is possible for each instantation to simply use the same storage location. However, when an anonymous function captures a local variable, the effects of instantiation become apparent. +When not captured, there is no way to observe exactly how often a local variable is instantiated—because the lifetimes of the instantiations are disjoint, it is possible for each instantiation to simply use the same storage location. However, when an anonymous function captures a local variable, the effects of instantiation become apparent. > *Example*: The example > @@ -6416,7 +6548,7 @@ In the translation steps described above, transparent identifiers are always int The ***Query-expression pattern*** establishes a pattern of methods that types can implement to support query expressions. -A generic type `C` supports the query-expression-pattern if its public member methods and the publicly accessible extension methods could be replaced by the following class definition. The members and accessible extenson methods is referred to as the “shape” of a generic type `C`. A generic type is used in order to illustrate the proper relationships between parameter and return types, but it is possible to implement the pattern for non-generic types as well. +A generic type `C` supports the query-expression-pattern if its public member methods and the publicly accessible extension methods could be replaced by the following class definition. The members and accessible extension methods is referred to as the “shape” of a generic type `C`. A generic type is used in order to illustrate the proper relationships between parameter and return types, but it is possible to implement the pattern for non-generic types as well. ```csharp diff --git a/standard/lexical-structure.md b/standard/lexical-structure.md index 3e466b29c..f440da104 100644 --- a/standard/lexical-structure.md +++ b/standard/lexical-structure.md @@ -1010,11 +1010,11 @@ Punctuators are for grouping and separating. ```ANTLR operator_or_punctuator - : '{' | '}' | '[' | ']' | '(' | ')' | '.' | ',' | ':' | ';' - | '+' | '-' | ASTERISK | SLASH | '%' | '&' | '|' | '^' | '!' | '~' - | '=' | '<' | '>' | '?' | '??' | '::' | '++' | '--' | '&&' | '||' - | '->' | '==' | '!=' | '<=' | '>=' | '+=' | '-=' | '*=' | '/=' | '%=' - | '&=' | '|=' | '^=' | '<<' | '<<=' | '=>' | '??=' + : '{' | '}' | '[' | ']' | '(' | ')' | '.' | ',' | ':' | ';' + | '+' | '-' | '*' | '/' | '%' | '&' | '|' | '^' | '!' | '~' + | '=' | '<' | '>' | '?' | '??' | '::' | '++' | '--' | '&&' | '||' + | '->' | '==' | '!=' | '<=' | '>=' | '+=' | '-=' | '*=' | '/=' | '%=' + | '&=' | '|=' | '^=' | '<<' | '<<=' | '=>' | '??=' | '..' ; right_shift diff --git a/standard/ranges.md b/standard/ranges.md new file mode 100644 index 000000000..538852b9f --- /dev/null +++ b/standard/ranges.md @@ -0,0 +1,309 @@ +# 24 Extended Indexing and Slicing + +> **Review Note:** This new clause, currently (§24), is placed here temporarily to avoid text changes due to renumbering occurring in chapters & clauses otherwise unaffected by the PR. Its final placement is not yet determined, however between the Arrays ([§17](arrays.md#17-arrays)) and Interfaces ([§18](interfaces.md#18-interfaces)) chapters might be suitable – other placements can be suggested during review. It can be relocated later with just a simple edit to `clauses.json`. + +## 24.1 General + +This clause introduces a model for *extended indexable* and *sliceable* *collection* types built on: + +- The types introduced in this clause, `System.Index` (§24.2) and `System.Range` (§24.3); +- The pre-defined unary `^` (§hat-operator) and binary `..` (§range-operator) operators; and +- The *element_access* expression. + +Under the model a type is classified as: + +- a *collection* if it represents a group of *element*s +- an *extended indexable* collection if it supports an *element_access* expression which has a single argument expression of type `Index` which returns and/or sets a single element of the type, either by value or by reference; and +- an *extended sliceable* collection if it supports an *element_access* expression which has a single argument expression of type `Range` which returns a *slice* of the elements of the type by value. + +> *Note*: The model does not require that a slice, unlike an element, of the type can be set, but a type may support it as an extension of the model. *end note* + +The model is supported for single-dimensional arrays (§12.8.12.2) and strings (§string-access). + +The model can be supported by any class, struct or interface type which provides appropriate indexers (§15.9) which implement the model semantics. + +Implicit support for the model is provided for types which do not directly support it but which provide a certain *pattern* of members (§24.4). This support is pattern-based, rather than semantic-based, as the semantics of the type members upon which it is based are *assumed* – the language does not enforce, or check, the semantics of these type members. + +For the purposes of this clause the following terms are defined: + +- A ***collection*** is a type which represents a group of ***element***s. +- A ***countable collection*** is one which provides a ***countable property*** an `int` valued instance property whose value is the number of elements currently in the group. This property shall be named either `Length` or `Count`, the former is chosen if both exist. +- A ***sequence*** or ***indexable type*** is a collection: + - which is countable; + - where every element can be accessed using an *element_access* expression with a single required `int` argument, the ***from-start index***, additional optional arguments are allowed; + - a sequence is ***modifiable*** if every element can also be set using an *element_access* expression; + - an element’s from-start index is the number of elements before it in the sequence, for a sequence containing *N* elements: + - the first and last elements have indices of 0 and *N*-1 respectively, and + - the ***past-end index***, an index which represents a hypothetical element after the last one, has the value *N*. +- A ***from-end index*** represents an element’s position within a sequence relative to the last element. For a sequence containing *N* elements the first, last and past-end indices are *N*, 1 and 0 respectively. +- A ***range*** is a contiguous run of zero or more indices starting at any index within a sequence. +- A ***slice*** is the collection of elements within a range. +- A ***sliceable collection*** is one which: + - is countable; + - provides a method `Slice` which takes two `int` parameters specifying a range, being a starting index and a count of elements respectively, and returns a new slice constructed from the elements in the range. + +The above definitions are extended for uses of `Index` and `Range` as follows: + +- A type is also a *sequence* if an *element_access* expression taking a single required `Index` argument, rather than an `int` argument, is supported. Where a distinction is required the type is termed ***extended indexable***. +- A type is also *sliceable* if an *element_access* expression taking a single required `Range` argument, rather a `Slice` method, is supported. Where a distinction is required the type is termed ***extended sliceable***. + +Whether a type is classified as countable, indexable, or sliceable is subject to the constraints of member accessibility (§7.5) and therefore dependent on where the type is being used. + +> *Example*: A type where the countable property and/or the indexer are `protected` is only a sequence to members of itself and any derived types. *end example* + +The required members for a type to qualify as a sequence or sliceable may be inherited. + +> *Example*: In the following code +> +> ```csharp +> public class A +> { +> public int Length { get { … } } +> } +> +> public class B : A +> { +> public int this(int index) { … } +> } +> +> public class C : B +> { +> public int[] Slice(int index, int count) { … } +> } +> ``` +> +> The type `A` is countable, `B` is a sequence, and `C` is sliceable and a sequence. +> +> *end example* + + + +> *Note*: +> +> - A type can be sliceable without being indexable due to the lack of an (accessible) indexer. +> - For a type to be sliceable and/or indexable requires the type to be countable. +> - While the elements of a sequence are ordered by *position* within the sequence the elements themselves need not be ordered by their value, or even orderable. +> +> *end note* + +## 24.2 The Index type + +The `System.Index` type represents an *abstract* index which is either a *from-start index* or a *from-end index*. + +```csharp + public readonly struct Index : IEquatable + { + public int Value { get; } + public bool IsFromEnd { get; } + + public Index(int value, bool fromEnd = false); + + public static implicit operator Index(int value); + public int GetOffset(int length); + public bool Equals(Index other); + } +``` + +`Index` values are constructed from an `int`, specifying the non-negative offset, and a `bool`, indicating whether the offset is from the end (`true`) or start (`false`). If the specified offset is negative an `ArgumentOutOfRangeException` is thrown. + +> *Example* +> +> ```csharp +> Index first = new Index(0, false); // first element index +> var last = new Index(1, true); // last element index +> var past = new Index(0, true); // past-end index +> +> Index invalid = new Index(-1); // throws ArgumentOutOfRangeException +> ``` +> +> *end example* + +There is an implicit conversion from `int` to `Index` which produces from-start indices, and a language-defined unary operator `^` (§hat-operator) from `int` to `Index` which produces from-end indices. + +> *Example* +> +> Using implicit conversions and the unary `^` operator the above examples may be written: +> +> ```csharp +> Index first = 0; // first element index +> var last = ^1; // last element index +> var past = ^0; // past-end index +> ``` +> +> *end example* + +The method `GetOffset` converts from an abstract `Index` value to a concrete `int` index value for a sequence of the specified `length`. If the `Index` value, `I`, is from-end this method returns the same value as `length - I.Value`, otherwise it returns the same value as `I.Value`. + +This method does **not** check that the return value is in the valid range of `0` through `length-1` inclusive. + +> *Note:* No checking is specified as the expected use of the result is to index into a sequence with `length` elements, and that indexing operation is expected to perform the appropriate checks. *end note* + +`Index` implements `IEquatable` and values may be compared for equality based on the abstract value; two `Index` values are equal if and only if the respective `Value` and `IsFromEnd` properties are equal. However `Index` values are not ordered and no other comparison operations are provided. + +> *Note:* `Index` values are unordered as they are abstract indices, it is in general impossible to determine whether a from-end index comes before or after a from start index without reference to a sequence length. Once converted to concrete indices, e.g. by `GetOffset`, those concrete indices are comparable. *end note* + +`Index` values may be directly used in the *argument_list* of an *element_access* expression (§12.8.12) which is: + +- an array access and the target is a single-dimensional array (§12.8.12.2); +- a string access (§string-access) +- an indexer access and the target type has an indexer with corresponding parameters of either `Index` type (§12.8.12.3) or of a type to which `Index` values are implicitly convertible; or +- an indexer access and the target type conforms to a sequence pattern for which implicit `Index` support is specified (§24.4.2). + +## 24.3 The Range type + +The `System.Range` type represents the abstract range of `Index`es from a `Start` index up to, but not including, an `End` index. + +```csharp + public readonly struct Range : IEquatable + { + public Index Start { get; } + public Index End { get; } + + public Range(Index start, Index end); + + public (int Offset, int Length) GetOffsetAndLength(int length); + public bool Equals(Range other); + } +``` + +`Range` values are constructed from two `Index` values. + +> *Example* +> +> The following examples use the implicit conversion from `int` to `Index` (§24.2) and the `^` (§hat-operator) operator to create the `Index` values for each `Range`: +> +> ```csharp +> var firstQuad = new Range(0, 4); // the indices from `0` to `3` +> // int values impicitly convert to `Index` +> var nextQuad = new Range(4, 8); // the indices from `4` to `7` +> var wholeSeq = new Range(0, ^0); // the indices from `0` to `N-1` where `N` is the +> // length of the sequence wholeSeq is used with +> var dropFirst = new Range(1, ^0); // the indices from `1` to `N-1` +> var dropLast = new Range(0, ^1); // the indices from `0` to `N-2` +> var maybeLast = new Range(^1, 6); // the indices from `N-1` to 5 +> var lastTwo = new Range(^2, ^0); // the indices from `N-2` to `N-1` +> ``` +> +> *end example* + +The language-defined operator `..` (§range-operator) creates a `Range` value from `Index` values. + +> *Example* +> +> Using the `..` operator the above examples may be written: +> +> ```csharp +> var firstQuad = 0..4; // the indices from `0` to `3` +> var nextQuad = 4..8; // the indices from `4` to `7` +> var wholeSeq = 0..^0; // the indices from `0` to `N-1` +> var dropFirst = 1..^0; // the indices from `1` to `N-1` +> var dropLast = 0..^1; // the indices from `0` to `N-2` +> var maybeLast = ^1..6; // the indices from `N-1` to 5 +> var lastTwo = ^2..^0; // the indices from `N-2` to `N-1` +> ``` +> +> *end example* + +The operands of `..` are optional, the first defaults to `0`, the second defaults to `^0`. + +> *Example* +> +> Five of the above examples can be shortened by relying on default values for operands: +> +> ```csharp +> var firstQuad = ..4; // the indices from `0` to `3` +> var wholeSeq = ..; // the indices from `0` to `N-1` +> var dropFirst = 1..; // the indices from `1` to `N-1` +> var dropLast = ..^1; // the indices from `0` to `N-2` +> var lastTwo = ^2..; // the indices from `N-2` to `N-1` +> ``` +> +> *end example* + +A `Range` value is *valid* with respect to a length *L* if: + +- the concrete indices with respect to *L* of the `Range` properties `Start` and `End` are in the range 0 to *L*; and +- the concrete index for `Start` is not greater than the concrete index for `End` + +The method `GetOffsetAndLength` with an argument `length` converts an abstract `Range` value to a concrete `Range` value represented by tuple. If the `Range` is not valid with respect to `length` the method throws `ArgumentOutOfRangeException`. + +The returned concrete `Range` tuple is a pair of the form `(S, N)` where: + +- `S` is the starting offset of the range, being the concrete index for the `Start` property of the `Range`; and +- `N` is the number of items in the range, being the difference between the concrete indices for the `End` and `Start` properties; +- both values being calculated with respect to `length`. + +A concrete range value is *empty* if `N` is zero. An empty concrete range may have an `S` value equal to concrete past-end index (§24.1), a non-empty range may not. When a `Range` which is used to slice (§24.1) a collection is valid and empty with respect to that collection then the resulting slice is an empty collection. + +> *Note:* A consequence of the above is that a `Range` value which is valid and empty with respect to a `length` of zero may be used to slice an empty collection and results in an empty slice. This differs from indexing which throws an exception if the collection is empty. *end note** + + + +> *Example* +> +> Using the variables defined above with `GetOffSetAndLength(6)`: +> +> ```csharp +> var (ix0, len0) = firstQuad.GetOffsetAndLength(6); // ix0 = 0, len0 = 4 +> var (ix1, len1) = nextQuad.GetOffsetAndLength(6); // throws ArgumentOutOfRangeException +> // as range crosses sequence end +> var (ix2, len2) = wholeSeq.GetOffsetAndLength(6); // ix2 = 0, len2 = 6 +> var (ix3, len3) = dropFirst.GetOffsetAndLength(6); // ix3 = 1, len3 = 5 +> var (ix4, len4) = dropLast.GetOffsetAndLength(6); // ix4 = 0, len4 = 5 +> var (ix5, len5) = maybeLast.GetOffsetAndLength(6); // ix5 = 5, len5 = 1 +> var (ix6, len6) = lastTwo.GetOffsetAndLength(6); // ix6 = 4, len6 = 2 +> ``` + +`Range` implements `IEquatable` and values may be compared for equality based on the abstract value; two `Range` values are equal if and only if the abstract values of the respective `Start` and `End` properties are equal (§24.2). However `Range` values are not ordered and no other comparison operations are provided. + +> *Note:* `Range` values are unordered both as they are abstract and there is no unique ordering relation. Once converted to a concrete start and length, e.g. by `GetOffsetAndLength`, an ordering relation could be defined. *end note* + +`Range` values can be directly used in the *argument_list* of an *element_access* expression (§12.8.12) which is: + +- an array access and the target is a single-dimensional array (§12.8.12.2); +- a string access (§string-access); +- an indexer access and the target type has an indexer with corresponding parameters of either `Range` type (§12.8.12.3) or of a type to which `Range` values are implicitly convertible; or +- an indexer access (§12.8.12.3) and the target type conforms to a sequence pattern for which implicit `Range` support is specified (§24.4.3). + +## 24.4 Pattern-based implicit support for Index and Range + +### 24.4.1 General + +If an *element_access* expression (§12.8.12) of the form `E[A]`; where `E` has type `T` and `A` is a single expression implicitly convertible to `Index` or `Range`; fails to be identified as: + +- an array access (§12.8.12.2), +- a string access (§string-access), or +- an indexer access (§12.8.12.3) as `T` provides no suitable accessible indexer + +then implicit support for the expression is provided if `T` conforms to a particular pattern. If `T` does not conform to this pattern then a compile-time error occurs. + +### 24.4.2 Implicit Index support + +If in any context an *element_access* expression (§12.8.12) of the form `E[A]`; where `E` has type `T` and `A` is a single expression implicitly convertible to `Index`; is not valid (§24.4.1) then if in the same context: + +- `T` provides accessible members qualifying it as a *sequence* (§24.1); and +- the expression `E[0]` is valid and uses the same indexer that qualifies `T` as a sequence + +then the expression `E[A]` shall be implicitly supported. + +Without otherwise constraining implementations of this Standard the order of evaluation of the expression shall be equivalent to: + +1. `E` is evaluated; +2. `A` is evaluated; +3. the countable property of `T` is evaluated, if required by the implementation; +4. the get or set accessor of the `int` based indexer of `T` that would be used by `E[0]` in the same context is invoked. + +### 24.4.3 Implicit Range support + +If in any context an *element_access* expression (§12.8.12) of the form `E[A]`; where `E` has type `T` and `A` is a single expression implicitly convertible to `Range`; is not valid (§24.4.1) then if in the same context: + +- `T` provides accessible members qualifying it as both *countable* and *sliceable* (§24.1) + +then the expression `E[A]` shall be implicitly supported. + +Without otherwise constraining implementations of this Standard the order of evaluation of the expression shall be equivalent to: + +1. `E` is evaluated; +2. `A` is evaluated; +3. the countable property of `T` is evaluated, if required by the implementation; +4. the `Slice` method of `T` is invoked. diff --git a/standard/standard-library.md b/standard/standard-library.md index 9e8efdac0..fc0dc2b44 100644 --- a/standard/standard-library.md +++ b/standard/standard-library.md @@ -36,6 +36,12 @@ namespace System public ArgumentException(string? message, Exception? innerException); } + public class ArgumentOutOfRangeException : ArgumentException + { + public ArgumentOutOfRangeException(string? paramName); + public ArgumentOutOfRangeException(string? paramName, string? message); + } + public class ArithmeticException : Exception { public ArithmeticException(); @@ -130,6 +136,11 @@ namespace System void Dispose(); } + public interface IEquatable + { + bool Equals(T? other); + } + public interface IFormattable { } public sealed class IndexOutOfRangeException : Exception @@ -396,6 +407,164 @@ namespace System public OperationCanceledException(string? message, Exception? innerException); } + /// + /// A read-only value type which represents an abstract + /// index to be used with collections. + /// - The Index can be relative to the start or end of a + /// collection. + /// - An Index can be converted to a zero-based concrete + /// from-start index to be used with a collection + /// of some specified length. + /// - Equality between Index values is provided, however + /// unlike concrete indices they are not ordered. + /// - Array and String element access support indexing + /// with Index values. + /// + public readonly struct Index : IEquatable + { + /// + /// Construct an Index from an integer value and a + /// boolean indicating whether the value is relative + /// to the end (true) or start (false). + /// + /// + /// The value, must be ≥ 0. + /// + /// + /// Optional boolean indicating whether the Index is + /// relative to the end (true) or start (false). + /// The default value is false. + /// + /// + /// Thrown if value < 0. + /// + /// + /// If the Index is relative to the start then: + /// - the value 0 refers to the first element. + /// If the Index is relative to the end then: + /// - the value 1 refers to the last element; and + /// - the value 0 refers to beyond last element. + /// + public Index(int value, bool fromEnd = false); + + /// + /// Implicit conversion from integer to a + /// from-start Index. + /// + /// + /// The predefined operator: + /// Index operator ^(int value); + /// is provided to convert from integer to a + /// from-end Index. + /// + public static implicit operator Index(int value); + + /// + /// Return the value. + /// + public int Value { get; } + + /// + /// Return whether the Index is relative to + /// the end (true) or start (false). + /// + public bool IsFromEnd { get; } + + /// + /// Return a concrete from-start index for a + /// given collection length. + /// + /// + /// The length of the collection that the index + /// will be used with. + /// + /// + /// This method performs no sanity checking and + /// will never throw an IndexOutOfRangeException. + /// It is expected that the returned index will be + /// used with a collection which will do validation. + /// + public int GetOffset(int length); + + /// + /// Indicates whether the current Index value is + /// equal to another Index value. + /// + /// + /// The value to compare with this Index. + /// + public bool Equals(Index other); + } + + /// + /// A read-only value type which represents a range of + /// abstract indices to be used with collections. + /// - The Range has two Index properties, Start and End. + /// - A Range can be converted to a concrete index from + /// the start and a length value to be used with a + /// collection of some specified length. + /// - Equality between Range values is provided, + /// however they are not ordered. + /// - Array and String element access supports indexing + /// with Range values, returning a sub-array/substring + /// of the indexed value respectively. + /// + public readonly struct Range : IEquatable + { + /// + /// Construct a Range from two Index values. + /// + /// + /// The inclusive Index value for the start + /// of the range. + /// + /// + /// The exclusive Index value for the end + /// of the range. + /// + /// As Index values represent unordered abstract + /// indices no sanity checking can be performed + /// on the resultant Range value, + /// ". + /// + /// The predefined operator: + /// Range operator ..(Index start, Index end); + /// also exists to create a Range value. + /// + public Range(Index start, Index end); + + /// Return the starting Index. + public Index Start { get; } + + /// Return the ending Index. + public Index End { get; } + + /// + /// Return a concrete from-start index and the + /// range length for a given collection length. + /// + /// + /// The length of the collection that the result + /// will be used with. + /// + /// + /// Thrown if the range is not valid wrt length. + /// + /// + /// A tuple consisting of an index value and range length + /// + public (int Offset, int Length) GetOffsetAndLength(int length); + + /// + /// Indicates whether the current Range value is equal + /// to another Range value. + /// + /// + /// The value to compare with this Range. + /// + public bool Equals(Range other); + } + public readonly ref struct ReadOnlySpan { public int Length { get; } @@ -1105,6 +1274,7 @@ The following library types are referenced in this specification. The full names - `global::System.Action` - `global::System.ArgumentException` +- `global::System.ArgumentOutOfRangeException` - `global::System.ArithmeticException` - `global::System.Array` - `global::System.ArrayTypeMisMatchException` @@ -1124,7 +1294,9 @@ The following library types are referenced in this specification. The full names - `global::System.GC` - `global::System.IAsyncDisposable` - `global::System.IDisposable` +- `global::System.IEquatable` - `global::System.IFormattable` +- `global::System.Index` - `global::System.IndexOutOfRangeException` - `global::System.Int16` - `global::System.Int32` @@ -1140,6 +1312,7 @@ The following library types are referenced in this specification. The full names - `global::System.OperationCanceledException` - `global::System.OutOfMemoryException` - `global::System.OverflowException` +- `global::System.Range` - `global::System.ReadOnlySpan` - `global::System.SByte` - `global::System.Single` diff --git a/tools/GrammarTesting/Tests/Parsing/Samples/v6/AllInOneNoPreprocessor-v6-split/part-I/Reference/sample.gruntree.red.txt b/tools/GrammarTesting/Tests/Parsing/Samples/v6/AllInOneNoPreprocessor-v6-split/part-I/Reference/sample.gruntree.red.txt index 2b6bc6914..1f0eb4e20 100644 --- a/tools/GrammarTesting/Tests/Parsing/Samples/v6/AllInOneNoPreprocessor-v6-split/part-I/Reference/sample.gruntree.red.txt +++ b/tools/GrammarTesting/Tests/Parsing/Samples/v6/AllInOneNoPreprocessor-v6-split/part-I/Reference/sample.gruntree.red.txt @@ -598,7 +598,7 @@ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ * ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ -⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ range_expression ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ number diff --git a/tools/GrammarTesting/Tests/Parsing/Samples/v6/AllInOneNoPreprocessor-v6-split/part-I/Reference/sample.tree.red.txt b/tools/GrammarTesting/Tests/Parsing/Samples/v6/AllInOneNoPreprocessor-v6-split/part-I/Reference/sample.tree.red.txt index b2451249c..0faf8849b 100644 --- a/tools/GrammarTesting/Tests/Parsing/Samples/v6/AllInOneNoPreprocessor-v6-split/part-I/Reference/sample.tree.red.txt +++ b/tools/GrammarTesting/Tests/Parsing/Samples/v6/AllInOneNoPreprocessor-v6-split/part-I/Reference/sample.tree.red.txt @@ -1 +1 @@ -(prog (compilation_unit (namespace_declaration namespace (qualified_identifier (identifier My)) (namespace_body { (namespace_member_declaration (enum_declaration (attributes (attribute_section [ (attribute_target_specifier (attribute_target (identifier type)) :) (attribute_list (identifier Flags)) ])) (enum_modifier public) enum (identifier E) (enum_body { (enum_member_declarations (enum_member_declaration (identifier A)) , (enum_member_declaration (identifier B) = (constant_expression (identifier A))) , (enum_member_declaration (identifier C) = (constant_expression (additive_expression (additive_expression (literal 2)) + (multiplicative_expression (identifier A))))) , (enum_member_declaration (identifier D))) , }))) (namespace_member_declaration (delegate_declaration (delegate_modifier public) delegate (return_type void) (delegate_header (identifier Delegate) ( (parameter_list (fixed_parameter (type (class_type object)) (identifier P))) ) ;))) (namespace_member_declaration (namespace_declaration namespace (qualified_identifier (identifier Test)) (namespace_body { (using_directive (using_namespace_directive using (namespace_name (identifier System)) ;)) (using_directive (using_namespace_directive using (namespace_name (namespace_or_type_name (identifier System) . (identifier Collections))) ;)) (namespace_member_declaration (class_declaration (class_modifier public) class (identifier Список) (class_body { (class_member_declaration (method_declaration (method_modifiers (method_modifier (ref_method_modifier public)) (method_modifier (ref_method_modifier static))) (return_type (identifier IEnumerable)) (method_header (member_name (identifier Power)) ( (parameter_list (fixed_parameters (fixed_parameter (type (integral_type int)) (identifier number)) , (fixed_parameter (type (integral_type int)) (identifier exponent)))) )) (method_body (block { (statement_list (statement (declaration_statement (local_variable_declaration (explicitly_typed_local_variable_declaration (type (identifier Список)) (explicitly_typed_local_variable_declarators (explicitly_typed_local_variable_declarator (identifier Список) = (local_variable_initializer (object_creation_expression new (type (identifier Список)) ( ))))))) ;)) (statement (expression_statement (statement_expression (invocation_expression (primary_expression (member_access (primary_expression (identifier Список)) . (identifier Main))) ( ))) ;)) (statement (declaration_statement (local_variable_declaration (explicitly_typed_local_variable_declaration (type (integral_type int)) (explicitly_typed_local_variable_declarators (explicitly_typed_local_variable_declarator (identifier counter) = (local_variable_initializer (parenthesized_expression ( (expression (additive_expression (additive_expression (literal 0)) + (multiplicative_expression (literal 0)))) ))))))) ;)) (statement (declaration_statement (local_variable_declaration (explicitly_typed_local_variable_declaration (type (integral_type int)) (explicitly_typed_local_variable_declarators (explicitly_typed_local_variable_declarator (identifier אתר) = (local_variable_initializer (literal 0)))))) ;)) (statement (while_statement while ( (boolean_expression (relational_expression (relational_expression (pre_increment_expression ++ (unary_expression (post_increment_expression (primary_expression (identifier counter)) ++)))) < (shift_expression (pre_decrement_expression -- (unary_expression (post_decrement_expression (primary_expression (identifier exponent)) --)))))) ) (embedded_statement (block { (statement_list (statement (expression_statement (statement_expression (assignment (unary_expression (identifier result)) (assignment_operator =) (expression (additive_expression (additive_expression (additive_expression (multiplicative_expression (multiplicative_expression (identifier result)) * (unary_expression (identifier number)))) + (multiplicative_expression (unary_expression + (unary_expression (post_increment_expression (primary_expression (post_increment_expression (primary_expression (identifier number)) ++)) ++))))) + (multiplicative_expression (identifier number)))))) ;)) (statement (yield_statement yield return (expression (identifier result)) ;))) }))))) })))) (class_member_declaration (method_declaration (method_modifiers (ref_method_modifier static)) (return_type void) (method_header (member_name (identifier Main)) ( )) (method_body (block { (statement_list (foreach_statement foreach ( (local_variable_type (integral_type int)) (identifier i) in (expression (invocation_expression (primary_expression (identifier Power)) ( (argument_list (argument (literal 2)) , (argument (literal 8))) ))) ) (embedded_statement (block { (statement_list (expression_statement (statement_expression (invocation_expression (primary_expression (member_access (primary_expression (identifier Console)) . (identifier Write))) ( (argument_list (argument (literal "{0} ")) , (argument (identifier i))) ))) ;)) })))) })))) (class_member_declaration (method_declaration (method_modifiers (method_modifier async)) (return_type void) (method_header (member_name (identifier Wait)) ( )) (method_body (block { (statement_list (expression_statement (statement_expression (await_expression await (unary_expression (invocation_expression (primary_expression (member_access (primary_expression (member_access (primary_expression (member_access (primary_expression (member_access (primary_expression (identifier System)) . (identifier Threading))) . (identifier Tasks))) . (identifier Task))) . (identifier Delay))) ( (argument_list (literal 0)) ))))) ;)) })))) (class_member_declaration (method_declaration method_modifiers (return_type void) (method_header (member_name (identifier AsyncAnonymous)) ( )) (method_body (block { (statement_list (declaration_statement (local_variable_declaration (implicitly_typed_local_variable_declaration var (implicitly_typed_local_variable_declarator (identifier task) = (expression (invocation_expression (primary_expression (member_access (primary_expression (member_access (primary_expression (identifier Task)) . (identifier Factory))) . (identifier StartNew))) ( (argument_list (lambda_expression async (anonymous_function_signature (explicit_anonymous_function_signature ( ))) => (anonymous_function_body (block { (statement_list (return_statement return (expression (await_expression await (unary_expression (invocation_expression (primary_expression (member_access (primary_expression (object_creation_expression new (type (identifier WebClient)) ( ))) . (identifier DownloadStringTaskAsync))) ( (argument_list (literal "http://example.com")) ))))) ;)) })))) )))))) ;)) })))) }))) }))) })))) +(prog (compilation_unit (namespace_declaration namespace (qualified_identifier (identifier My)) (namespace_body { (namespace_member_declaration (enum_declaration (attributes (attribute_section [ (attribute_target_specifier (attribute_target (identifier type)) :) (attribute_list (identifier Flags)) ])) (enum_modifier public) enum (identifier E) (enum_body { (enum_member_declarations (enum_member_declaration (identifier A)) , (enum_member_declaration (identifier B) = (constant_expression (identifier A))) , (enum_member_declaration (identifier C) = (constant_expression (additive_expression (additive_expression (literal 2)) + (multiplicative_expression (identifier A))))) , (enum_member_declaration (identifier D))) , }))) (namespace_member_declaration (delegate_declaration (delegate_modifier public) delegate (return_type void) (delegate_header (identifier Delegate) ( (parameter_list (fixed_parameter (type (class_type object)) (identifier P))) ) ;))) (namespace_member_declaration (namespace_declaration namespace (qualified_identifier (identifier Test)) (namespace_body { (using_directive (using_namespace_directive using (namespace_name (identifier System)) ;)) (using_directive (using_namespace_directive using (namespace_name (namespace_or_type_name (identifier System) . (identifier Collections))) ;)) (namespace_member_declaration (class_declaration (class_modifier public) class (identifier Список) (class_body { (class_member_declaration (method_declaration (method_modifiers (method_modifier (ref_method_modifier public)) (method_modifier (ref_method_modifier static))) (return_type (identifier IEnumerable)) (method_header (member_name (identifier Power)) ( (parameter_list (fixed_parameters (fixed_parameter (type (integral_type int)) (identifier number)) , (fixed_parameter (type (integral_type int)) (identifier exponent)))) )) (method_body (block { (statement_list (statement (declaration_statement (local_variable_declaration (explicitly_typed_local_variable_declaration (type (identifier Список)) (explicitly_typed_local_variable_declarators (explicitly_typed_local_variable_declarator (identifier Список) = (local_variable_initializer (object_creation_expression new (type (identifier Список)) ( ))))))) ;)) (statement (expression_statement (statement_expression (invocation_expression (primary_expression (member_access (primary_expression (identifier Список)) . (identifier Main))) ( ))) ;)) (statement (declaration_statement (local_variable_declaration (explicitly_typed_local_variable_declaration (type (integral_type int)) (explicitly_typed_local_variable_declarators (explicitly_typed_local_variable_declarator (identifier counter) = (local_variable_initializer (parenthesized_expression ( (expression (additive_expression (additive_expression (literal 0)) + (multiplicative_expression (literal 0)))) ))))))) ;)) (statement (declaration_statement (local_variable_declaration (explicitly_typed_local_variable_declaration (type (integral_type int)) (explicitly_typed_local_variable_declarators (explicitly_typed_local_variable_declarator (identifier אתר) = (local_variable_initializer (literal 0)))))) ;)) (statement (while_statement while ( (boolean_expression (relational_expression (relational_expression (pre_increment_expression ++ (unary_expression (post_increment_expression (primary_expression (identifier counter)) ++)))) < (shift_expression (pre_decrement_expression -- (unary_expression (post_decrement_expression (primary_expression (identifier exponent)) --)))))) ) (embedded_statement (block { (statement_list (statement (expression_statement (statement_expression (assignment (unary_expression (identifier result)) (assignment_operator =) (expression (additive_expression (additive_expression (additive_expression (multiplicative_expression (multiplicative_expression (identifier result)) * (range_expression (identifier number)))) + (multiplicative_expression (unary_expression + (unary_expression (post_increment_expression (primary_expression (post_increment_expression (primary_expression (identifier number)) ++)) ++))))) + (multiplicative_expression (identifier number)))))) ;)) (statement (yield_statement yield return (expression (identifier result)) ;))) }))))) })))) (class_member_declaration (method_declaration (method_modifiers (ref_method_modifier static)) (return_type void) (method_header (member_name (identifier Main)) ( )) (method_body (block { (statement_list (foreach_statement foreach ( (local_variable_type (integral_type int)) (identifier i) in (expression (invocation_expression (primary_expression (identifier Power)) ( (argument_list (argument (literal 2)) , (argument (literal 8))) ))) ) (embedded_statement (block { (statement_list (expression_statement (statement_expression (invocation_expression (primary_expression (member_access (primary_expression (identifier Console)) . (identifier Write))) ( (argument_list (argument (literal "{0} ")) , (argument (identifier i))) ))) ;)) })))) })))) (class_member_declaration (method_declaration (method_modifiers (method_modifier async)) (return_type void) (method_header (member_name (identifier Wait)) ( )) (method_body (block { (statement_list (expression_statement (statement_expression (await_expression await (unary_expression (invocation_expression (primary_expression (member_access (primary_expression (member_access (primary_expression (member_access (primary_expression (member_access (primary_expression (identifier System)) . (identifier Threading))) . (identifier Tasks))) . (identifier Task))) . (identifier Delay))) ( (argument_list (literal 0)) ))))) ;)) })))) (class_member_declaration (method_declaration method_modifiers (return_type void) (method_header (member_name (identifier AsyncAnonymous)) ( )) (method_body (block { (statement_list (declaration_statement (local_variable_declaration (implicitly_typed_local_variable_declaration var (implicitly_typed_local_variable_declarator (identifier task) = (expression (invocation_expression (primary_expression (member_access (primary_expression (member_access (primary_expression (identifier Task)) . (identifier Factory))) . (identifier StartNew))) ( (argument_list (lambda_expression async (anonymous_function_signature (explicit_anonymous_function_signature ( ))) => (anonymous_function_body (block { (statement_list (return_statement return (expression (await_expression await (unary_expression (invocation_expression (primary_expression (member_access (primary_expression (object_creation_expression new (type (identifier WebClient)) ( ))) . (identifier DownloadStringTaskAsync))) ( (argument_list (literal "http://example.com")) ))))) ;)) })))) )))))) ;)) })))) }))) }))) })))) diff --git a/tools/GrammarTesting/Tests/Parsing/Samples/v6/AllInOneNoPreprocessor-v6-split/part-I/Reference/sample.tree.svg b/tools/GrammarTesting/Tests/Parsing/Samples/v6/AllInOneNoPreprocessor-v6-split/part-I/Reference/sample.tree.svg index 994d268a4..bc4e09f5e 100644 --- a/tools/GrammarTesting/Tests/Parsing/Samples/v6/AllInOneNoPreprocessor-v6-split/part-I/Reference/sample.tree.svg +++ b/tools/GrammarTesting/Tests/Parsing/Samples/v6/AllInOneNoPreprocessor-v6-split/part-I/Reference/sample.tree.svg @@ -515,2076 +515,2076 @@ - - -block - - - -delegate_header - - - -explicitly_typed_local_variable_declaration - - - -+ - - - -primary_expression + + +int - - -0 + + +. - - -expression + + +) - - -primary_expression + + +} - - -ref_method_modifier + + +) - - -Factory + + +explicitly_typed_local_variable_declarator - - -{ + + +argument_list - - -Main + + +System - - + + ; - - -Список - - - -delegate_declaration + + +identifier - - -additive_expression + + +Test - - + + declaration_statement - - -identifier + + +void - - -prog + + +object_creation_expression - - -statement_list + + +System - - -identifier + + +method_declaration - - -{ + + +public - - -statement + + ++ - - -async + + +* - - -await + + +primary_expression - - -; + + +primary_expression - - -A + + +member_access - - -identifier + + +local_variable_initializer - - -identifier + + +argument_list - - -, + + +statement_expression - - + + identifier - - -type - - - -attribute_list - - - -+ + + +statement - - -unary_expression + + +literal - - -identifier + + +argument_list - - + + type - - -) - - - + + identifier - - -namespace_name + + +enum_modifier - - -local_variable_declaration + + +constant_expression - - + + method_body - - -class_type - - - -identifier - - - -return_type - - - -invocation_expression - - - -} + + +method_modifiers - - -method_declaration + + +; P - - -method_header - - - -attribute_target_specifier + + +explicitly_typed_local_variable_declarators - - -Wait + + +unary_expression - - -primary_expression + + +. - - -; + + +class_member_declaration - - -expression + + +block - - -literal + + +public - - -; + + +member_access - - -Collections + + +identifier - - -literal + + +local_variable_declaration - - -explicitly_typed_local_variable_declarators + + +type - - -return_type + + +identifier - - -delegate + + +invocation_expression + + + +assignment + + + +member_name + + + +identifier + + + +argument + + + +identifier + + + +C + + + +, + + + +. + + + +ref_method_modifier + + + +class_type + + + +Список + + + +identifier parameter_list - - -expression_statement + + +explicitly_typed_local_variable_declarators - - -System + + +method_body - - -) + + +attribute_target - - + + +fixed_parameter + + + +literal + + + +await_expression + + + +class_member_declaration + + + block - - -identifier + + +0 - - -identifier + + +multiplicative_expression - - -class_modifier + + +public - - -method_modifiers + + +in - - -) + + +A - - -. + + +Tasks - - -< + + +statement - - -pre_increment_expression + + +local_variable_initializer - - -) + + +namespace_member_declaration - - -boolean_expression + + +argument - - -block + + +fixed_parameters - - + + +=> + + + +static + + + +statement_list + + + +identifier + + + primary_expression - - -type + + +int - - -foreach_statement + + +; - - -method_declaration + + +argument - - -method_declaration + + +delegate_modifier - - -return_statement + + +method_modifiers - - -invocation_expression + + +block - - -invocation_expression + + +namespace_declaration - - -} + + +statement_expression - - -using_directive + + +identifier - - -primary_expression + + +local_variable_initializer - - -namespace_body + + +identifier + + + +declaration_statement + + + +++ + + + +multiplicative_expression + + + +await + + + +( + + + +statement_list + + + +expression + + + +, method_modifier - - -Main + + +attribute_section - - -class_member_declaration + + +qualified_identifier - - -( + + +++ - - -identifier + + +) - - -identifier + + +namespace_body - - -additive_expression + + +pre_increment_expression - - -block + + +. - - -parenthesized_expression + + +Delegate - - -) + + +delegate - - -method_header + + +identifier + + + +qualified_identifier { - - -literal - - - -embedded_statement - - - -local_variable_declaration + + +Console - - + + identifier - - -statement + + +method_body - - -primary_expression + + +Task - - -. + + +int - - -public + + +class_declaration - - -primary_expression + + +expression_statement - - -primary_expression + + += - - -local_variable_type + + +class_member_declaration - - -namespace + + +identifier - - -} + + +additive_expression - - -method_modifier + + +( - - -identifier + + +expression_statement - - -embedded_statement + + +( - - + + +attribute_target_specifier + + + ref_method_modifier - - -unary_expression + + +using_namespace_directive - - -enum_member_declaration + + +result - - -) + + +argument_list - - -static + + +member_name - - + + type - - -post_increment_expression - - - -; + + +additive_expression - - -pre_decrement_expression + + +identifier - - -type + + +embedded_statement - - -+ + + +expression_statement - - -0 + + +invocation_expression - - -method_modifiers + + +method_modifier - - -namespace_or_type_name + + +A - - -, + + +} - - -identifier + + +boolean_expression - - -number + + +result - - -statement_list + + +int - - + + identifier - - -statement - - - -) + + +0 - - -member_access + + +{ - - -+ + + +"{0}·" - - -explicitly_typed_local_variable_declarator + + +additive_expression - - -multiplicative_expression + + +number - - -method_body + + +} - - -fixed_parameter + + +E - - -Delay + + +explicitly_typed_local_variable_declarators - - -identifier + + +{ - - -implicitly_typed_local_variable_declarator + + +explicitly_typed_local_variable_declaration - - -enum_member_declarations + + +, - - -assignment + + +return_type - - + + primary_expression - - + + identifier - - -namespace_body - - - -block - - - -method_header - - - -using_directive - - - + + enum_member_declaration - - -void + + +method_modifier - - -local_variable_initializer + + +shift_expression - - -D + + +expression_statement - - + + identifier - - -) - - - -int + + +exponent - - -statement_expression + + +identifier - - -type + + +2 - - + + ( - - -System + + +primary_expression - - -namespace_declaration + + +identifier - - + + integral_type - - -declaration_statement + + +identifier - - -primary_expression + + +8 - - -local_variable_declaration + + +pre_decrement_expression - - -explicitly_typed_local_variable_declarators + + +2 - - -argument + + +anonymous_function_body - - + + +, + + + ( - - -argument + + +statement_list - - -using_namespace_directive + + +yield_statement - - -integral_type + + +expression - - -exponent + + +"http://example.com" - - -unary_expression + + +statement_list - - -result + + +additive_expression - - -primary_expression + + +counter - - -( + + +relational_expression - - -IEnumerable + + +) - - -Console + + +0 - - -} + + +{ - - -identifier + + +explicit_anonymous_function_signature - - -number + + +identifier - - -A + + +( - - -} + + +identifier - - -) + + +await - - -; + + +type - - -foreach + + +declaration_statement - - -explicitly_typed_local_variable_declaration + + +type - - -{ + + +++ - - -identifier + + +number - - -expression_statement + + +using_directive - - + + primary_expression - - -A + + +unary_expression - - -) + + +method_declaration - - + + identifier - - -expression_statement + + +return_type + + + +member_name + + + +, + + + +; + + + +( - - -class + + +member_name - - -new + + +; - - -( + + +literal - - -result + + +void - - + + identifier - - -( + + +; - - + + +argument_list + + + identifier - - -literal + + +invocation_expression { - - -integral_type - - - -int + + +{ - - -namespace_member_declaration + + +. - - -i + + +invocation_expression - - -expression + + +multiplicative_expression - - -) + + +Main - - -literal + + +anonymous_function_signature - - + + identifier - - -compilation_unit + + +( - - -= + + +await_expression - - -statement + + +( - - -integral_type + + += - - -unary_expression + + +expression - - -[ + + +method_header - - -counter + + +statement_expression - - -2 + + +compilation_unit - - -. + + +namespace_member_declaration - - -enum_modifier + + +primary_expression - - -) + + +namespace_name - - -0 + + +identifier - - -StartNew + + +range_expression - - -( + + +using - - -enum_declaration + + +) - - -explicitly_typed_local_variable_declarators + + +while_statement - - -literal + + +DownloadStringTaskAsync - - -multiplicative_expression + + += - - -class_member_declaration + + +block - - -} + + +System - - -method_body + + +) - - --- + + +) - - -method_declaration + + +( - - + + = - - -, - - - -member_access - - - -. - - - -argument_list - - - -post_increment_expression + + +return_statement - - -async + + +literal - - -class_member_declaration + + +embedded_statement - - + + return_type - - -identifier + + +method_declaration - - -Tasks + + +primary_expression - - -Task + + +IEnumerable - - -Threading + + +local_variable_declaration - - -enum + + +additive_expression - - -explicitly_typed_local_variable_declaration + + +{ - - -enum_member_declaration + + +namespace - - -) + + +literal - - + + identifier - - -{ - - - -invocation_expression - - - -statement_list + + +local_variable_declaration - - -statement_expression + + +int - - -local_variable_initializer + + +primary_expression - - -exponent + + +A - - -public + + +-- - - -member_access + + +attributes - - -multiplicative_expression + + +namespace_or_type_name - - -qualified_identifier + + +result - - -invocation_expression + + +explicitly_typed_local_variable_declaration - - -fixed_parameters + + +primary_expression - - -var + + +statement - - -literal + + +parenthesized_expression - - -void + + +i - - -await_expression + + +{ - - -statement_list + + +fixed_parameter - - -} + + +new B - - -, - - - -local_variable_declaration - - - -. - - - -statement_list - - - -qualified_identifier + + +Delay - - -int + + +; - - -declaration_statement + + +member_access - - --- + + +primary_expression - - -class_body + + +statement - - -identifier + + +. - - -expression + + +( - - -E + + +member_access - - -identifier + + +new - - -namespace_member_declaration + + +literal - - -identifier + + ++ + + + +multiplicative_expression post_increment_expression - - -Power + + +identifier - - -task + + +local_variable_type - - -identifier + + +using - - -{ + + +implicitly_typed_local_variable_declaration - - -= + + +parameter_list - - -result + + +enum - - -2 + + +explicitly_typed_local_variable_declaration - - -( + + +method_header - - -expression_statement + + +var - - -void + + +async - - -) + + +namespace_body - - -member_access + + +; - - -( + + +object_creation_expression - - -anonymous_function_body + + +identifier - - -fixed_parameter + + +enum_member_declaration - - -multiplicative_expression + + +-- - - -( + + +) - - + + +} + + + identifier - - -void + + +( - - -explicitly_typed_local_variable_declarator + + +statement_list - - -additive_expression + + +( - - -identifier + + +Список - - -anonymous_function_signature + + +class_body - - -method_modifier + + +Список - - -object + + +unary_expression - - -] + + +number - - -statement + + +constant_expression - - + + +integral_type + + + +primary_expression + + + ( - - -number + + +primary_expression - - -argument + + +. - - -literal + + +lambda_expression - - -unary_expression + + +return - - -delegate_modifier + + +member_access - - -identifier + + +integral_type - - -explicitly_typed_local_variable_declarator + + +type - - + + identifier - - -attributes - - - -declaration_statement + + +identifier type - - -{ - - - -method_body - - - -{ - - - -argument_list - - - -identifier + + +namespace_member_declaration - - -; + + +integral_type - - -constant_expression + + +namespace_declaration - - -argument + + +Power - - -i + + +implicitly_typed_local_variable_declarator - - -enum_member_declaration + + +foreach - - -= + + +StartNew - - -argument_list + + +D - - -; + + +Power - - -identifier + + +Main - - -await_expression + + +literal - - -class_member_declaration + + +; - - -Delegate + + +statement - - + + identifier - - -C - - - -My + + +multiplicative_expression - - -object_creation_expression + + +async - - + + identifier - - -static + + +statement_list - - -, + + +identifier - - -0 + + +using_directive - - -expression + + +} - - -literal + + +Write - - -statement_expression + + +method_declaration - - -attribute_section + + +fixed_parameter - - -"{0}·" + + +Список - - -) + + +explicitly_typed_local_variable_declarator - - -primary_expression + + +post_increment_expression - - -using + + +type - - + + member_access - - -Список + + +method_modifiers - - + + identifier - - -. + + +enum_member_declarations - - -enum_body + + +: - - -Список + + +. ( - - + + +identifier + + + ++ - - -( + + +identifier - - -member_access + + +block - - -primary_expression + + +Threading אתר - - -int - - - -shift_expression + + +{ - - -++ + + +void - - -. + + +identifier - - -( + + +invocation_expression - - -await + + +static - - -statement + + +primary_expression - - -= + + +Flags - - -: + + +unary_expression - - -using_namespace_directive + + +; - - + + identifier - - -=> - - - + + ) - - -} - - - -fixed_parameter - - - -in + + +) - - -primary_expression + + +prog - - -namespace_member_declaration + + +; - - -relational_expression + + +) - - -++ + + +block - - -number + + +declaration_statement - - -object_creation_expression + + +exponent - - -"http://example.com" + + +literal - - -implicitly_typed_local_variable_declaration + + +unary_expression - - -member_access + + +, - - -while_statement + + +block - - + + identifier - - -return + + +enum_declaration - - -++ + + +primary_expression - - -identifier + + +{ counter - - -method_modifiers - - - -member_name + + +0 - - -namespace_name + + +< - - -yield + + +member_access - - -attribute_target + + +identifier - - -* + + +WebClient - - -int + + +argument - - -= + + +; - - -{ + + +foreach_statement - - -post_decrement_expression + + +statement - - -invocation_expression + + +AsyncAnonymous - - -; + + +. - - -, + + +member_access - - + + identifier - - -argument_list - - - -statement_expression - - - -( - - - -namespace_member_declaration + + ++ - - -new + + ++ - - + + identifier - - -Write + + +expression - - -} + + += + + + +Список - - -unary_expression + + +return - - -unary_expression + + +yield - - -Power + + +[ - - -return_type + + +enum_member_declaration - - -Task + + +return_type - - -; + + +using_namespace_directive - - -ref_method_modifier + + +post_decrement_expression - - -method_header + + +) - - -member_name + + +integral_type - - -, + + +delegate_declaration - - -Test + + +] while - - -integral_type + + +} - - -local_variable_initializer + + +) - - -public + + +attribute_list - - -unary_expression + + +primary_expression - - -identifier + + +method_header - - -additive_expression + + +namespace_name - - -AsyncAnonymous + + +Wait - - -statement_list + + +public - - -primary_expression + + +. - - -return + + +delegate_header - - -class_declaration + + +identifier - - -member_access + + +Factory - - + + identifier - - -block - - - -method_modifiers + + +identifier - - -yield_statement + + +} } - - -multiplicative_expression - - - -identifier - - - -( - - - -Список - - - -relational_expression + + +primary_expression - - -DownloadStringTaskAsync + + +) - - -; + + +) - - -WebClient + + +void - - -System + + +enum_body - - -parameter_list + + +unary_expression - - + + primary_expression - - -return_type - - - -+ - - - -statement + + +identifier - - -member_name + + +member_access - - -constant_expression + + +number - - -identifier + + +class_modifier - - -. + + +post_increment_expression - - -explicit_anonymous_function_signature + + +My - - -namespace_declaration + + +Task - - -assignment_operator + + +unary_expression - - -type + + +i - - -argument_list + + +class - - -; + + +invocation_expression - - -identifier + + +object - - -block + + +class_member_declaration additive_expression - - + + +return_type + + + +expression + + + identifier - - -{ + + += - - -; + + +) - - -public + + +relational_expression - - -type + + +multiplicative_expression - - -member_name + + +primary_expression - - -using + + +literal - - -Flags + + +, - - -identifier + + +ref_method_modifier - - -8 + + +} - - + + +expression + + + +additive_expression + + + +; + + + +method_header + + + identifier - - -expression + + +type - - -= + + +explicitly_typed_local_variable_declarator - - + + identifier - - -multiplicative_expression + + +} - - + + ) - - -Список + + +local_variable_declaration - - -member_access + + +method_modifiers - - -additive_expression + + +statement - - -primary_expression + + += - - -additive_expression + + +} - - -lambda_expression + + +identifier + + + +enum_member_declaration + + + +{ + + + ++ + + + +task namespace - - -} - - - -. + + +statement_expression - - + + identifier - - -. + + +statement_list - - -primary_expression + + +method_body - - + + ( - - -statement_list + + +namespace_member_declaration + + + +( + + + +assignment_operator + + + +Collections \ No newline at end of file diff --git a/tools/GrammarTesting/Tests/Parsing/Samples/v6/AllInOneNoPreprocessor-v6-split/part-O/Reference/sample.gruntree.red.txt b/tools/GrammarTesting/Tests/Parsing/Samples/v6/AllInOneNoPreprocessor-v6-split/part-O/Reference/sample.gruntree.red.txt index 318651ca2..0478900c7 100644 --- a/tools/GrammarTesting/Tests/Parsing/Samples/v6/AllInOneNoPreprocessor-v6-split/part-O/Reference/sample.gruntree.red.txt +++ b/tools/GrammarTesting/Tests/Parsing/Samples/v6/AllInOneNoPreprocessor-v6-split/part-O/Reference/sample.gruntree.red.txt @@ -845,7 +845,7 @@ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ * ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ -⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ range_expression ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ i @@ -854,7 +854,7 @@ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ / ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ -⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ range_expression ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ i @@ -863,7 +863,7 @@ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ % ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ -⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ range_expression ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ i diff --git a/tools/GrammarTesting/Tests/Parsing/Samples/v6/AllInOneNoPreprocessor-v6-split/part-O/Reference/sample.tree.red.txt b/tools/GrammarTesting/Tests/Parsing/Samples/v6/AllInOneNoPreprocessor-v6-split/part-O/Reference/sample.tree.red.txt index 0b336426c..4dcda1537 100644 --- a/tools/GrammarTesting/Tests/Parsing/Samples/v6/AllInOneNoPreprocessor-v6-split/part-O/Reference/sample.tree.red.txt +++ b/tools/GrammarTesting/Tests/Parsing/Samples/v6/AllInOneNoPreprocessor-v6-split/part-O/Reference/sample.tree.red.txt @@ -1 +1 @@ -(prog (compilation_unit (namespace_declaration namespace (qualified_identifier (identifier Comments) . (identifier XmlComments) . (identifier UndocumentedKeywords)) (namespace_body { (namespace_member_declaration (class_declaration class (identifier (contextual_keyword yield)) (class_body { (class_member_declaration (method_declaration method_modifiers (return_type void) (method_header (member_name (identifier Params)) ( (parameter_list (fixed_parameters (fixed_parameter (parameter_modifier (parameter_mode_modifier ref)) (type (contextual_keyword dynamic)) (identifier a)) , (fixed_parameter (parameter_modifier (parameter_mode_modifier out)) (type (contextual_keyword dynamic)) (identifier b))) , (parameter_array params (array_type (non_array_type (contextual_keyword dynamic)) (rank_specifier [ ])) (identifier c))) )) (method_body (block { })))) (class_member_declaration (method_declaration method_modifiers (return_type void) (method_header (member_name (identifier Params)) ( (parameter_list (fixed_parameters (fixed_parameter (parameter_modifier (parameter_mode_modifier out)) (type (contextual_keyword dynamic)) (identifier a) (default_argument = (expression (literal 2)))) , (fixed_parameter (parameter_modifier (parameter_mode_modifier ref)) (type (contextual_keyword dynamic)) (identifier c) (default_argument = (expression (explictly_typed_default default ( (type (contextual_keyword dynamic)) )))))) , (parameter_array params (array_type (non_array_type (contextual_keyword dynamic)) (rank_specifier [ ]) (rank_specifier [ ])) (identifier c))) )) (method_body (block { })))) (class_member_declaration (method_declaration (method_modifiers (method_modifier (ref_method_modifier public)) (method_modifier (ref_method_modifier override))) (return_type (class_type string)) (method_header (member_name (identifier ToString)) ( )) (method_body (block { (statement_list (return_statement return (expression (invocation_expression (primary_expression (base_access base . (identifier ToString))) ( ))) ;)) })))) (class_member_declaration (method_declaration (method_modifiers (method_modifier (ref_method_modifier public)) partial) (return_type void) (method_header (member_name (identifier OnError)) ( )) (method_body ;))) (class_member_declaration (method_declaration (method_modifiers (method_modifier (ref_method_modifier public)) partial) (return_type void) (method_header (member_name (identifier method)) ( )) (method_body (block { (statement_list (statement (declaration_statement (local_variable_declaration (explicitly_typed_local_variable_declaration (type (array_type (non_array_type (nullable_value_type (non_nullable_value_type (integral_type int)) (nullable_type_annotation ?))) (rank_specifier [ ]))) (explicitly_typed_local_variable_declarators (explicitly_typed_local_variable_declarator (identifier a) = (local_variable_initializer (array_creation_expression new (non_array_type (nullable_value_type (non_nullable_value_type (integral_type int)) (nullable_type_annotation ?))) [ (expression_list (literal 5)) ])))))) ;)) (statement (declaration_statement (local_variable_declaration (explicitly_typed_local_variable_declaration (type (array_type (non_array_type (integral_type int)) (rank_specifier [ ]))) (explicitly_typed_local_variable_declarators (explicitly_typed_local_variable_declarator (identifier (contextual_keyword var)) = (local_variable_initializer (array_initializer { (variable_initializer_list (variable_initializer (literal 1)) , (variable_initializer (literal 2)) , (variable_initializer (literal 3)) , (variable_initializer (literal 4)) , (variable_initializer (literal 5))) })))))) ;)) (statement (declaration_statement (local_variable_declaration (explicitly_typed_local_variable_declaration (type (integral_type int)) (explicitly_typed_local_variable_declarators (explicitly_typed_local_variable_declarator (identifier i) = (local_variable_initializer (element_access (primary_expression (identifier a)) [ (argument_list (identifier i)) ])))))) ;)) (statement (declaration_statement (local_variable_declaration (explicitly_typed_local_variable_declaration (type (namespace_or_type_name (identifier Foo) (type_argument_list < (type_argument (identifier T)) >))) (explicitly_typed_local_variable_declarators (explicitly_typed_local_variable_declarator (identifier f) = (local_variable_initializer (object_creation_expression new (type (namespace_or_type_name (identifier Foo) (type_argument_list < (type_argument (integral_type int)) >))) ( ))))))) ;)) (statement (expression_statement (statement_expression (invocation_expression (primary_expression (member_access (primary_expression (identifier f)) . (identifier method))) ( ))) ;)) (statement (expression_statement (statement_expression (assignment (unary_expression (identifier i)) (assignment_operator =) (expression (inclusive_or_expression (inclusive_or_expression (and_expression (and_expression (additive_expression (additive_expression (additive_expression (identifier i)) + (multiplicative_expression (identifier i))) - (multiplicative_expression (multiplicative_expression (multiplicative_expression (multiplicative_expression (identifier i)) * (unary_expression (identifier i))) / (unary_expression (identifier i))) % (unary_expression (identifier i))))) & (equality_expression (identifier i)))) | (exclusive_or_expression (exclusive_or_expression (identifier i)) ^ (and_expression (identifier i))))))) ;)) (statement (declaration_statement (local_variable_declaration (explicitly_typed_local_variable_declaration (type (simple_type bool)) (explicitly_typed_local_variable_declarators (explicitly_typed_local_variable_declarator (identifier b) = (local_variable_initializer (inclusive_or_expression (inclusive_or_expression (and_expression (and_expression (boolean_literal true)) & (equality_expression (boolean_literal false)))) | (exclusive_or_expression (exclusive_or_expression (boolean_literal true)) ^ (and_expression (boolean_literal false))))))))) ;))) })))) }))) })))) +(prog (compilation_unit (namespace_declaration namespace (qualified_identifier (identifier Comments) . (identifier XmlComments) . (identifier UndocumentedKeywords)) (namespace_body { (namespace_member_declaration (class_declaration class (identifier (contextual_keyword yield)) (class_body { (class_member_declaration (method_declaration method_modifiers (return_type void) (method_header (member_name (identifier Params)) ( (parameter_list (fixed_parameters (fixed_parameter (parameter_modifier (parameter_mode_modifier ref)) (type (contextual_keyword dynamic)) (identifier a)) , (fixed_parameter (parameter_modifier (parameter_mode_modifier out)) (type (contextual_keyword dynamic)) (identifier b))) , (parameter_array params (array_type (non_array_type (contextual_keyword dynamic)) (rank_specifier [ ])) (identifier c))) )) (method_body (block { })))) (class_member_declaration (method_declaration method_modifiers (return_type void) (method_header (member_name (identifier Params)) ( (parameter_list (fixed_parameters (fixed_parameter (parameter_modifier (parameter_mode_modifier out)) (type (contextual_keyword dynamic)) (identifier a) (default_argument = (expression (literal 2)))) , (fixed_parameter (parameter_modifier (parameter_mode_modifier ref)) (type (contextual_keyword dynamic)) (identifier c) (default_argument = (expression (explictly_typed_default default ( (type (contextual_keyword dynamic)) )))))) , (parameter_array params (array_type (non_array_type (contextual_keyword dynamic)) (rank_specifier [ ]) (rank_specifier [ ])) (identifier c))) )) (method_body (block { })))) (class_member_declaration (method_declaration (method_modifiers (method_modifier (ref_method_modifier public)) (method_modifier (ref_method_modifier override))) (return_type (class_type string)) (method_header (member_name (identifier ToString)) ( )) (method_body (block { (statement_list (return_statement return (expression (invocation_expression (primary_expression (base_access base . (identifier ToString))) ( ))) ;)) })))) (class_member_declaration (method_declaration (method_modifiers (method_modifier (ref_method_modifier public)) partial) (return_type void) (method_header (member_name (identifier OnError)) ( )) (method_body ;))) (class_member_declaration (method_declaration (method_modifiers (method_modifier (ref_method_modifier public)) partial) (return_type void) (method_header (member_name (identifier method)) ( )) (method_body (block { (statement_list (statement (declaration_statement (local_variable_declaration (explicitly_typed_local_variable_declaration (type (array_type (non_array_type (nullable_value_type (non_nullable_value_type (integral_type int)) (nullable_type_annotation ?))) (rank_specifier [ ]))) (explicitly_typed_local_variable_declarators (explicitly_typed_local_variable_declarator (identifier a) = (local_variable_initializer (array_creation_expression new (non_array_type (nullable_value_type (non_nullable_value_type (integral_type int)) (nullable_type_annotation ?))) [ (expression_list (literal 5)) ])))))) ;)) (statement (declaration_statement (local_variable_declaration (explicitly_typed_local_variable_declaration (type (array_type (non_array_type (integral_type int)) (rank_specifier [ ]))) (explicitly_typed_local_variable_declarators (explicitly_typed_local_variable_declarator (identifier (contextual_keyword var)) = (local_variable_initializer (array_initializer { (variable_initializer_list (variable_initializer (literal 1)) , (variable_initializer (literal 2)) , (variable_initializer (literal 3)) , (variable_initializer (literal 4)) , (variable_initializer (literal 5))) })))))) ;)) (statement (declaration_statement (local_variable_declaration (explicitly_typed_local_variable_declaration (type (integral_type int)) (explicitly_typed_local_variable_declarators (explicitly_typed_local_variable_declarator (identifier i) = (local_variable_initializer (element_access (primary_expression (identifier a)) [ (argument_list (identifier i)) ])))))) ;)) (statement (declaration_statement (local_variable_declaration (explicitly_typed_local_variable_declaration (type (namespace_or_type_name (identifier Foo) (type_argument_list < (type_argument (identifier T)) >))) (explicitly_typed_local_variable_declarators (explicitly_typed_local_variable_declarator (identifier f) = (local_variable_initializer (object_creation_expression new (type (namespace_or_type_name (identifier Foo) (type_argument_list < (type_argument (integral_type int)) >))) ( ))))))) ;)) (statement (expression_statement (statement_expression (invocation_expression (primary_expression (member_access (primary_expression (identifier f)) . (identifier method))) ( ))) ;)) (statement (expression_statement (statement_expression (assignment (unary_expression (identifier i)) (assignment_operator =) (expression (inclusive_or_expression (inclusive_or_expression (and_expression (and_expression (additive_expression (additive_expression (additive_expression (identifier i)) + (multiplicative_expression (identifier i))) - (multiplicative_expression (multiplicative_expression (multiplicative_expression (multiplicative_expression (identifier i)) * (range_expression (identifier i))) / (range_expression (identifier i))) % (range_expression (identifier i))))) & (equality_expression (identifier i)))) | (exclusive_or_expression (exclusive_or_expression (identifier i)) ^ (and_expression (identifier i))))))) ;)) (statement (declaration_statement (local_variable_declaration (explicitly_typed_local_variable_declaration (type (simple_type bool)) (explicitly_typed_local_variable_declarators (explicitly_typed_local_variable_declarator (identifier b) = (local_variable_initializer (inclusive_or_expression (inclusive_or_expression (and_expression (and_expression (boolean_literal true)) & (equality_expression (boolean_literal false)))) | (exclusive_or_expression (exclusive_or_expression (boolean_literal true)) ^ (and_expression (boolean_literal false))))))))) ;))) })))) }))) })))) diff --git a/tools/GrammarTesting/Tests/Parsing/Samples/v6/AllInOneNoPreprocessor-v6-split/part-O/Reference/sample.tree.svg b/tools/GrammarTesting/Tests/Parsing/Samples/v6/AllInOneNoPreprocessor-v6-split/part-O/Reference/sample.tree.svg index 515bf538c..febbbbcfa 100644 --- a/tools/GrammarTesting/Tests/Parsing/Samples/v6/AllInOneNoPreprocessor-v6-split/part-O/Reference/sample.tree.svg +++ b/tools/GrammarTesting/Tests/Parsing/Samples/v6/AllInOneNoPreprocessor-v6-split/part-O/Reference/sample.tree.svg @@ -451,1820 +451,1820 @@ - - -rank_specifier + + +type_argument - - + + +class_member_declaration + + + +) + + + identifier - - -3 + + +UndocumentedKeywords - - -exclusive_or_expression + + +array_initializer + + + +inclusive_or_expression + + + +( + + + +type + + + +parameter_modifier array_type - - -explicitly_typed_local_variable_declarators + + +type_argument - - -identifier + + +] - - -; + + +class_type - - -exclusive_or_expression + + +multiplicative_expression - - + + identifier - - -method + + +method_body - - -unary_expression + + += - - -identifier + + +; - - -expression_statement + + +integral_type - - -Params + + +b - - -member_name + + +new - - -nullable_value_type + + +( - - -type + + +parameter_list - - -override + + +multiplicative_expression - - -member_access + + +type - - -out + + +type - - -] + + +method - - -local_variable_declaration + + +identifier - - -parameter_mode_modifier + + +a - - -; + + +dynamic - - -} + + +yield - - -primary_expression + + +2 - - -< + + +explicitly_typed_local_variable_declaration - - -type + + +expression_list - - -< + + +dynamic - - -method_header + + +identifier - - -i + + +non_array_type - - -array_initializer + + +expression - - -inclusive_or_expression + + +default_argument - - -parameter_array + + +method_modifier - - -method_header + + +dynamic - - -rank_specifier + + +explictly_typed_default - - -statement + + +class - - -statement + + +default_argument - - -class_declaration + + +, - - -compilation_unit - - - -method_modifiers - - - -element_access + + +identifier - - + + i - - -true + + +expression - - -Comments + + +prog - - + + ) - - -literal + + +contextual_keyword - - -Foo + + +variable_initializer - - -local_variable_initializer + + +parameter_array - - -integral_type + + +contextual_keyword - - -expression + + +identifier - - -% + + +} - - + + , - - -c - - - -yield - - - -{ - - - -explicitly_typed_local_variable_declarators - - - -fixed_parameter - - - -( - - - -{ - - - -non_array_type - - - -boolean_literal - - - -prog + + +b var - - -ref_method_modifier - - - -; - - - -method_body - - - -[ - - - -type - - - -, - - - -[ - - - -class_type - - - -statement_expression - - - -statement + + += - - -declaration_statement + + +unary_expression - - -T + + +identifier namespace_or_type_name - - -integral_type - - - -statement_expression - - - -unary_expression - - - -method_declaration - - - -base - - - -a + + +i - - -parameter_list + + +expression - - -assignment + + +identifier - - -OnError + + +primary_expression - - -parameter_mode_modifier + + +{ - - -( + + +primary_expression - - -nullable_value_type + + +int - - -) + + +dynamic - - + + non_array_type - - -identifier - - - -] - - - -statement + + +declaration_statement - - -method_modifiers + + +primary_expression - - -method_body + + +return - - -ref_method_modifier + + +argument_list - - + + identifier - - -expression - - - -base_access - - - -type - - - -contextual_keyword - - - -) - - - -{ + + +identifier - - -integral_type + + +XmlComments - - -explicitly_typed_local_variable_declaration + + +out - - -parameter_modifier + + +local_variable_initializer - - -declaration_statement + + +ref - - -expression_list + + +i - - -; + + +member_name - - -Foo + + +method_modifiers - - -fixed_parameter + + +parameter_mode_modifier - - -identifier + + +type - - -) + + +method_modifiers - - + + dynamic - - -] + + +fixed_parameter - - -} + + +Foo - - -namespace + + +identifier - - -true + + +{ - - -method_modifier + + +explicitly_typed_local_variable_declaration - - -5 + + +c - - -void + + +contextual_keyword - - -i + + +namespace_declaration - - -parameter_modifier + + +compilation_unit - - -integral_type + + +{ - - + + = - - -non_array_type + + +block - - -b + + +class_member_declaration - - -parameter_modifier + + +inclusive_or_expression - - -non_array_type + + +{ - - -identifier + + +statement - - -identifier + + +true - - -non_array_type + + +public - - -identifier + + +; local_variable_initializer - - -and_expression - - - -identifier + + +dynamic - - -method_modifier + + +[ - - -? + + +literal - - -inclusive_or_expression + + +parameter_list - - -method_body + + +integral_type - - -, + + +f - - -boolean_literal + + +additive_expression - - -int + + +namespace_member_declaration - - -type_argument_list + + +new - - -1 + + +literal - - -params + + ++ - - -variable_initializer + + +a - - -} + + +parameter_modifier - - -method_declaration + + += - - -declaration_statement + + +, - - + + identifier - - -variable_initializer - - - -XmlComments - - - -type - - - -additive_expression + + +bool - - -expression + + +statement_list - - -UndocumentedKeywords + + +{ - - -) + + +local_variable_initializer - - -( + + +parameter_modifier - - -a + + +1 - - -local_variable_initializer + + +expression - - -variable_initializer + + +rank_specifier - - -- + + +additive_expression - - -multiplicative_expression + + +. - - -and_expression + + +identifier - - -namespace_declaration + + +declaration_statement - - -out + + +int - - + + boolean_literal - - -explicitly_typed_local_variable_declarator + + +Foo + + + +{ ) - - -, + + +params - - -literal + + +statement - - -and_expression + + +partial - - -] + + +i - - -^ + + +5 - - -new + + +method_modifiers - - -dynamic + + +fixed_parameters - - -partial + + +namespace - - -dynamic + + +array_type - - -contextual_keyword + + +boolean_literal - - -i + + +explicitly_typed_local_variable_declaration - - -> + + +and_expression - - -| + + +and_expression - - -class_member_declaration + + +contextual_keyword - - -; + + +method_modifiers - - -contextual_keyword + + +statement - - -literal + + +integral_type - - -inclusive_or_expression + + +identifier - - -. + + +ref_method_modifier - - + + identifier - - -4 + + +identifier - - -public + + +method_body - - -i + + +and_expression - - -= + + +explicitly_typed_local_variable_declaration - - -f + + +local_variable_initializer - - -fixed_parameter + + +local_variable_declaration - - -explicitly_typed_local_variable_declaration + + +a - - -statement + + +explicitly_typed_local_variable_declarators - - + + +] + + + identifier - - -parameter_list + + +> + + + +int + + + +( + + + +nullable_value_type member_name - - -statement_list + + +& + + + +Comments + + + +integral_type } + + +] + + + +and_expression + + + +rank_specifier + + + +* + + + +range_expression + namespace_body - - -contextual_keyword + + +void - - + + +identifier + + + +method_header + + + +{ + + + +[ + + + type - - -variable_initializer + + +identifier - - -namespace_or_type_name + + +range_expression - - -block + + +; - - -local_variable_declaration + + +i - - + + +method_header + + + int - - -. + + +expression_statement - - -{ + + +identifier - - -* + + +ref_method_modifier - - -method_modifier + + +i - - -2 + + +statement_expression - - -identifier + + +. - - -identifier + + +method_modifier - - -= + + +base_access - - -explicitly_typed_local_variable_declaration + + +; - - -nullable_type_annotation + + +statement - - -& + + +method - - -identifier + + +element_access - - -variable_initializer + + +block - - -local_variable_declaration + + +default - - -explicitly_typed_local_variable_declarator + + +non_nullable_value_type - - -parameter_mode_modifier + + +3 - - -[ + + +a - - -primary_expression + + +, - - -return_type + + +array_creation_expression - - -member_name + + +non_array_type - - -( + + +4 - - -default_argument + + +contextual_keyword - - -rank_specifier + + +partial - - + + +explicitly_typed_local_variable_declarator + + + identifier - - -primary_expression + + +) - - -local_variable_initializer + + +method_modifiers - - -i + + +literal + + + +identifier + + + +type_argument_list - - -method_body + + +declaration_statement - - -method_declaration + + +member_name - - -( + + +literal - - -ToString + + +rank_specifier - - -, + + +i - - -additive_expression + + +non_nullable_value_type - - -5 + + +? - - -identifier + + +type - - -contextual_keyword + + +multiplicative_expression - - -explicitly_typed_local_variable_declarators + + +method_declaration - - -method_body + + +ref - - -exclusive_or_expression + + +override invocation_expression - - -invocation_expression + + +literal - - -identifier + + +} - - -identifier + + +} - - -method_modifier + + +method_declaration - - -return + + +parameter_modifier - - -, + + +> - - -, + + +[ - - -explicitly_typed_local_variable_declarator + + +} - - -method_header + + +method_declaration - - -explicitly_typed_local_variable_declarator + + +[ - - -parameter_modifier + + += - - -) + + +type - - -int + + +c - - -int + + +; - - -identifier + + +| - - -= + + +contextual_keyword - - -statement_list + + +exclusive_or_expression - - -ToString + + +fixed_parameters - - -return_type + + +variable_initializer - - -default_argument + + +local_variable_declaration - - -statement + + +int - - -type + + +% - - + + identifier - - -namespace_member_declaration + + +) + + + +2 + + + +parameter_mode_modifier + + + +[ + + + +] ( - - + + +false + + + identifier - - -equality_expression + + +return_statement - - -partial + + +invocation_expression + + + +class_body + + + +nullable_type_annotation - - -block + + +public - - -; + + +method_body - - + + f - - -} - contextual_keyword - - -method_modifiers - - - -string + + +block - - -local_variable_declaration + + +method_body - - -^ + + +assignment - - -return_type + + +simple_type - - -c + + +statement_expression - - -member_name + + +non_array_type - - -literal + + +void - - -explicitly_typed_local_variable_declarators + + +type - - -integral_type + + +& - - -assignment_operator + + +ref_method_modifier - - -dynamic + + +identifier - - + + identifier - - -and_expression + + +T - - -equality_expression + + +parameter_mode_modifier - - -c + + +( - - -{ + + +; - - -class_member_declaration + + +namespace_or_type_name - - -type + + +method_modifier - - -public + + +fixed_parameter - - -nullable_type_annotation + + +void - - -array_type + + +and_expression - - -= + + +Params - - -literal + + +non_array_type - - -identifier + + +local_variable_declaration - - -] + + +method_header - - + + +out + + + +} + + + +explicitly_typed_local_variable_declarators + + + +i + + + identifier - - -multiplicative_expression + + +block - - -array_type + + +/ - - -boolean_literal + + +Params - - -2 + + +identifier - - -primary_expression + + +class_member_declaration - - + + += + + + i - - -false + + +( - - -{ + + +) - - -class_member_declaration + + +statement_list + + + +statement + + + +ToString - - -return_type + + +qualified_identifier - - -/ + + +explicitly_typed_local_variable_declarator - - -identifier + + +additive_expression - - -explicitly_typed_local_variable_declaration + + +local_variable_declaration - - -rank_specifier + + +parameter_array - - -and_expression + + +method_body - - -ref + + +identifier - - -method_modifiers + + +exclusive_or_expression - - -object_creation_expression + + +rank_specifier - - -fixed_parameters + + +statement - - -} + + +variable_initializer_list - - -non_nullable_value_type + + +. - - -literal + + +local_variable_initializer - - -method_header + + +< - - -> + + +parameter_mode_modifier - - -member_name + + +) - - -class_member_declaration + + +nullable_type_annotation - - + + ; - - -simple_type + + +return_type - - -default + + +i - - -] + + +multiplicative_expression - - -type_argument_list + + +identifier expression_statement - - -[ + + +identifier - - -argument_list + + +method_declaration - - -explicitly_typed_local_variable_declarator + + +variable_initializer - - -method + + +variable_initializer - - -multiplicative_expression + + +, - - -statement + + +void - - -? + + +identifier - - -block + + +type - - -declaration_statement + + +range_expression - - -additive_expression + + +array_type - - -identifier + + +literal - - -identifier + + +class_member_declaration - - -identifier + + +statement - - -explicitly_typed_local_variable_declarators + + +boolean_literal - - -void + + +return_type - - -type + + +return_type - - -i + + +; + + + +method_declaration + + + +explicitly_typed_local_variable_declarator ( - - -a + + +] + + + +member_name + + + +variable_initializer - - -i + + +explicitly_typed_local_variable_declarator - - -declaration_statement + + +| - - -literal + + +member_access - - -variable_initializer_list + + +explicitly_typed_local_variable_declarators - - -expression + + +identifier - - -local_variable_declaration + + +nullable_value_type - - -contextual_keyword + + +equality_expression - - -= + + +fixed_parameter - - + + +string + + + type - - -i + + +explicitly_typed_local_variable_declarators - - -. + + +^ - - -b + + +identifier - - -multiplicative_expression + + +class_declaration - - -parameter_array + + += - - -unary_expression + + +, - - -method_modifiers + + +dynamic - - -method_declaration + + +OnError - - -identifier + + +integral_type - - -identifier + + +inclusive_or_expression - - -} + + +( - - -) + + +and_expression - - -multiplicative_expression + + +false - - + + +exclusive_or_expression + + + identifier - - -method_declaration + + +rank_specifier - - -bool + + +explicitly_typed_local_variable_declaration - - -& + + +assignment_operator - - -[ + + +exclusive_or_expression - - -identifier + + +; - - -, + + +contextual_keyword - - -a + + +array_type - - -class_member_declaration + + +) - - -class_body + + +contextual_keyword - - -fixed_parameter + + +5 - - -identifier + + +equality_expression - - -method_header + + +ToString - - -| + + +return_type - - -and_expression + + +) - - -inclusive_or_expression + + +method_header - - -type_argument + + +c - - + + [ - - -type_argument - - - -void + + +explicitly_typed_local_variable_declarators - - -explictly_typed_default + + +public - - -block + + +ref_method_modifier - - + + identifier - - -public - - - -return_type + + +class_member_declaration - - -i + + +, - - -= + + +declaration_statement - - -( + + +method_modifier - - -exclusive_or_expression + + +local_variable_declaration - - + + type - - -parameter_mode_modifier - - - -local_variable_initializer + + +} - - -ref_method_modifier + + +inclusive_or_expression - - -array_type + + +literal - - -; + + +base - - -class + + +i - - -return_statement + + +params - - + + . - - -dynamic + + +[ - - -= + + +, ] - - -contextual_keyword - - - -int - - - -dynamic + + += - - -{ + + +primary_expression - - -[ + + +^ - - -+ + + +member_name - - -array_creation_expression + + +< - - -contextual_keyword + + +explicitly_typed_local_variable_declarator - - + + identifier - - -unary_expression - - - -ref - - - -params - - - -explicitly_typed_local_variable_declaration - - - -new + + +fixed_parameter - - -false + + +method_header - - -; + + +declaration_statement - - + + i - - -( + + +- - - -fixed_parameters + + +return_type - - -qualified_identifier + + +? - - -dynamic + + +object_creation_expression - - -) + + +] - - -rank_specifier + + +type_argument_list - - -Params + + +multiplicative_expression - - -non_nullable_value_type + + +boolean_literal - - -ref_method_modifier + + +( - - -void + + +true + + + +identifier \ No newline at end of file diff --git a/tools/GrammarTesting/Tests/Parsing/Samples/v6/AllInOneNoPreprocessor-v6-split/part-R/Reference/sample.gruntree.red.txt b/tools/GrammarTesting/Tests/Parsing/Samples/v6/AllInOneNoPreprocessor-v6-split/part-R/Reference/sample.gruntree.red.txt index 759035fb6..e86bc5836 100644 --- a/tools/GrammarTesting/Tests/Parsing/Samples/v6/AllInOneNoPreprocessor-v6-split/part-R/Reference/sample.gruntree.red.txt +++ b/tools/GrammarTesting/Tests/Parsing/Samples/v6/AllInOneNoPreprocessor-v6-split/part-R/Reference/sample.gruntree.red.txt @@ -116,7 +116,7 @@ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ * ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ -⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ range_expression ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ literal ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ 3 @@ -136,7 +136,7 @@ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ * ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ -⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ range_expression ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ literal ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ 4 @@ -320,7 +320,7 @@ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ % ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ -⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ range_expression ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ literal ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ 2 diff --git a/tools/GrammarTesting/Tests/Parsing/Samples/v6/AllInOneNoPreprocessor-v6-split/part-R/Reference/sample.tree.red.txt b/tools/GrammarTesting/Tests/Parsing/Samples/v6/AllInOneNoPreprocessor-v6-split/part-R/Reference/sample.tree.red.txt index a0521fec2..26972d351 100644 --- a/tools/GrammarTesting/Tests/Parsing/Samples/v6/AllInOneNoPreprocessor-v6-split/part-R/Reference/sample.tree.red.txt +++ b/tools/GrammarTesting/Tests/Parsing/Samples/v6/AllInOneNoPreprocessor-v6-split/part-R/Reference/sample.tree.red.txt @@ -1 +1 @@ -(prog (compilation_unit (namespace_declaration namespace (qualified_identifier (identifier Comments) . (identifier XmlComments) . (identifier UndocumentedKeywords)) (namespace_body { (namespace_member_declaration (class_declaration class (identifier CSharp6Features) (class_body { (class_member_declaration (method_declaration (method_modifiers (method_modifier async)) (return_type void) (method_header (member_name (identifier Test)) ( )) (method_body (block { (statement_list (statement (expression_statement (statement_expression (invocation_expression (primary_expression (identifier WriteLine)) ( (argument_list (invocation_expression (primary_expression (identifier Sqrt)) ( (argument_list (additive_expression (additive_expression (multiplicative_expression (multiplicative_expression (literal 3)) * (unary_expression (literal 3)))) + (multiplicative_expression (multiplicative_expression (literal 4)) * (unary_expression (literal 4))))) ))) ))) ;)) (statement (expression_statement (statement_expression (invocation_expression (primary_expression (identifier WriteLine)) ( (argument_list (additive_expression (additive_expression (identifier Friday)) - (multiplicative_expression (identifier Monday)))) ))) ;)) (statement (declaration_statement (local_variable_declaration (implicitly_typed_local_variable_declaration var (implicitly_typed_local_variable_declarator (identifier range) = (expression (invocation_expression (primary_expression (identifier Range)) ( (argument_list (argument (literal 5)) , (argument (literal 17))) )))))) ;)) (statement (declaration_statement (local_variable_declaration (implicitly_typed_local_variable_declaration var (implicitly_typed_local_variable_declarator (identifier even) = (expression (invocation_expression (primary_expression (member_access (primary_expression (identifier range)) . (identifier Where))) ( (argument_list (lambda_expression (anonymous_function_signature (identifier i)) => (anonymous_function_body (equality_expression (equality_expression (multiplicative_expression (multiplicative_expression (identifier i)) % (unary_expression (literal 2)))) == (relational_expression (literal 0)))))) )))))) ;)) (statement (declaration_statement (local_variable_declaration (explicitly_typed_local_variable_declaration (type (nullable_value_type (non_nullable_value_type (integral_type int)) (nullable_type_annotation ?))) (explicitly_typed_local_variable_declarators (explicitly_typed_local_variable_declarator (identifier length) = (local_variable_initializer (null_conditional_member_access (primary_expression (identifier customers)) ? . (identifier Length))))))) ;)) (statement (declaration_statement (local_variable_declaration (explicitly_typed_local_variable_declaration (type (identifier Customer)) (explicitly_typed_local_variable_declarators (explicitly_typed_local_variable_declarator (identifier first) = (local_variable_initializer (null_conditional_element_access (primary_expression (identifier customers)) ? [ (argument_list (literal 0)) ])))))) ;)) (statement (declaration_statement (local_variable_declaration (explicitly_typed_local_variable_declaration (type (integral_type int)) (explicitly_typed_local_variable_declarators (explicitly_typed_local_variable_declarator (identifier length) = (local_variable_initializer (null_coalescing_expression (conditional_or_expression (null_conditional_member_access (primary_expression (identifier customers)) ? . (identifier Length))) ?? (null_coalescing_expression (literal 0)))))))) ;)) (statement (declaration_statement (local_variable_declaration (explicitly_typed_local_variable_declaration (type (nullable_value_type (non_nullable_value_type (integral_type int)) (nullable_type_annotation ?))) (explicitly_typed_local_variable_declarators (explicitly_typed_local_variable_declarator (identifier first) = (local_variable_initializer (null_conditional_member_access (primary_expression (null_conditional_member_access (primary_expression (null_conditional_element_access (primary_expression (identifier customers)) ? [ (argument_list (literal 0)) ])) ? . (identifier Orders))) ? . (identifier Count) (dependent_access ( )))))))) ;)) (statement (expression_statement (statement_expression (null_conditional_invocation_expression (null_conditional_member_access (primary_expression (identifier PropertyChanged)) ? . (identifier Invoke)) ( (argument_list (argument (this_access this)) , (argument (identifier args))) ))) ;))) })))) }))) })))) +(prog (compilation_unit (namespace_declaration namespace (qualified_identifier (identifier Comments) . (identifier XmlComments) . (identifier UndocumentedKeywords)) (namespace_body { (namespace_member_declaration (class_declaration class (identifier CSharp6Features) (class_body { (class_member_declaration (method_declaration (method_modifiers (method_modifier async)) (return_type void) (method_header (member_name (identifier Test)) ( )) (method_body (block { (statement_list (statement (expression_statement (statement_expression (invocation_expression (primary_expression (identifier WriteLine)) ( (argument_list (invocation_expression (primary_expression (identifier Sqrt)) ( (argument_list (additive_expression (additive_expression (multiplicative_expression (multiplicative_expression (literal 3)) * (range_expression (literal 3)))) + (multiplicative_expression (multiplicative_expression (literal 4)) * (range_expression (literal 4))))) ))) ))) ;)) (statement (expression_statement (statement_expression (invocation_expression (primary_expression (identifier WriteLine)) ( (argument_list (additive_expression (additive_expression (identifier Friday)) - (multiplicative_expression (identifier Monday)))) ))) ;)) (statement (declaration_statement (local_variable_declaration (implicitly_typed_local_variable_declaration var (implicitly_typed_local_variable_declarator (identifier range) = (expression (invocation_expression (primary_expression (identifier Range)) ( (argument_list (argument (literal 5)) , (argument (literal 17))) )))))) ;)) (statement (declaration_statement (local_variable_declaration (implicitly_typed_local_variable_declaration var (implicitly_typed_local_variable_declarator (identifier even) = (expression (invocation_expression (primary_expression (member_access (primary_expression (identifier range)) . (identifier Where))) ( (argument_list (lambda_expression (anonymous_function_signature (identifier i)) => (anonymous_function_body (equality_expression (equality_expression (multiplicative_expression (multiplicative_expression (identifier i)) % (range_expression (literal 2)))) == (relational_expression (literal 0)))))) )))))) ;)) (statement (declaration_statement (local_variable_declaration (explicitly_typed_local_variable_declaration (type (nullable_value_type (non_nullable_value_type (integral_type int)) (nullable_type_annotation ?))) (explicitly_typed_local_variable_declarators (explicitly_typed_local_variable_declarator (identifier length) = (local_variable_initializer (null_conditional_member_access (primary_expression (identifier customers)) ? . (identifier Length))))))) ;)) (statement (declaration_statement (local_variable_declaration (explicitly_typed_local_variable_declaration (type (identifier Customer)) (explicitly_typed_local_variable_declarators (explicitly_typed_local_variable_declarator (identifier first) = (local_variable_initializer (null_conditional_element_access (primary_expression (identifier customers)) ? [ (argument_list (literal 0)) ])))))) ;)) (statement (declaration_statement (local_variable_declaration (explicitly_typed_local_variable_declaration (type (integral_type int)) (explicitly_typed_local_variable_declarators (explicitly_typed_local_variable_declarator (identifier length) = (local_variable_initializer (null_coalescing_expression (conditional_or_expression (null_conditional_member_access (primary_expression (identifier customers)) ? . (identifier Length))) ?? (null_coalescing_expression (literal 0)))))))) ;)) (statement (declaration_statement (local_variable_declaration (explicitly_typed_local_variable_declaration (type (nullable_value_type (non_nullable_value_type (integral_type int)) (nullable_type_annotation ?))) (explicitly_typed_local_variable_declarators (explicitly_typed_local_variable_declarator (identifier first) = (local_variable_initializer (null_conditional_member_access (primary_expression (null_conditional_member_access (primary_expression (null_conditional_element_access (primary_expression (identifier customers)) ? [ (argument_list (literal 0)) ])) ? . (identifier Orders))) ? . (identifier Count) (dependent_access ( )))))))) ;)) (statement (expression_statement (statement_expression (null_conditional_invocation_expression (null_conditional_member_access (primary_expression (identifier PropertyChanged)) ? . (identifier Invoke)) ( (argument_list (argument (this_access this)) , (argument (identifier args))) ))) ;))) })))) }))) })))) diff --git a/tools/GrammarTesting/Tests/Parsing/Samples/v6/AllInOneNoPreprocessor-v6-split/part-R/Reference/sample.tree.svg b/tools/GrammarTesting/Tests/Parsing/Samples/v6/AllInOneNoPreprocessor-v6-split/part-R/Reference/sample.tree.svg index 8937fa3ad..5a1cdd607 100644 --- a/tools/GrammarTesting/Tests/Parsing/Samples/v6/AllInOneNoPreprocessor-v6-split/part-R/Reference/sample.tree.svg +++ b/tools/GrammarTesting/Tests/Parsing/Samples/v6/AllInOneNoPreprocessor-v6-split/part-R/Reference/sample.tree.svg @@ -307,1244 +307,1244 @@ - - + + +return_type + + + +primary_expression + + + identifier - - -nullable_type_annotation + + +) - - + + +customers + + + = - - + + +qualified_identifier + + + +expression_statement + + + +literal + + + +0 + + + +; + + + identifier - - -3 + + +Test - - + + primary_expression - - -range + + +identifier - - -4 + + +local_variable_declaration + + + +null_conditional_member_access + + + +statement_list + + + +explicitly_typed_local_variable_declarators literal - - -primary_expression - - - -] - - - -i + + +- - - -identifier + + +statement - - -argument_list + + +Invoke additive_expression - - -null_conditional_member_access - - - -type - - - -. - - - -) + + +identifier - - -statement + + +identifier argument_list - - -identifier + + +literal - - -explicitly_typed_local_variable_declarator + + +i - - -expression_statement + + +primary_expression - - + + identifier - - -multiplicative_expression + + += - - -) + + +Orders implicitly_typed_local_variable_declaration - - -primary_expression + + +; - - -type + + +null_conditional_invocation_expression - - -method_body + + +. - - -int + + +nullable_type_annotation - - + + +var + + + +) + + + +; + + + identifier - - -Friday + + +integral_type - - -? + + +identifier - - -= + + +non_nullable_value_type + + + +local_variable_declaration + + + +identifier first - - -argument - - - -statement_list + + +argument_list - - -; + + +local_variable_initializer - - -customers + + +method_header - - -primary_expression - - - -primary_expression - - - -namespace_declaration - - - -literal - - - -non_nullable_value_type - - - -null_conditional_member_access - - - -primary_expression - - - -declaration_statement + + +statement - - -block + + +explicitly_typed_local_variable_declarator - - -5 + + +; - - -null_conditional_invocation_expression + + +explicitly_typed_local_variable_declarators - - -? + + +) statement_expression - - -Length + + +int - - -implicitly_typed_local_variable_declarator + + +null_coalescing_expression - - -?? + + +statement - - -identifier + + +namespace_body - - -. + + +identifier - - -literal + + +additive_expression - - -explicitly_typed_local_variable_declaration + + +invocation_expression - - -literal + + +? - - -explicitly_typed_local_variable_declarators + + +statement - - -( + + +% - - -invocation_expression + + +explicitly_typed_local_variable_declarator - - -( + + +type - - -identifier + + +i - - -identifier + + +. - - -WriteLine + + +implicitly_typed_local_variable_declarator - - -equality_expression + + +primary_expression - - -argument + + +null_conditional_member_access - - -nullable_value_type + + +type - - -identifier + + +this - - -multiplicative_expression + + +WriteLine - - -literal + + +declaration_statement ( - - -argument_list - - - -compilation_unit - - - -identifier - identifier - - -Range - - - -. - - - -identifier - - - -declaration_statement + + +conditional_or_expression - - -=> + + +args - - -primary_expression + + +expression - - -explicitly_typed_local_variable_declarators + + +} - - -. + + +( - - + + local_variable_initializer - - -statement_expression + + +type - - + + +? + + + ( - - -statement + + +?? - - -prog + + +identifier - - + + +range_expression + + + ; - - + + argument + + +invocation_expression + + + +? + + + +; + + + +PropertyChanged + + + +local_variable_initializer + + + +primary_expression + + + +( + + + +explicitly_typed_local_variable_declarators + + + +class_member_declaration + + + +length + identifier - - -explicitly_typed_local_variable_declaration - - - -namespace_member_declaration + + +2 - - -== + + +primary_expression - - -( + + +implicitly_typed_local_variable_declarator statement - - -Where - - - -invocation_expression + + +explicitly_typed_local_variable_declarator - - -argument_list + + +statement - - -argument_list + + +namespace - - -explicitly_typed_local_variable_declaration + + +CSharp6Features - - -; + + +5 - - -) + + +. = - - -) - - - -] - - - + + int - - -. - - - -this_access - - - -local_variable_initializer - - - + + [ - - -argument + + +( - - + + identifier - - -implicitly_typed_local_variable_declaration - - - -local_variable_initializer - - - -CSharp6Features - - - -argument_list + + +multiplicative_expression - - -; + + +WriteLine - - -= + + +nullable_value_type - - -literal + + +identifier - - -{ + + +statement_expression - - + + literal - - -Sqrt - - - -% + + +* - - -{ + + +invocation_expression - - -identifier + + +expression - - -literal + + +local_variable_declaration - - -nullable_type_annotation + + +argument_list - - -identifier + + +nullable_value_type - - -* + + +this_access statement - - -expression_statement - - - -Comments - - - -primary_expression - - - -range - - - -this - - - -multiplicative_expression + + +Monday - - + + argument_list - - -null_coalescing_expression + + +identifier - - -} + + +( - - -conditional_or_expression + + +multiplicative_expression - - + + identifier - - -class_declaration + + +null_conditional_element_access - - -statement + + +4 - - + + local_variable_declaration - - + + identifier - - -statement - - - -method_modifier - - - -length - - - -argument_list - - - -multiplicative_expression + + +primary_expression - - -+ + + +argument - - + + identifier - - -local_variable_declaration - - - -( - - - -explicitly_typed_local_variable_declarators - - - -, - - - -nullable_value_type + + +0 - - -expression_statement + + +] - - + + ? - - -identifier - - - -identifier - - - -identifier + + +3 - - -identifier + + +Length - - -Invoke + + +length - - -. + + +{ - - -* + + +literal - - -integral_type + + +customers - - -null_conditional_member_access + + +multiplicative_expression - - -lambda_expression + + +argument 17 - - -2 - - - -3 + + +identifier UndocumentedKeywords - - -multiplicative_expression - - - -declaration_statement - - - -dependent_access + + +explicitly_typed_local_variable_declaration - - + + primary_expression - - -var + + +identifier - - -multiplicative_expression + + +int - - -statement + + +4 - - -explicitly_typed_local_variable_declarators + + +3 - - -statement + + +equality_expression - - -) + + +Comments - - -identifier + + +statement_expression - - -unary_expression + + +method_modifier - - -identifier + + +block - - -equality_expression + + +Friday + + + +void + + + +primary_expression + + + +member_name + + + +=> + + + +literal + + + +additive_expression identifier - - -args - - - -null_conditional_member_access + + +multiplicative_expression - - -literal + + +) - - -( + + +primary_expression - - -integral_type + + +null_conditional_member_access ? - - -Customer + + +. - - -Monday + + +. - - -declaration_statement + + +} - - -explicitly_typed_local_variable_declarator + + +. - - -[ + + +async - - -multiplicative_expression + + +method_body - - -0 + + +primary_expression - - -{ + + +Where - - -identifier + + +member_access + + + +] XmlComments - - -explicitly_typed_local_variable_declarator + + +multiplicative_expression - - + + identifier + + +( + + + +) + identifier - - -statement + + +local_variable_declaration - - -0 + + +( - - -? + + +class - - -Test + + +; - - -0 + + +customers - - -null_conditional_member_access + + +expression_statement - - -i + + +anonymous_function_body - - -type + + +* - - -Orders + + +range - - -qualified_identifier + + +explicitly_typed_local_variable_declarator - - -0 + + +, - - -customers + + +0 - - -null_conditional_element_access + + +null_conditional_member_access - - -invocation_expression + + +nullable_type_annotation - - + + additive_expression - - -member_name + + +multiplicative_expression - - -expression + + +argument_list - - -method_declaration + + +Range - - -. + + +local_variable_initializer - - -class + + +compilation_unit - - -- + + +invocation_expression - - -= + + +argument - - -namespace + + +null_conditional_element_access - - -anonymous_function_signature + + +dependent_access - - -non_nullable_value_type + + +local_variable_declaration - - -type + + +identifier + + + +declaration_statement + + + +declaration_statement declaration_statement - - -WriteLine + + +identifier - - -? + + +namespace_member_declaration - - -additive_expression + + +. - - -invocation_expression + + +primary_expression + + + +integral_type + + + +, + + + +lambda_expression + + + +literal + + + +) + + + +Count primary_expression - - -null_conditional_element_access + + +0 - - -local_variable_declaration + + +anonymous_function_signature - - -} + + +Length - - -class_body + + +even - - -local_variable_declaration + + +null_coalescing_expression - - -implicitly_typed_local_variable_declarator + + +range_expression - - -; + + +relational_expression - - -async + + +literal - - -method_modifiers + + +implicitly_typed_local_variable_declaration - - -) + + +expression_statement + + + +explicitly_typed_local_variable_declaration var - - -? - - - -= + + +multiplicative_expression - - -primary_expression + + +namespace_declaration - - -local_variable_declaration + + +argument_list - - -; + + +[ - - + + identifier - - -method_header + + +== - - -statement_expression + + +method_modifiers - - -. + + +Customer - - -namespace_body + + += - - -expression + + +identifier - - -even + + +? - - + + +range_expression + + + +prog + + + ; - - -Length + + +declaration_statement - - -unary_expression + + +class_body - - -literal + + +} - - -primary_expression + + +method_declaration - - -int + + += - - -additive_expression + + +{ - - -invocation_expression + + +identifier - - -customers + + +equality_expression - - -return_type + + +? - - -anonymous_function_body + + +argument_list - - -customers + + +{ - - -integral_type + + +declaration_statement - - -local_variable_declaration + + +? - - -local_variable_initializer + + +first - - -length + + +. - - -primary_expression + + +null_conditional_member_access - - -member_access + + +identifier - - -null_coalescing_expression + + +class_declaration - - -; + + +type - - -identifier + + +explicitly_typed_local_variable_declaration - - + + identifier - - -) + + +Sqrt - - -) + + +invocation_expression - - -PropertyChanged + + +range - - -first + + +statement - - -, + + +literal - - -explicitly_typed_local_variable_declaration + + +) - - -void + + +; - - -unary_expression + + += - - -class_member_declaration + + +identifier - - -( + + +non_nullable_value_type - - -relational_expression + + +integral_type - - -; + + ++ - - -? + + +explicitly_typed_local_variable_declaration - - -explicitly_typed_local_variable_declarator + + +literal - - -4 + + +identifier - - -literal + + +? - - -} + + +) - - -declaration_statement + + +argument_list - - -Count + + +customers - - -? + + +literal + + + +explicitly_typed_local_variable_declarators + + + +statement \ No newline at end of file diff --git a/tools/GrammarTesting/Tests/Parsing/Samples/v6/RightShift/Reference/sample.gruntree.red.txt b/tools/GrammarTesting/Tests/Parsing/Samples/v6/RightShift/Reference/sample.gruntree.red.txt index d915780a3..c93e194b1 100644 --- a/tools/GrammarTesting/Tests/Parsing/Samples/v6/RightShift/Reference/sample.gruntree.red.txt +++ b/tools/GrammarTesting/Tests/Parsing/Samples/v6/RightShift/Reference/sample.gruntree.red.txt @@ -158,10 +158,10 @@ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ shift_expression ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ -⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ range_expression ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ > ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ -⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ primary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ c diff --git a/tools/GrammarTesting/Tests/Parsing/Samples/v6/RightShift/Reference/sample.stderr.txt b/tools/GrammarTesting/Tests/Parsing/Samples/v6/RightShift/Reference/sample.stderr.txt index 19ef2924c..6cbf4b5e8 100644 --- a/tools/GrammarTesting/Tests/Parsing/Samples/v6/RightShift/Reference/sample.stderr.txt +++ b/tools/GrammarTesting/Tests/Parsing/Samples/v6/RightShift/Reference/sample.stderr.txt @@ -1,3 +1,3 @@ line 10:12 no viable alternative at input '>' -line 10:14 extraneous input '>' expecting {'-', '--', '!', '(', '&', '+', '++', '~', 'add', 'alias', 'ascending', 'async', 'await', 'base', 'bool', 'by', 'byte', 'char', 'checked', 'decimal', 'delegate', 'descending', 'double', 'dynamic', 'equals', 'float', 'from', 'get', 'global', 'group', 'int', 'into', 'join', 'let', 'long', 'nameof', 'new', 'notnull', 'object', 'on', 'orderby', 'partial', 'remove', 'sbyte', 'select', 'set', 'short', 'sizeof', 'stackalloc', 'string', 'this', 'typeof', 'uint', 'ulong', 'unchecked', 'unmanaged', 'ushort', 'value', 'var', 'when', 'where', 'yield', 'default', 'null', 'true', 'false', '*', Simple_Identifier, Integer_Literal, Real_Literal, Character_Literal, String_Literal, Interpolated_Regular_String_Start, Interpolated_Verbatim_String_Start} +line 10:14 extraneous input '>' expecting {'-', '--', '!', '..', '(', '&', '^', '+', '++', '~', 'add', 'alias', 'ascending', 'async', 'await', 'base', 'bool', 'by', 'byte', 'char', 'checked', 'decimal', 'delegate', 'descending', 'double', 'dynamic', 'equals', 'float', 'from', 'get', 'global', 'group', 'int', 'into', 'join', 'let', 'long', 'nameof', 'new', 'notnull', 'object', 'on', 'orderby', 'partial', 'remove', 'sbyte', 'select', 'set', 'short', 'sizeof', 'stackalloc', 'string', 'this', 'typeof', 'uint', 'ulong', 'unchecked', 'unmanaged', 'ushort', 'value', 'var', 'when', 'where', 'yield', 'default', 'null', 'true', 'false', '*', Simple_Identifier, Integer_Literal, Real_Literal, Character_Literal, String_Literal, Interpolated_Regular_String_Start, Interpolated_Verbatim_String_Start} line 11:8 no viable alternative at input '>' diff --git a/tools/GrammarTesting/Tests/Parsing/Samples/v6/RightShift/Reference/sample.tree.red.txt b/tools/GrammarTesting/Tests/Parsing/Samples/v6/RightShift/Reference/sample.tree.red.txt index bc5a48544..9319e7c52 100644 --- a/tools/GrammarTesting/Tests/Parsing/Samples/v6/RightShift/Reference/sample.tree.red.txt +++ b/tools/GrammarTesting/Tests/Parsing/Samples/v6/RightShift/Reference/sample.tree.red.txt @@ -1 +1 @@ -(prog (compilation_unit (class_declaration class (identifier RightShift) (class_body { (class_member_declaration (method_declaration method_modifiers (return_type void) (method_header (member_name (identifier RightShift)) ( )) (method_body (block { (statement_list (statement (expression_statement (statement_expression (assignment (unary_expression (identifier a)) (assignment_operator =) (expression (shift_expression (shift_expression (identifier b)) (right_shift > >) (additive_expression (identifier c)))))) ;)) (statement (expression_statement (statement_expression (assignment (unary_expression (identifier d)) (assignment_operator (right_shift_assignment > >=)) (expression (identifier e)))) ;)) (statement (expression_statement (statement_expression (assignment (unary_expression (identifier a)) (assignment_operator =) (expression (relational_expression (relational_expression (identifier b)) > (shift_expression (unary_expression > (primary_expression (identifier c)))))))) ;)) (statement (expression_statement (statement_expression (assignment (unary_expression (identifier d)) (assignment_operator > >=) (expression (identifier e)))) ;))) })))) })))) +(prog (compilation_unit (class_declaration class (identifier RightShift) (class_body { (class_member_declaration (method_declaration method_modifiers (return_type void) (method_header (member_name (identifier RightShift)) ( )) (method_body (block { (statement_list (statement (expression_statement (statement_expression (assignment (unary_expression (identifier a)) (assignment_operator =) (expression (shift_expression (shift_expression (identifier b)) (right_shift > >) (additive_expression (identifier c)))))) ;)) (statement (expression_statement (statement_expression (assignment (unary_expression (identifier d)) (assignment_operator (right_shift_assignment > >=)) (expression (identifier e)))) ;)) (statement (expression_statement (statement_expression (assignment (unary_expression (identifier a)) (assignment_operator =) (expression (relational_expression (relational_expression (identifier b)) > (shift_expression (range_expression > (unary_expression (identifier c)))))))) ;)) (statement (expression_statement (statement_expression (assignment (unary_expression (identifier d)) (assignment_operator > >=) (expression (identifier e)))) ;))) })))) })))) diff --git a/tools/GrammarTesting/Tests/Parsing/Samples/v6/RightShift/Reference/sample.tree.svg b/tools/GrammarTesting/Tests/Parsing/Samples/v6/RightShift/Reference/sample.tree.svg index a2f9245dc..721877c1e 100644 --- a/tools/GrammarTesting/Tests/Parsing/Samples/v6/RightShift/Reference/sample.tree.svg +++ b/tools/GrammarTesting/Tests/Parsing/Samples/v6/RightShift/Reference/sample.tree.svg @@ -73,10 +73,10 @@ - - - - + + + + @@ -94,392 +94,392 @@ - - -; - - - -right_shift_assignment + + +relational_expression - - -class_member_declaration + + +prog - - -block + + +> - - + + identifier - - -e - - - -unary_expression - - - -statement - - - -unary_expression - - - -class_declaration - - - -class - - - -statement_expression - - - + + expression_statement - - -> - assignment - - -method_body - - - -statement + + +right_shift_assignment - - + + identifier - - -d + + +expression - - -identifier + + +expression_statement - - -assignment + + +unary_expression + + + +identifier expression - - -relational_expression - identifier - - -RightShift - - - -RightShift + + +unary_expression - - -} + + +; - - -statement_list + + +shift_expression - - -primary_expression + + +void - - + + } - - -c + + +e - - -return_type + + +assignment_operator - - -identifier + + +; - - + + identifier - - -{ + + +( - - -= + + +block - - -identifier + + +assignment_operator - - -unary_expression + + +statement_list - - -assignment_operator + + +expression - - -> + + +statement_expression - - -> + + +method_declaration - - -; + + +identifier - - -b + + +shift_expression - - -; + + +{ - - -assignment + + +method_modifiers - - -c + + +unary_expression - - -relational_expression + + +statement - - -> + + +expression_statement - - + + identifier - - -statement_expression + + +range_expression - - ->= + + +additive_expression - - -prog + + +shift_expression - - -b + + +identifier - - -statement + + += - - -void + + +c - - -method_modifiers + + +assignment - - -) + + +expression - - -= + + +method_header - - -shift_expression + + +statement - - -member_name + + +c - - + + { - - -expression_statement + + +> - - + + identifier - - -right_shift - - - + + identifier - - -expression - - - -assignment_operator + + +class_member_declaration - - -d + + +assignment expression_statement - - -statement_expression + + +>= assignment_operator + + +; + + + +> + >= - - -; + + +class_declaration - - -( + + +identifier - - -shift_expression + + +statement a - - -class_body + + +; + + + +> + + + +unary_expression + + + +> + + + +) + + + +method_body + + + +d + + + +e a - - -expression + + +statement_expression - - -method_declaration + + +RightShift - - -expression + + +relational_expression - - -unary_expression + + +d compilation_unit - - -statement + + +> - - -e + + +statement_expression - - + + +RightShift + + + +member_name + + + unary_expression - - -method_header + + +statement - - + + +identifier + + + +return_type + + + assignment_operator - - -expression_statement + + +b - - -identifier + + +assignment + + + +b statement_expression - - -> - - - -> + + += - - -additive_expression + + +right_shift - - -identifier + + +} - - -assignment + + +class - - -shift_expression + + +class_body \ No newline at end of file diff --git a/tools/GrammarTesting/Tests/Parsing/Samples/v8/Element Access/ReadMe.md b/tools/GrammarTesting/Tests/Parsing/Samples/v8/Element Access/ReadMe.md index 348083c6e..60ff2220b 100644 --- a/tools/GrammarTesting/Tests/Parsing/Samples/v8/Element Access/ReadMe.md +++ b/tools/GrammarTesting/Tests/Parsing/Samples/v8/Element Access/ReadMe.md @@ -9,4 +9,4 @@ The sample contains both valid and invalid samples, the semantic errors the latt produce are checked – the reference errors are in `Reference/sample.stderr.txt` The check is a semantic one only, the code still parses successfully and the parse tree -is checked for correctness as with other samples. \ No newline at end of file +is checked for correctness as with other samples. diff --git a/tools/GrammarTesting/Tests/Parsing/Samples/v8/Index & Range/ReadMe.md b/tools/GrammarTesting/Tests/Parsing/Samples/v8/Index & Range/ReadMe.md new file mode 100644 index 000000000..db692992f --- /dev/null +++ b/tools/GrammarTesting/Tests/Parsing/Samples/v8/Index & Range/ReadMe.md @@ -0,0 +1 @@ +# Sample: Index & Range expressions diff --git a/tools/GrammarTesting/Tests/Parsing/Samples/v8/Index & Range/Reference/sample.gruntree.red.txt b/tools/GrammarTesting/Tests/Parsing/Samples/v8/Index & Range/Reference/sample.gruntree.red.txt new file mode 100644 index 000000000..babc97bfa --- /dev/null +++ b/tools/GrammarTesting/Tests/Parsing/Samples/v8/Index & Range/Reference/sample.gruntree.red.txt @@ -0,0 +1,1017 @@ +⎛ +⎜ prog +⎜ ⎛ +⎜ ⎜ compilation_unit +⎜ ⎜ ⎛ +⎜ ⎜ ⎜ class_declaration +⎜ ⎜ ⎜ class +⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ IndexAndRangeExpressions +⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ class_body +⎜ ⎜ ⎜ ⎜ { +⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ class_member_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ method_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ method_modifiers +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ return_type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ void +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ method_header +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ member_name +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ IndexAndRangeExpressions_1 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ( +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ) +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ method_body +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ block +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ { +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ statement_list +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ declaration_statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ var +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declarator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ a +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ = +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ^ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ literal +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ 1 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ; +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ declaration_statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ var +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declarator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ b +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ = +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ range_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ .. +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ^ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ literal +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ 1 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ; +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ declaration_statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ var +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declarator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ c +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ = +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ range_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ literal +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ 0 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ .. +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ; +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ declaration_statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ var +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declarator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ d +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ = +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ range_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ .. +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ; +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ declaration_statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ var +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declarator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ e +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ = +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ object_creation_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ new +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ type +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ Struct +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ( +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ) +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ; +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ declaration_statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ var +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declarator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ f +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ = +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ multiplicative_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ multiplicative_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ e +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ * +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ range_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ literal +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ 1 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ .. +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ literal +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ 2 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ; +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ declaration_statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ var +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declarator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ g +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ = +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ multiplicative_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ multiplicative_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ e +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ * +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ range_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ .. +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ; +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ declaration_statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ var +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declarator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ h +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ = +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ multiplicative_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ multiplicative_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ e +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ * +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ range_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ literal +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ 1 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ .. +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ; +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ declaration_statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ var +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declarator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ i +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ = +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ multiplicative_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ multiplicative_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ e +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ * +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ range_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ .. +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ literal +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ 2 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ; +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ declaration_statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ var +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declarator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ j +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ = +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ multiplicative_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ multiplicative_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ range_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ .. +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ / +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ range_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ e +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ; +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ declaration_statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ var +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declarator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ k +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ = +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ multiplicative_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ multiplicative_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ range_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ^ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ literal +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ 2 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ .. +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ / +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ range_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ e +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ; +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ declaration_statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ var +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declarator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ l +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ = +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ multiplicative_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ multiplicative_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ range_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ .. +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ^ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ literal +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ 1 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ / +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ range_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ e +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ; +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ declaration_statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ var +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declarator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ m +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ = +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ multiplicative_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ multiplicative_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ range_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ^ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ literal +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ 2 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ .. +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ^ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ literal +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ 1 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ / +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ range_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ e +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ; +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ declaration_statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ var +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declarator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ n +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ = +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ range_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ literal +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ 1 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ .. +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ member_access +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ primary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ parenthesized_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ( +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ range_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ .. +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ literal +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ 6 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ) +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ . +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ End +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ; +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ declaration_statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ var +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declarator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ o +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ = +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ range_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ member_access +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ primary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ b +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ . +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ Start +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ .. +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ literal +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ 5 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ; +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ declaration_statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ var +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declarator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ p +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ = +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ range_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ member_access +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ primary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ parenthesized_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ( +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ range_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ literal +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ 1 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ .. +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ literal +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ 3 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ) +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ . +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ Start +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ .. +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ literal +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ 5 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ; +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ declaration_statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ var +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declarator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ oops +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ = +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ range_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ parenthesized_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ( +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ range_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ literal +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ 1 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ .. +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ literal +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ 3 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ) +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ .. +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ literal +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ 5 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ; +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ declaration_statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ var +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declarator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ oops +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ = +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ range_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ literal +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ 1 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ .. +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ parenthesized_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ( +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ range_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ literal +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ 3 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ .. +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ literal +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ 5 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ) +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ; +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ declaration_statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declaration +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ var +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ implicitly_typed_local_variable_declarator +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ identifier +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ oops +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ = +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ range_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ literal +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ 1 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ .. +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ unary_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ literal +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ 3 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ .. +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎛ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ expression_statement +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ statement_expression +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ 5 +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ; +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ } +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎜ ⎜ } +⎜ ⎜ ⎜ ⎝ +⎜ ⎜ ⎝ +⎜ ⎝ +⎝ diff --git a/tools/GrammarTesting/Tests/Parsing/Samples/v8/Index & Range/Reference/sample.stderr.txt b/tools/GrammarTesting/Tests/Parsing/Samples/v8/Index & Range/Reference/sample.stderr.txt new file mode 100644 index 000000000..8761e9bbd --- /dev/null +++ b/tools/GrammarTesting/Tests/Parsing/Samples/v8/Index & Range/Reference/sample.stderr.txt @@ -0,0 +1 @@ +line 24:21 mismatched input '..' expecting {'-', '--', '->', ';', '!', '!=', '?', '.', '(', '[', '&', '&&', '%', '^', '+', '++', '<', '<<', '<=', '==', '>', '>=', '|', '||', 'as', 'is', '*', '/'} diff --git a/tools/GrammarTesting/Tests/Parsing/Samples/v8/Index & Range/Reference/sample.tokens.txt b/tools/GrammarTesting/Tests/Parsing/Samples/v8/Index & Range/Reference/sample.tokens.txt new file mode 100644 index 000000000..53045c1f6 --- /dev/null +++ b/tools/GrammarTesting/Tests/Parsing/Samples/v8/Index & Range/Reference/sample.tokens.txt @@ -0,0 +1,176 @@ +[@0,0:4='class',<'class'>,1:0] +[@1,6:29='IndexAndRangeExpressions',,1:6] +[@2,31:31='{',<'{'>,2:0] +[@3,36:39='void',<'void'>,3:3] +[@4,41:66='IndexAndRangeExpressions_1',,3:8] +[@5,67:67='(',<'('>,3:34] +[@6,68:68=')',<')'>,3:35] +[@7,73:73='{',<'{'>,4:3] +[@8,81:83='var',<'var'>,5:6] +[@9,85:85='a',,5:10] +[@10,87:87='=',<'='>,5:12] +[@11,89:89='^',<'^'>,5:14] +[@12,90:90='1',,5:15] +[@13,91:91=';',<';'>,5:16] +[@14,99:101='var',<'var'>,6:6] +[@15,103:103='b',,6:10] +[@16,105:105='=',<'='>,6:12] +[@17,107:108='..',<'..'>,6:14] +[@18,109:109='^',<'^'>,6:16] +[@19,110:110='1',,6:17] +[@20,111:111=';',<';'>,6:18] +[@21,119:121='var',<'var'>,7:6] +[@22,123:123='c',,7:10] +[@23,125:125='=',<'='>,7:12] +[@24,127:127='0',,7:14] +[@25,128:129='..',<'..'>,7:15] +[@26,130:130=';',<';'>,7:17] +[@27,138:140='var',<'var'>,8:6] +[@28,142:142='d',,8:10] +[@29,144:144='=',<'='>,8:12] +[@30,146:147='..',<'..'>,8:14] +[@31,148:148=';',<';'>,8:16] +[@32,156:158='var',<'var'>,9:6] +[@33,160:160='e',,9:10] +[@34,162:162='=',<'='>,9:12] +[@35,164:166='new',<'new'>,9:14] +[@36,168:173='Struct',,9:18] +[@37,174:174='(',<'('>,9:24] +[@38,175:175=')',<')'>,9:25] +[@39,176:176=';',<';'>,9:26] +[@40,218:220='var',<'var'>,10:6] +[@41,222:222='f',,10:10] +[@42,224:224='=',<'='>,10:12] +[@43,226:226='e',,10:14] +[@44,228:228='*',<'*'>,10:16] +[@45,230:230='1',,10:18] +[@46,232:233='..',<'..'>,10:20] +[@47,235:235='2',,10:23] +[@48,236:236=';',<';'>,10:24] +[@49,244:246='var',<'var'>,11:6] +[@50,248:248='g',,11:10] +[@51,250:250='=',<'='>,11:12] +[@52,252:252='e',,11:14] +[@53,254:254='*',<'*'>,11:16] +[@54,256:257='..',<'..'>,11:18] +[@55,258:258=';',<';'>,11:20] +[@56,266:268='var',<'var'>,12:6] +[@57,270:270='h',,12:10] +[@58,272:272='=',<'='>,12:12] +[@59,274:274='e',,12:14] +[@60,276:276='*',<'*'>,12:16] +[@61,278:278='1',,12:18] +[@62,279:280='..',<'..'>,12:19] +[@63,281:281=';',<';'>,12:21] +[@64,289:291='var',<'var'>,13:6] +[@65,293:293='i',,13:10] +[@66,295:295='=',<'='>,13:12] +[@67,297:297='e',,13:14] +[@68,299:299='*',<'*'>,13:16] +[@69,301:302='..',<'..'>,13:18] +[@70,303:303='2',,13:20] +[@71,304:304=';',<';'>,13:21] +[@72,312:314='var',<'var'>,14:6] +[@73,316:316='j',,14:10] +[@74,318:318='=',<'='>,14:12] +[@75,320:321='..',<'..'>,14:14] +[@76,323:323='/',<'/'>,14:17] +[@77,325:325='e',,14:19] +[@78,326:326=';',<';'>,14:20] +[@79,334:336='var',<'var'>,15:6] +[@80,338:338='k',,15:10] +[@81,340:340='=',<'='>,15:12] +[@82,342:342='^',<'^'>,15:14] +[@83,343:343='2',,15:15] +[@84,344:345='..',<'..'>,15:16] +[@85,347:347='/',<'/'>,15:19] +[@86,349:349='e',,15:21] +[@87,350:350=';',<';'>,15:22] +[@88,358:360='var',<'var'>,16:6] +[@89,362:362='l',,16:10] +[@90,364:364='=',<'='>,16:12] +[@91,366:367='..',<'..'>,16:14] +[@92,369:369='^',<'^'>,16:17] +[@93,370:370='1',,16:18] +[@94,371:371='/',<'/'>,16:19] +[@95,372:372='e',,16:20] +[@96,373:373=';',<';'>,16:21] +[@97,381:383='var',<'var'>,17:6] +[@98,385:385='m',,17:10] +[@99,387:387='=',<'='>,17:12] +[@100,389:389='^',<'^'>,17:14] +[@101,390:390='2',,17:15] +[@102,392:393='..',<'..'>,17:17] +[@103,394:394='^',<'^'>,17:19] +[@104,395:395='1',,17:20] +[@105,397:397='/',<'/'>,17:22] +[@106,399:399='e',,17:24] +[@107,400:400=';',<';'>,17:25] +[@108,408:410='var',<'var'>,18:6] +[@109,412:412='n',,18:10] +[@110,414:414='=',<'='>,18:12] +[@111,416:416='1',,18:14] +[@112,417:418='..',<'..'>,18:15] +[@113,419:419='(',<'('>,18:17] +[@114,420:421='..',<'..'>,18:18] +[@115,423:423='6',,18:21] +[@116,424:424=')',<')'>,18:22] +[@117,425:425='.',<'.'>,18:23] +[@118,426:428='End',,18:24] +[@119,429:429=';',<';'>,18:27] +[@120,437:439='var',<'var'>,19:6] +[@121,441:441='o',,19:10] +[@122,443:443='=',<'='>,19:12] +[@123,445:445='b',,19:14] +[@124,446:446='.',<'.'>,19:15] +[@125,447:451='Start',,19:16] +[@126,452:453='..',<'..'>,19:21] +[@127,454:454='5',,19:23] +[@128,455:455=';',<';'>,19:24] +[@129,463:465='var',<'var'>,20:6] +[@130,467:467='p',,20:10] +[@131,469:469='=',<'='>,20:12] +[@132,471:471='(',<'('>,20:14] +[@133,472:472='1',,20:15] +[@134,473:474='..',<'..'>,20:16] +[@135,475:475='3',,20:18] +[@136,476:476=')',<')'>,20:19] +[@137,477:477='.',<'.'>,20:20] +[@138,478:482='Start',,20:21] +[@139,483:484='..',<'..'>,20:26] +[@140,485:485='5',,20:28] +[@141,486:486=';',<';'>,20:29] +[@142,501:503='var',<'var'>,22:6] +[@143,505:508='oops',,22:10] +[@144,510:510='=',<'='>,22:15] +[@145,512:512='(',<'('>,22:17] +[@146,513:513='1',,22:18] +[@147,514:515='..',<'..'>,22:19] +[@148,516:516='3',,22:21] +[@149,517:517=')',<')'>,22:22] +[@150,518:519='..',<'..'>,22:23] +[@151,520:520='5',,22:25] +[@152,521:521=';',<';'>,22:26] +[@153,561:563='var',<'var'>,23:6] +[@154,565:568='oops',,23:10] +[@155,570:570='=',<'='>,23:15] +[@156,572:572='1',,23:17] +[@157,573:574='..',<'..'>,23:18] +[@158,575:575='(',<'('>,23:20] +[@159,576:576='3',,23:21] +[@160,577:578='..',<'..'>,23:22] +[@161,579:579='5',,23:24] +[@162,580:580=')',<')'>,23:25] +[@163,581:581=';',<';'>,23:26] +[@164,621:623='var',<'var'>,24:6] +[@165,625:628='oops',,24:10] +[@166,630:630='=',<'='>,24:15] +[@167,632:632='1',,24:17] +[@168,633:634='..',<'..'>,24:18] +[@169,635:635='3',,24:20] +[@170,636:637='..',<'..'>,24:21] +[@171,638:638='5',,24:23] +[@172,639:639=';',<';'>,24:24] +[@173,680:680='}',<'}'>,25:3] +[@174,682:682='}',<'}'>,26:0] +[@175,683:682='',,26:1] diff --git a/tools/GrammarTesting/Tests/Parsing/Samples/v8/Index & Range/Reference/sample.tree.red.txt b/tools/GrammarTesting/Tests/Parsing/Samples/v8/Index & Range/Reference/sample.tree.red.txt new file mode 100644 index 000000000..2c5fdd8a8 --- /dev/null +++ b/tools/GrammarTesting/Tests/Parsing/Samples/v8/Index & Range/Reference/sample.tree.red.txt @@ -0,0 +1 @@ +(prog (compilation_unit (class_declaration class (identifier IndexAndRangeExpressions) (class_body { (class_member_declaration (method_declaration method_modifiers (return_type void) (method_header (member_name (identifier IndexAndRangeExpressions_1)) ( )) (method_body (block { (statement_list (statement (declaration_statement (local_variable_declaration (implicitly_typed_local_variable_declaration var (implicitly_typed_local_variable_declarator (identifier a) = (expression (unary_expression ^ (unary_expression (literal 1))))))) ;)) (statement (declaration_statement (local_variable_declaration (implicitly_typed_local_variable_declaration var (implicitly_typed_local_variable_declarator (identifier b) = (expression (range_expression .. (unary_expression ^ (unary_expression (literal 1)))))))) ;)) (statement (declaration_statement (local_variable_declaration (implicitly_typed_local_variable_declaration var (implicitly_typed_local_variable_declarator (identifier c) = (expression (range_expression (unary_expression (literal 0)) ..))))) ;)) (statement (declaration_statement (local_variable_declaration (implicitly_typed_local_variable_declaration var (implicitly_typed_local_variable_declarator (identifier d) = (expression (range_expression ..))))) ;)) (statement (declaration_statement (local_variable_declaration (implicitly_typed_local_variable_declaration var (implicitly_typed_local_variable_declarator (identifier e) = (expression (object_creation_expression new (type (identifier Struct)) ( )))))) ;)) (statement (declaration_statement (local_variable_declaration (implicitly_typed_local_variable_declaration var (implicitly_typed_local_variable_declarator (identifier f) = (expression (multiplicative_expression (multiplicative_expression (identifier e)) * (range_expression (unary_expression (literal 1)) .. (unary_expression (literal 2)))))))) ;)) (statement (declaration_statement (local_variable_declaration (implicitly_typed_local_variable_declaration var (implicitly_typed_local_variable_declarator (identifier g) = (expression (multiplicative_expression (multiplicative_expression (identifier e)) * (range_expression ..)))))) ;)) (statement (declaration_statement (local_variable_declaration (implicitly_typed_local_variable_declaration var (implicitly_typed_local_variable_declarator (identifier h) = (expression (multiplicative_expression (multiplicative_expression (identifier e)) * (range_expression (unary_expression (literal 1)) ..)))))) ;)) (statement (declaration_statement (local_variable_declaration (implicitly_typed_local_variable_declaration var (implicitly_typed_local_variable_declarator (identifier i) = (expression (multiplicative_expression (multiplicative_expression (identifier e)) * (range_expression .. (unary_expression (literal 2)))))))) ;)) (statement (declaration_statement (local_variable_declaration (implicitly_typed_local_variable_declaration var (implicitly_typed_local_variable_declarator (identifier j) = (expression (multiplicative_expression (multiplicative_expression (range_expression ..)) / (range_expression (identifier e))))))) ;)) (statement (declaration_statement (local_variable_declaration (implicitly_typed_local_variable_declaration var (implicitly_typed_local_variable_declarator (identifier k) = (expression (multiplicative_expression (multiplicative_expression (range_expression (unary_expression ^ (unary_expression (literal 2))) ..)) / (range_expression (identifier e))))))) ;)) (statement (declaration_statement (local_variable_declaration (implicitly_typed_local_variable_declaration var (implicitly_typed_local_variable_declarator (identifier l) = (expression (multiplicative_expression (multiplicative_expression (range_expression .. (unary_expression ^ (unary_expression (literal 1))))) / (range_expression (identifier e))))))) ;)) (statement (declaration_statement (local_variable_declaration (implicitly_typed_local_variable_declaration var (implicitly_typed_local_variable_declarator (identifier m) = (expression (multiplicative_expression (multiplicative_expression (range_expression (unary_expression ^ (unary_expression (literal 2))) .. (unary_expression ^ (unary_expression (literal 1))))) / (range_expression (identifier e))))))) ;)) (statement (declaration_statement (local_variable_declaration (implicitly_typed_local_variable_declaration var (implicitly_typed_local_variable_declarator (identifier n) = (expression (range_expression (unary_expression (literal 1)) .. (unary_expression (member_access (primary_expression (parenthesized_expression ( (expression (range_expression .. (unary_expression (literal 6)))) ))) . (identifier End)))))))) ;)) (statement (declaration_statement (local_variable_declaration (implicitly_typed_local_variable_declaration var (implicitly_typed_local_variable_declarator (identifier o) = (expression (range_expression (unary_expression (member_access (primary_expression (identifier b)) . (identifier Start))) .. (unary_expression (literal 5))))))) ;)) (statement (declaration_statement (local_variable_declaration (implicitly_typed_local_variable_declaration var (implicitly_typed_local_variable_declarator (identifier p) = (expression (range_expression (unary_expression (member_access (primary_expression (parenthesized_expression ( (expression (range_expression (unary_expression (literal 1)) .. (unary_expression (literal 3)))) ))) . (identifier Start))) .. (unary_expression (literal 5))))))) ;)) (statement (declaration_statement (local_variable_declaration (implicitly_typed_local_variable_declaration var (implicitly_typed_local_variable_declarator (identifier oops) = (expression (range_expression (unary_expression (parenthesized_expression ( (expression (range_expression (unary_expression (literal 1)) .. (unary_expression (literal 3)))) ))) .. (unary_expression (literal 5))))))) ;)) (statement (declaration_statement (local_variable_declaration (implicitly_typed_local_variable_declaration var (implicitly_typed_local_variable_declarator (identifier oops) = (expression (range_expression (unary_expression (literal 1)) .. (unary_expression (parenthesized_expression ( (expression (range_expression (unary_expression (literal 3)) .. (unary_expression (literal 5)))) )))))))) ;)) (statement (declaration_statement (local_variable_declaration (implicitly_typed_local_variable_declaration var (implicitly_typed_local_variable_declarator (identifier oops) = (expression (range_expression (unary_expression (literal 1)) .. (unary_expression (literal 3))))))) ..)) (statement (expression_statement statement_expression 5 ;))) })))) })))) diff --git a/tools/GrammarTesting/Tests/Parsing/Samples/v8/Index & Range/Reference/sample.tree.svg b/tools/GrammarTesting/Tests/Parsing/Samples/v8/Index & Range/Reference/sample.tree.svg new file mode 100644 index 000000000..85dd1add9 --- /dev/null +++ b/tools/GrammarTesting/Tests/Parsing/Samples/v8/Index & Range/Reference/sample.tree.svg @@ -0,0 +1,2285 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +expression + + + +literal + + + +implicitly_typed_local_variable_declaration + + + +/ + + + +.. + + + +declaration_statement + + + +.. + + + += + + + +statement + + + +expression + + + +literal + + + +range_expression + + + +unary_expression + + + +.. + + + +1 + + + +; + + + +implicitly_typed_local_variable_declaration + + + +implicitly_typed_local_variable_declarator + + + +var + + + +member_access + + + +multiplicative_expression + + + += + + + +identifier + + + +multiplicative_expression + + + +1 + + + +5 + + + +; + + + +unary_expression + + + +multiplicative_expression + + + +literal + + + +implicitly_typed_local_variable_declaration + + + += + + + +) + + + +e + + + +statement_expression + + + +declaration_statement + + + +identifier + + + += + + + +declaration_statement + + + +. + + + +IndexAndRangeExpressions_1 + + + +var + + + +var + + + +} + + + +c + + + +.. + + + +; + + + +range_expression + + + +identifier + + + +multiplicative_expression + + + +return_type + + + +var + + + +multiplicative_expression + + + +declaration_statement + + + +statement + + + +parenthesized_expression + + + +unary_expression + + + +identifier + + + +* + + + +2 + + + +unary_expression + + + +statement + + + +; + + + +2 + + + +5 + + + +IndexAndRangeExpressions + + + +implicitly_typed_local_variable_declarator + + + +multiplicative_expression + + + +1 + + + +range_expression + + + +literal + + + +expression + + + +e + + + +.. + + + +identifier + + + +literal + + + +implicitly_typed_local_variable_declaration + + + +literal + + + +literal + + + +; + + + +m + + + +expression + + + +; + + + +literal + + + +identifier + + + +unary_expression + + + +l + + + +unary_expression + + + += + + + +implicitly_typed_local_variable_declarator + + + +statement + + + +{ + + + +unary_expression + + + +( + + + +5 + + + +identifier + + + +g + + + +) + + + +expression + + + +local_variable_declaration + + + +unary_expression + + + +/ + + + +implicitly_typed_local_variable_declaration + + + +implicitly_typed_local_variable_declarator + + + +implicitly_typed_local_variable_declaration + + + +implicitly_typed_local_variable_declarator + + + +primary_expression + + + +identifier + + + +unary_expression + + + +expression + + + +expression + + + +var + + + +statement + + + +literal + + + +declaration_statement + + + +identifier + + + +.. + + + +unary_expression + + + += + + + +.. + + + +expression_statement + + + +range_expression + + + += + + + += + + + +.. + + + +declaration_statement + + + += + + + +( + + + +declaration_statement + + + +1 + + + +0 + + + +literal + + + +expression + + + +oops + + + +; + + + +class_member_declaration + + + +range_expression + + + +expression + + + +implicitly_typed_local_variable_declarator + + + +.. + + + +unary_expression + + + +unary_expression + + + +unary_expression + + + +2 + + + +* + + + +implicitly_typed_local_variable_declarator + + + +; + + + +local_variable_declaration + + + +range_expression + + + +expression + + + +implicitly_typed_local_variable_declaration + + + +local_variable_declaration + + + +.. + + + +identifier + + + +range_expression + + + +multiplicative_expression + + + +1 + + + +n + + + +Start + + + +method_modifiers + + + += + + + +class_declaration + + + +identifier + + + +var + + + +unary_expression + + + +Struct + + + +unary_expression + + + +; + + + +unary_expression + + + +literal + + + +; + + + +.. + + + +identifier + + + +.. + + + +identifier + + + +expression + + + +unary_expression + + + +local_variable_declaration + + + +new + + + +implicitly_typed_local_variable_declarator + + + +unary_expression + + + +unary_expression + + + +; + + + +implicitly_typed_local_variable_declarator + + + +local_variable_declaration + + + +e + + + +range_expression + + + +local_variable_declaration + + + +expression + + + +implicitly_typed_local_variable_declarator + + + +e + + + +object_creation_expression + + + +void + + + +declaration_statement + + + +statement + + + +parenthesized_expression + + + +declaration_statement + + + +method_body + + + +a + + + +implicitly_typed_local_variable_declaration + + + +class_body + + + +statement + + + +6 + + + +statement + + + +^ + + + +p + + + +e + + + +.. + + + +expression + + + +unary_expression + + + +var + + + +; + + + +local_variable_declaration + + + +.. + + + +3 + + + +implicitly_typed_local_variable_declaration + + + +e + + + +3 + + + += + + + +implicitly_typed_local_variable_declarator + + + +k + + + +; + + + +identifier + + + +expression + + + +prog + + + +e + + + +multiplicative_expression + + + +implicitly_typed_local_variable_declaration + + + +statement + + + +statement + + + +( + + + +local_variable_declaration + + + +expression + + + +parenthesized_expression + + + +o + + + +implicitly_typed_local_variable_declarator + + + +unary_expression + + + +i + + + +implicitly_typed_local_variable_declaration + + + +) + + + +literal + + + +.. + + + +literal + + + +range_expression + + + +implicitly_typed_local_variable_declarator + + + +identifier + + + +local_variable_declaration + + + +declaration_statement + + + +^ + + + +member_name + + + +implicitly_typed_local_variable_declaration + + + +identifier + + + +.. + + + +statement + + + +declaration_statement + + + +/ + + + +implicitly_typed_local_variable_declaration + + + +range_expression + + + +3 + + + +var + + + +^ + + + +range_expression + + + +implicitly_typed_local_variable_declarator + + + +identifier + + + +identifier + + + +identifier + + + +implicitly_typed_local_variable_declarator + + + +oops + + + +multiplicative_expression + + + +multiplicative_expression + + + +( + + + +local_variable_declaration + + + +range_expression + + + +var + + + += + + + +literal + + + +multiplicative_expression + + + +identifier + + + +local_variable_declaration + + + +range_expression + + + +var + + + +; + + + +; + + + +unary_expression + + + += + + + +Start + + + +local_variable_declaration + + + +local_variable_declaration + + + +class + + + +identifier + + + +literal + + + +range_expression + + + +expression + + + +var + + + +) + + + +declaration_statement + + + +range_expression + + + +e + + + +unary_expression + + + +( + + + +5 + + + +1 + + + +implicitly_typed_local_variable_declarator + + + +local_variable_declaration + + + +f + + + +range_expression + + + +identifier + + + +oops + + + +End + + + +j + + + +unary_expression + + + +; + + + +{ + + + +parenthesized_expression + + + +* + + + +; + + + +range_expression + + + +b + + + +multiplicative_expression + + + +local_variable_declaration + + + +^ + + + +unary_expression + + + +) + + + +} + + + +statement + + + +local_variable_declaration + + + +unary_expression + + + +implicitly_typed_local_variable_declarator + + + +unary_expression + + + +3 + + + +1 + + + +var + + + +unary_expression + + + +implicitly_typed_local_variable_declaration + + + +expression + + + +expression + + + +identifier + + + += + + + +multiplicative_expression + + + +unary_expression + + + +statement + + + +expression + + + += + + + +declaration_statement + + + +implicitly_typed_local_variable_declaration + + + +literal + + + +range_expression + + + +literal + + + +; + + + +d + + + +h + + + +.. + + + +method_header + + + +range_expression + + + +declaration_statement + + + +.. + + + +2 + + + +literal + + + +unary_expression + + + +.. + + + +primary_expression + + + +unary_expression + + + +expression + + + +literal + + + +implicitly_typed_local_variable_declaration + + + +multiplicative_expression + + + +statement_list + + + +. + + + +identifier + + + +identifier + + + +.. + + + +e + + + +identifier + + + +expression + + + +literal + + + +literal + + + +method_declaration + + + +range_expression + + + +statement + + + +range_expression + + + +identifier + + + +primary_expression + + + +statement + + + +.. + + + +literal + + + +* + + + +block + + + +declaration_statement + + + +^ + + + +5 + + + +unary_expression + + + +statement + + + +var + + + += + + + +range_expression + + + +identifier + + + +var + + + +implicitly_typed_local_variable_declaration + + + +implicitly_typed_local_variable_declarator + + + +identifier + + + +statement + + + +identifier + + + += + + + +var + + + +unary_expression + + + +statement + + + +identifier + + + +local_variable_declaration + + + +unary_expression + + + +1 + + + +range_expression + + + +unary_expression + + + += + + + +expression + + + +b + + + +/ + + + +literal + + + +identifier + + + +expression + + + +1 + + + +multiplicative_expression + + + +declaration_statement + + + +identifier + + + +.. + + + +literal + + + +declaration_statement + + + +var + + + +^ + + + +identifier + + + +local_variable_declaration + + + +var + + + +var + + + +multiplicative_expression + + + +implicitly_typed_local_variable_declarator + + + +compilation_unit + + + +. + + + +range_expression + + + +local_variable_declaration + + + +type + + + +declaration_statement + + + +implicitly_typed_local_variable_declaration + + + +statement + + + +; + + + += + + + +member_access + + + +) + + + +range_expression + + + +member_access + + + +var + + + +statement + + + +1 + + + +1 + + + +literal + + + +implicitly_typed_local_variable_declaration + + + +unary_expression + + + +declaration_statement + + + +( + + \ No newline at end of file diff --git a/tools/GrammarTesting/Tests/Parsing/Samples/v8/Index & Range/_Sample_Options.txt b/tools/GrammarTesting/Tests/Parsing/Samples/v8/Index & Range/_Sample_Options.txt new file mode 100644 index 000000000..c3810f510 --- /dev/null +++ b/tools/GrammarTesting/Tests/Parsing/Samples/v8/Index & Range/_Sample_Options.txt @@ -0,0 +1 @@ +-ms Rules -rt \ No newline at end of file diff --git a/tools/GrammarTesting/Tests/Parsing/Samples/v8/Index & Range/sample.cs b/tools/GrammarTesting/Tests/Parsing/Samples/v8/Index & Range/sample.cs new file mode 100644 index 000000000..27fabc203 --- /dev/null +++ b/tools/GrammarTesting/Tests/Parsing/Samples/v8/Index & Range/sample.cs @@ -0,0 +1,26 @@ +class IndexAndRangeExpressions +{ + void IndexAndRangeExpressions_1() + { + var a = ^1; + var b = ..^1; + var c = 0..; + var d = ..; + var e = new Struct(); // type with ops * and / taking Range + var f = e * 1 .. 2; + var g = e * ..; + var h = e * 1..; + var i = e * ..2; + var j = .. / e; + var k = ^2.. / e; + var l = .. ^1/e; + var m = ^2 ..^1 / e; + var n = 1..(.. 6).End; + var o = b.Start..5; + var p = (1..3).Start..5; + + var oops = (1..3)..5; // compile-time type error + var oops = 1..(3..5); // compile-time type error + var oops = 1..3..5; // compile-time syntax error + } +} \ No newline at end of file