Renamed tightName to ParameterIdentifier + removed some keywords from Identifier.

		return this.Identifier();

	}

	@ValueConverter(rule = "org.etsi.mts.tdl.TDLtx.TightName")

	public IValueConverter<String> TightName() {

	@ValueConverter(rule = "org.etsi.mts.tdl.TDLtx.ParameterIdentifier")

	public IValueConverter<String> ParameterIdentifier() {

		return this.Identifier();

	}

	@ValueConverter(rule = "TightName")

	public IValueConverter<String> TDLtxTightName() {

	@ValueConverter(rule = "ParameterIdentifier")

	public IValueConverter<String> TDLtxParameterIdentifier() {

		return this.Identifier();

	}

	@ValueConverter(rule = "org.etsi.mts.tdl.TDLtx.PackageName")

	public IValueConverter<String> PackageName() {

		return this.Identifier();

	}

	@ValueConverter(rule = "PackageName")

	public IValueConverter<String> TDLtxPackageName() {

		return this.Identifier();

	}

| Position | Description | Example |

|---|---|---|

| **Free** | Reachable as a first token of an expression (DataUseWrapped). Competes with `'instance'`, `'parameter'`, `'omit'`, `'an'`, `'size'`, `'not'`, `'-'`, `'('`, `'?'`, `'*'`, `'@'` as alternative starts. | `dataElement` in DataElementUse, `componentInstance` in VariableUse |

| **Tight** | Anchored on at least one side by a structural token (`.`, `(`, type-ref, `=`, `\|`, `,`, `)`). No competing alternative starts with an identifier in this state. | Member name after `.`, parameter name after `(` in a binding |

| **Introducer-anchored** | Preceded by a strong introducer keyword (`Type`, `Action`, `'execute'`, `'perform'`, …). The next token's role is fixed by the parent rule. | Top-level decl names, anchored cross-refs |

| **Parameter / Tight** | Anchored on at least one side by a structural token (`.`, `(`, type-ref, `=`, `\|`, `,`, `)`). No competing alternative starts with an identifier in this state. | Member name after `.`, parameter name after `(` in a binding |

| **Introducer-anchored** | Preceded by a strong introducer keyword (`Type`, `Action`, `'execute'`, `'perform'`, …). The next token's role is fixed by the parent rule. Uses the same admission set as parameter slots; the `DeclName` alias documents intent at the grammar surface. | Top-level decl names, anchored cross-refs |

| **Qualifier-prefixed** (TO) | Preceded by `Qualifier*` greedy chain in TO contexts. Both the qualifier loop and the name slot accept any identifier; the parser greedily takes all but the last. | TO `LiteralValueFragment.name`, `DataContent.name` |

Free positions are the most constrained — every keyword admitted there must

not be a sibling-first token, not a Qualifier-vocabulary word, and not an

expression operator. Tight positions are looser. Introducer-anchored

positions are the loosest, bounded mostly by what the rule's *follower*

keyword set is.

expression operator. Parameter/tight positions are looser. Introducer-anchored

positions share the parameter-position admission set under the `DeclName`

alias.

## TDL-side rules (three tiers)

## TDL-side rules (two tiers)

### `Identifier` — free-position rule

'entity' 'event' 'component' 'variable' 'timer'

'argument' 'action' 'behaviour'

'verdict' 'exception'

'get'

'when' 'then'

'check' 'where'

'sends' 'receives' 'triggers' 'accepts'

```

Excluded and why:

Excluded from `Identifier` and why:

| Excluded | Reason |

|---|---|

| `a`, `an`, `the` | `ArticleQualifier` member; `'an'` also a sibling-first of `DataInstanceUse` |

| `and`, `or`, `xor`, `not`, `mod`, `as` | Expression operators / cast keyword |

| `gate` | Would clash with the `'on' (ComponentInstance | 'gate' GR)` discriminator in `Quiescence` |

| `sends`, `receives`, `triggers` | Discriminator keywords in `Message` and `ReceiveMessage`. Admissible only at parameter positions where the discriminator role is unreachable |

| `accepts` | Follower of the `Gate` decl name (`'Gate' name 'accepts' dataType+=...`). Admissible only at parameter positions |

| `get` | `.get(LParen ... RParen)` is a collection method-call form. Admissible only at parameter positions (where the position is anchored and the method-call competition is unreachable) |

| `when`, `then`, `check`, `where` | **Excluded from every generic identifier rule** — see "Universally excluded keywords" below |

### `TightName` — tight-position rule

### `ParameterIdentifier` — parameter/tight-position rule

Used at: `Member.name` (struct decl), `MemberReference` (after `.`),

`MemberAssignment` cross-ref, TDL-side `ParameterBinding.parameter` cross-ref.

`MemberAssignment` cross-ref, `ParameterBinding.parameter` cross-ref,

`FormalParameter.name`, `ProcedureParameter.name`, the `'parameter'

[FormalParameter|...]` slot, and the `'where' parameter ... 'is'` slot. Also

the underlying admission set for `DeclName` (see below).

Extends `Identifier` with keywords that are blocked from `Identifier`

by expression-level conflicts but become safe when the position is

anchored on at least one side by a structural token:

Extends `Identifier` with keywords that are blocked from `Identifier` by

expression-level conflicts but become safe when the position is anchored on

at least one side by a structural token:

```

+ 'start' 'stop'

+ 'size'

+ 'instance' 'parameter'

+ 'gate'

+ 'sends' 'receives' 'triggers' 'accepts'

+ 'get'

```

(The `Identifier`-blocking reasons — sibling-first tokens, Qualifier

vocabulary, Quiescence's `'gate'` discriminator — are all unreachable from

inside a tight-anchored slot, so the keywords become safe.)

vocabulary, Quiescence's `'gate'` discriminator, Message/ReceiveMessage

verb discriminators, Gate-decl `'accepts'` follower, the `.get(...)`

method-call form — are all unreachable from inside a parameter-anchored

slot, so the keywords become safe.)

### `DeclName` — introducer-anchored rule

### `DeclName` — alias of `ParameterIdentifier`

Used at TDL-side decl-name slots (top-level introducer-anchored) and at

their anchored cross-refs:

  in typed-decl positions, `[ConstraintType|DeclName]`,

  `[MappableDataElement|DeclName]` in `Map`, `[Timer|DeclName]` after `'::'`.

Admits everything `Identifier` admits, plus the same extras `TightName`

adds, plus a few more that are tight-or-introducer-only:

Defined as a one-line alias:

```xtext

DeclName: ParameterIdentifier;

```

+ everything Identifier admits

+ everything TightName adds

+ 'during' 'within'

+ 'omit'

Kept as a separate rule (rather than inlining `ParameterIdentifier` at use

sites) so that decl-name and introducer-anchored cross-ref slots remain

self-documenting at the grammar surface. Zero parser cost — the alias is a

parser-rule indirection that returns the matched string.

The previous independent `DeclName` rule admitted three keywords (`during`,

`within`, `omit`) that `ParameterIdentifier` does not, and excluded

`accepts` (Gate decl follower) which `ParameterIdentifier` does admit. The

merge trades those edge admissions for a simpler two-tier rule structure.

The only practical consequence is that a name like `accepts` at a Gate decl

will consume the follower keyword and produce a confusing parse error; a

user hitting that case can escape with `^accepts`.

## Universally excluded keywords

The keywords `when`, `then`, `check`, `where` are excluded from **every**

generic identifier rule (`Identifier`, `ParameterIdentifier`, `AIdentifier`).

They are reserved annotation-key keywords parsed via dedicated single-keyword

rules:

```xtext

When:  'when' ;

Then:  'then' ;

Check: 'check' ;

Where: 'where' ;

WhenAnnotation:  key=[tdl::AnnotationType|When] ;

ThenAnnotation:  key=[tdl::AnnotationType|Then] ;

CheckAnnotation: key=[tdl::AnnotationType|CheckIdentifier] ; // CheckIdentifier: Check | Where

```

Excluded and why:

`where` also appears as a structural keyword in `'where' 'it' 'is' ...`

(value-assignment-message) and `'where' parameter ... 'is' ...`

(value-assignment-procedure).

| Excluded | Reason |

|---|---|

| `with` | Universal optional decl follower (body-block opener) |

| `extends` | Follower of `Type`, `Structure`, `Component`, `Gate` decl names |

| `optional` | Follower of `Structure` decl name |

| `of` | Follower of `Collection` decl name |

| `returns` | Follower of `Function` decl name |

| `accepts` | Follower of `Gate` decl name |

| `uses` | Follower of `TestDescription` decl name |

| `now` | Follower of `TimeLabel` decl name |

| `as` | Follower of `ComponentInstance` decl name; introducer of mapping clauses |

| `Description`, `Reference`, `Configuration`, `PICS`, `PIXIT`, `Bindings`, `Objective` | TP / Variant header-section keywords |

| `Note` | Annotation-comment introducer |

| Top-level / capitalized section keywords (`Package`, `Type`, `Structure`, `Action`, `Function`, …) | Sibling decl introducers |

| `and`, `or`, `xor`, `not`, `mod` | Expression operators |

**Consequence:** a user cannot declare a generic `Annotation` type, or any

other named element, with one of these four names. This is intentional —

they are reserved annotation keywords whose meaning is fixed by the grammar.

A user who really needs one of these as a name can still use the `^when`

escape syntax (the `ID` terminal accepts a leading `^`), and the resulting

declared name will be `when`, but it cannot be referenced through any of

the generic identifier rules.

## Auxiliary rules

### `AIdentifier` — annotation key/name

Annotation keys and `AnnotationType` decl names. Extends `Identifier` with

the multi-word Test-Purpose-block keywords so `@Initial conditions`,

`@Expected behaviour`, `@PICS`, `@PIXIT`, `@Test Purpose Description` parse

as annotation keys. `@when`, `@then`, `@check`, `@where` parse via the

`Identifier` branch since those four keywords are admitted there.

Annotation keys (generic `Annotation: key=[AnnotationType|AIdentifier]`) and

`AnnotationType` decl names (`'Annotation' name=AIdentifier`). Extends

`Identifier` with the multi-word Test-Purpose-block keywords so

`@Initial conditions`, `@Expected behaviour`, `@PICS`, `@PIXIT`,

`@Test Purpose Description` parse as annotation keys.

`@when`, `@then`, `@check`, `@where` parse via the dedicated

`WhenAnnotation` / `ThenAnnotation` / `CheckAnnotation` rules — not via

`AIdentifier`, since those four keywords are universally excluded from

generic identifier rules (see above).

### `CheckIdentifier` — closed vocabulary

  `Function`, `ConstraintType`, `ComponentType`, `GateType`,

  `ProcedureSignature`, `Time`, `Timer`, `MappableDataElement`,

  `PackageableElement` via `Import`/`extending`) use `DeclName` on both

  sides.

  sides. Since `DeclName` is an alias of `ParameterIdentifier`, decl and

  cross-ref share the same admission set automatically.

- `Member`, `FormalParameter`, `ProcedureParameter`, and the abstract

  `Parameter` cross-refs (in `ParameterBinding`, `ParameterMapping`,

  `ValueAssignmentProcedure`, and the `'parameter' [FormalParameter|...]`

  slot) all use `TightName` on both sides.

  slot) all use `ParameterIdentifier` on both sides.

- `GateReference` is two parities in one rule. Auto-qualified

  `<CI.name>::<GI.name>` references parse via `GRIdentifier`'s two-segment

  form, where each segment is `Identifier` to match the underlying

| Rule | Reach | Admits keywords | Use it for |

|---|---|---|---|

| `Identifier` | Free (expression-reachable) | Most conservative | Names referenced in expressions |

| `TightName` | Tight (anchored both sides) | + sibling-first / Qualifier-vocab safe | Member / parameter-binding tight slots |

| `DeclName` | Introducer-anchored | + nearly all non-follower keywords | Top-level decls and their anchored cross-refs |

| `ParameterIdentifier` | Parameter / tight (anchored both sides) | + sibling-first / Qualifier-vocab safe + gate-action verbs + `get` | Member / parameter slots |

| `DeclName` | Introducer-anchored (alias of `ParameterIdentifier`) | Same as `ParameterIdentifier` | Top-level decls and their anchored cross-refs |

| `TOIdentifier` | TO sub-language only | Frozen narrow | All TO name positions |

| `AIdentifier` | Annotation key/name | Identifier + TP-block multi-word keywords | Annotation key/name slots |

| `AIdentifier` | Annotation key/name | Identifier + TP-block multi-word keywords | Generic annotation key/name slots (excludes `when`/`then`/`check`/`where`) |

| `KIdentifier` | TO Event names | ID + gate-action keywords | `to::Event` decl/ref |

| `CheckIdentifier` | Annotation key for check/where | Closed two-keyword choice | Check-annotation key only |

| `GRIdentifier` | Gate-reference cross-ref | Identifier per segment | `component::gate` cross-ref |

ParameterMapping returns tdl::ParameterMapping:

    AnnotationCommentFragment

    parameter=[tdl::Parameter|TightName]

    parameter=[tdl::Parameter|ParameterIdentifier]

    '->' parameterURI=EString

;

    AnnotationCommentFragment

    (isOptional?='optional')?

    dataType=[tdl::DataType|Identifier]

    name=TightName

    name=ParameterIdentifier

    (LBrace constraint+=Constraint RBrace)*

;

MemberAssignment returns tdl::MemberAssignment:

    AnnotationCommentFragment

    member=[tdl::Member|TightName]

    member=[tdl::Member|ParameterIdentifier]

    '=' memberSpec=DataUse

;

    AnnotationFragment?

    kind=ParameterKind

    dataType=[tdl::DataType|Identifier]

    name=TightName

    name=ParameterIdentifier

    WithCommentFragment?

;

FormalParameter returns tdl::FormalParameter:

    AnnotationFragment?

    dataType=[tdl::DataType|Identifier]

    name=TightName

    name=ParameterIdentifier

    WithCommentFragment?

;

ParameterBinding returns tdl::ParameterBinding:

    parameter=[tdl::Parameter|TightName]

    parameter=[tdl::Parameter|ParameterIdentifier]

	//TODO: is there a better way? -> will need to be rethought, semantics for collections still problematic..

	('|' ParameterReductionFragment)?

    '=' dataUse=DataUse

;

MemberReference returns tdl::MemberReference:

    ('.' member=[tdl::Member|TightName])

    ('.' member=[tdl::Member|ParameterIdentifier])

    |

    ('.' 'get' LParen collectionIndex=DataUse RParen)

;

//TODO: deprecated?

FormalParameterUse returns tdl::FormalParameterUse:

    'parameter' parameter=[tdl::FormalParameter|TightName]

    'parameter' parameter=[tdl::FormalParameter|ParameterIdentifier]

    ParameterBindingFragment?

    // ReductionFragment now handled by PostfixExpression

;

    // Behaviour ultimately recurses through

    // Block→Behaviour+, and several Behaviour first-tokens are identifier-shape

    // (ProcedureCall labels, VariableUse, Message source-gate via GRIdentifier).

    =>(behaviourDescription=BehaviourDescription)?

    (behaviourDescription=BehaviourDescription)?

;

fragment TDPrefixFragment returns tdl::TestDescription:

ValueAssignmentProcedure returns tdl::ValueAssignment:

    //NOTE: No name, annotations or comments

    'where' parameter=[tdl::Parameter|TightName] 'is'

    'where' parameter=[tdl::Parameter|ParameterIdentifier] 'is'

    'assigned' 'to' variable=[tdl::Variable|Identifier]

;

// it would clash with the `'on' (ComponentInstance | 'gate' GR)` discriminator

// in Quiescence (an Identifier-shaped 'gate' would become indistinguishable

// from the literal 'gate' that introduces the gate-reference alternative).

//

// Verbs admissible only at parameter/member positions ('sends', 'receives',

// 'triggers', 'accepts', 'get') live in ParameterIdentifier, not here — they

// are sibling-discriminator or method-call keywords whose use as a free

// expression-position name would be ambiguous or would consume a follower

// keyword the parent rule needs.

//

// Excluded from Identifier and ParameterIdentifier: 'when', 'then', 'check',

// 'where'. These four are reserved at expression/parameter positions —

// 'check'/'where' introduce CheckFragment inside DataUse braces, and

// 'when'/'then' introduce WhenBehaviour/ThenBehaviour structurally. They

// are admitted at annotation-name positions via AIdentifier so that users

// may declare and reference custom AnnotationTypes named with these words.

Identifier:

    ID

    //implementation specific

    | 'entity' | 'event' | 'component' | 'variable' | 'timer'

    | 'argument' | 'action' | 'behaviour'

    | 'verdict' | 'exception'

    | 'get'

    | 'when' | 'then'

    | 'check' | 'where'

    | 'sends' | 'receives' | 'triggers' | 'accepts'

;

// TightName — extends Identifier with keywords admissible in

// "tight name" positions: anchored on the left by a structural token

// ('.', '(' for parameter binding, or a type-ref) and on the right by

// '=', '|', ',', or ')'. Used at: Member name (struct decl),

// MemberReference (after '.'), MemberAssignment cross-ref,

// ParameterBinding parameter cross-ref. (TOParameterBinding stays on

// TOIdentifier per the TO-isolation principle.)

// ParameterIdentifier — the wider rule used at parameter-like positions

// (members of structured aggregates and formal/procedure parameters), all

// of which are anchored on the left by a structural token ('.', '(' for

// parameter binding, or a type-ref) and on the right by '=', '|', ',',

// or ')'. Used at: Member name (struct decl), MemberReference (after '.'),

// MemberAssignment cross-ref, ParameterBinding parameter cross-ref,

// FormalParameter.name, ProcedureParameter.name, the 'parameter'

// [FormalParameter|...] slot, and the 'where' parameter ... 'is' slot.

//

// Also used by the DeclName alias for TDL-side decl-name slots and their

// introducer-anchored cross-refs ('execute', 'perform', 'uses', 'calls',

// 'responds with', etc.).

//

// Only keywords NOT already in Identifier are listed here. Tight position

// admits more than free position: DataUseWrapped sibling-first tokens

// ('size', 'instance', 'parameter') and Qualifier-vocabulary words

// ('start', 'stop', 'from', 'to', 'before', 'after') are unreachable here

// because the surrounding context fixes parser state. Also adds 'gate'

// (excluded from Identifier due to Quiescence discriminator clash).

TightName:

// Admits everything Identifier admits, plus:

//  - sibling-first DataUseWrapped tokens ('size', 'instance', 'parameter')

//    — unreachable from inside an anchored parameter slot

//  - Qualifier-vocabulary words ('start', 'stop', 'from', 'to', 'before',

//    'after') — same reason

//  - 'gate' — excluded from Identifier because of the Quiescence

//    `'on' (ComponentInstance | 'gate' GR)` discriminator clash; safe at

//    parameter positions

//  - the gate-action verbs 'sends', 'receives', 'triggers', 'accepts'

//    — moved out of Identifier to avoid clashes at expression positions

//    (Message/ReceiveMessage discriminators and the Gate decl 'accepts'

//    follower); admissible at parameter positions

//  - 'get' — moved out of Identifier because '.get(...)' is a collection

//    method-call form; safe at parameter positions

//

// Excluded here (see Identifier rule comment): 'when', 'then', 'check',

// 'where' — admitted only at annotation-name positions via AIdentifier.

ParameterIdentifier:

    Identifier

    | 'start' | 'stop'

    | 'from' | 'to'

    | 'size'

    | 'instance' | 'parameter'

    | 'gate'

    | 'sends' | 'receives' | 'triggers' | 'accepts'

    | 'get'

;

// AIdentifier — annotation key/name rule. Extends Identifier with the

// (multi-word) Test-Purpose-block keywords so e.g. `@Initial conditions`,

// `@Expected behaviour`, `@PICS`, `@PIXIT` parse as annotation keys.

// 'when', 'then', 'check', 'where' are admitted via the Identifier branch.

// `@Expected behaviour`, `@PICS`, `@PIXIT` parse as annotation keys, plus

// 'when', 'then', 'check', 'where' so the generic 'Annotation' name=AIdentifier

// decl form and `[AnnotationType|AIdentifier]` cross-refs admit those keywords

// as annotation names alongside the dedicated WhenAnnotation, ThenAnnotation,

// and CheckAnnotation rules (which remain in use at structural positions —

// WhenBehaviour/ThenBehaviour and CheckFragment).

AIdentifier:

    Identifier

    | InitialBlockName

    | TestPurposeDescriptionName

    | PICSName

    | PIXITName

    | 'when' | 'then' | 'check' | 'where'

;

CheckIdentifier:

    | 'name' | 'type' | 'value' | 'attribute'

;

// DeclName — wide identifier rule for TDL-side decl-name slots and their

// introducer-anchored cross-refs (e.g. 'execute' [TestDescription|DeclName],

// 'perform' [Action|DeclName], 'uses' [TestConfiguration|DeclName]).

//

// Admits everything Identifier admits, plus keywords that are blocked from

// Identifier by expression-level conflicts (DataUseWrapped sibling-firsts and

// Qualifier vocabulary) but become safe once the surrounding rule pins the

// position with a strong introducer keyword.

//

// Excluded: direct decl-name followers ('with', 'extends', 'optional', 'of',

// 'returns', 'accepts', 'uses', 'now', 'as'); top-level introducers and

// capitalized section keywords; expression operators ('and', 'or', 'xor',

// 'not', 'mod').

// DeclName — alias of ParameterIdentifier. Kept as a separate rule (rather

// than inlining ParameterIdentifier at use sites) so that decl-name and

// introducer-anchored cross-ref slots remain self-documenting at the

// grammar surface. The previous independent DeclName rule admitted three

// keywords ('during', 'within', 'omit') that ParameterIdentifier does not,

// and excluded 'accepts' (Gate decl follower) which ParameterIdentifier

// does admit. Merging the two trades those edge admissions for a simpler

// two-tier rule structure; the only practical consequence is that names

// like 'accepts' at a Gate decl will consume the follower keyword (a user

// hitting that case can escape with `^accepts`).

DeclName:

    ID

    // Same admissions as Identifier (free-position name rule)

    | 'name' | 'type' | 'value' | 'attribute'

    | 'time' | 'point' | 'default'

    | 'entity' | 'event' | 'component' | 'variable' | 'timer'

    | 'argument' | 'action' | 'behaviour'

    | 'verdict' | 'exception'

    | 'get'

    | 'when' | 'then'

    | 'check' | 'where'

    | 'sends' | 'receives' | 'triggers'

    // Extras safe in introducer-anchored positions

    | 'start' | 'stop'

    | 'from' | 'to'

    | 'before' | 'after' | 'during' | 'within'

    | 'size' | 'instance' | 'parameter'

    | 'gate'

    | 'omit'

    ParameterIdentifier

;

// GRIdentifier — qualified gate-reference form `component::gate`. Used only

;

TOMemberReference returns tdl::MemberReference:

    ('.' member=[tdl::Member|TightName])

    ('.' member=[tdl::Member|ParameterIdentifier])

    |

    ('.' 'get' LParen collectionIndex=TODataUse RParen)

;