0
0
mirror of https://github.com/vim/vim.git synced 2025-07-04 23:07:33 -04:00
vim/runtime/syntax/testdir/input/java_contextual_keywords.java
Aliaksei Budavei 5ccdcc482e
runtime(java): Improve the matching of contextual keywords
- Recognise a _record_ contextual keyword.
- Recognise _non-sealed_, _sealed_, and _permits_ contextual
  keywords.
- Admit _$_ to keyword characters.
- Group _abstract_, _final_, _default_, _(non-)sealed_
  (apart from _(non-)sealed_, the incompossibility of these
  modifiers calls for attention).
- Remove another _synchronized_ keyword redefinition.

I have also replaced a function with an expression.  Before
patch 8.1.0515, it should have been declared :function! to
work with repeatable script sourcing; there is less to worry
about with an expression.

References:
https://openjdk.org/jeps/395 (Records)
https://openjdk.org/jeps/409 (Sealed Classes)
https://docs.oracle.com/javase/specs/jls/se21/html/jls-3.html#jls-3.8

closes: #14403

Signed-off-by: Aliaksei Budavei <0x000c70@gmail.com>
Signed-off-by: Christian Brabandt <cb@256bit.org>
2024-04-04 21:51:18 +02:00

49 lines
1.9 KiB
Java

class ContextualKeywordsTests // See JLS, §3.9 Keywords.
{
private ContextualKeywordsTests() { throw new Error(); }
// ModuleDeclaration: module open.
void module() { Object module = null; when(); }
void open() { Object open = null; module(); }
// ModuleDirective: exports opens provides requires to uses with.
void exports() { Object exports = null; open(); }
void opens() { Object opens = null; exports(); }
void provides() { Object provides = null; opens(); }
void requires() { Object requires = null; provides(); }
void to() { Object to = null; requires(); }
void uses() { Object uses = null; to(); }
void with() { Object with = null; uses(); }
// RequiresModifier: transitive.
void transitive() { Object transitive = null; with(); }
// LocalVariableType | LambdaParameterType: var.
void var() { var var = new Object(); transitive(); }
// YieldStatement: yield (see java_switch.java).
void yield() { Object yield = null; var(); }
// RecordDeclaration: record.
void record() { Object record = null; this.yield(); }
// Normal{Class,Interface}Declaration: non-sealed permits sealed.
void permits() { Object permits = null; record(); }
void sealed() { Object sealed = null; permits(); }
// Guard: when (see java_switch.java).
void when() { Object when = null; sealed(); }
sealed interface I1 permits C1, I3 { }
sealed interface I2 permits C1, I3 { }
non-sealed interface I3 extends I1, I2 { }
interface I4 extends I3 { }
abstract sealed class C1 implements I1, I2 permits C2, C3 { }
abstract non-sealed class C2 extends C1 { }
final class C3 extends C1 implements I3 { }
class C4 extends C2 { }
record R() implements I3 { }
enum E implements I3 { INSTANCE }
static <T> I<T> i1() { return (var var) -> var; }
static <T> I<T> i2() { return (T var) -> var; }
static <T> I<T> i3() { return (var) -> var; }
static <T> I<T> i4() { return var -> var; }
interface I<T> { T i(T i); default I<T> self() { return this; } }
}