vim

Fork of vim, an acceptable text editor
git clone git://git.laack.co/vim.git
Log | Files | Refs | README | LICENSE

java_methods_indent8.java (4775B)


      1 // VIM_TEST_SETUP let g:java_highlight_functions = 'indent8'
      2 // VIM_TEST_SETUP let g:java_highlight_generics = 1
      3 // VIM_TEST_SETUP set encoding=utf-8 termencoding=utf-8
      4 import java.lang.annotation.ElementType;
      5 import java.lang.annotation.Target;
      6 
      7 abstract class Indent8MethodsTests
      8 { // DO NOT retab! THIS FILE; REMEMBER ABOUT testdir/ftplugin.
      9         // TYPES.
     10         record Τʬ<α>(α a) { }
     11 
     12         enum E
     13         {
     14                 A("a"), B("b"), C("c"), D("d"),
     15                 E("e"), F("f"), G("g"), H("h");
     16                 final String s;
     17                 private E(String s) { this.s = s; }
     18         }
     19 
     20         @Target({ElementType.METHOD, ElementType.CONSTRUCTOR})
     21         @java.lang.annotation.Repeatable(Tɐggablɘs.class)
     22         @interface Tɐggablɘ
     23         {
     24                 String[] value() default "";
     25         }
     26 
     27         @Target({ElementType.METHOD, ElementType.CONSTRUCTOR})
     28         @interface Tɐggablɘs
     29         {
     30                 Tɐggablɘ[] value();
     31         }
     32 
     33         interface Stylable<Α>
     34         {
     35                 default void ascii$0_() { }
     36                 default Α μʭʭ$0_() { return null; }
     37         }
     38 
     39         // FIELDS.
     40         private static final Class<?> CLASS_LOCK = classLock();
     41 
     42         private final Object instanceLock = new Object();
     43 
     44         // CONSTRUCTORS.
     45         @Tɐggablɘ @Tɐggablɘ protected Indent8MethodsTests() { }
     46         <T extends Comparable<T>> Indent8MethodsTests(T t, Void v) { }
     47         private <T extends Comparable<T>> Indent8MethodsTests(T t) { }
     48 
     49         // METHODS.
     50         @Tɐggablɘ @Tɐggablɘ abstract void ascii$0_(////////////////
     51                                                                 );
     52         @Tɐggablɘ @Tɐggablɘ abstract <α, β> Τʬ<α> μʭʭ$0_(
     53                                 @SuppressWarnings("bespoke") β b);
     54 
     55         @Tɐggablɘ private native void ascii$1_(/*////////////*/);
     56         @Tɐggablɘ private native <α, β> Τʬ<α>[] μʭʭ$1_(
     57                         java.util.function.Function<β, Τʬ<α>[]> ƒ);
     58 
     59         void Ascii$2_() { }
     60         <T, U extends Stylable<T>> void Μʭʭ$2_(U u) { }
     61 
     62         static final native synchronized void ascii$98_();
     63         static final native synchronized <α, β> Τʬ<α>[][] μʭʭ$98_(
     64                         java.util.function.Function<β, Τʬ<α>[][]> ƒ);
     65 
     66         @SuppressWarnings("strictfp")
     67         protected static final synchronized strictfp void ascii$99_()
     68         { ascii$98_(); }
     69 
     70         @SuppressWarnings("strictfp") protected
     71         static final synchronized strictfp <α, β> Τʬ<α>[] μʭʭ$99_(
     72                         java.util.function.Function<β, Τʬ<α>[][]> ƒ)
     73         {
     74                 return
     75         Indent8MethodsTests.<α, β>μʭʭ$98_(ƒ)[0];
     76         }
     77 
     78         public static Class<?> classLock() { return Indent8MethodsTests.class; }
     79 
     80         public <E extends Comparable<? super E>> java.util.List<E> filter(
     81                         java.util.function.Predicate<? super E> filter,
     82                         java.util.List<? extends E> cs)
     83         {
     84                 return cs.stream().filter(filter)
     85                         .collect(java.util.stream.Collectors.toUnmodifiableList());
     86         }
     87 
     88         @Override @SuppressWarnings("cast")
     89         public String toString() { return (String) "Indent8MethodsTests"; }
     90 }
     91 
     92 enum E8
     93 {
     94         @SuppressWarnings("bespoke") A("a"),
     95         B("b"
     96                 /*\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\*/),
     97         C("c", new Thread(
     98 
     99                 () -> {
    100         })), D("d", (java.util.function.BooleanSupplier) () -> true),
    101         E("e", new char[] { 'a', 'b', 'c', 'd' }), F("f", new Object() {
    102                 transient String name = "";
    103                 @Override public String toString() { return this.name; }
    104         }), //\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//
    105         G("g"), @Deprecated H("h");
    106 
    107         final String s;
    108         private E8(String s) { this.s = s; }
    109         private <δ> E8(String s, δ dummy) { this(s); }
    110 
    111         @Override public String toString() { return name().toUpperCase(); }
    112 }
    113 
    114 class C8Alias<T>
    115 {
    116         final T name; C8Alias(T name) { this.name = name; }
    117 
    118         class Builder
    119         {
    120                 final java.util.stream.Stream.Builder<T> builder =
    121                         java.util.stream.Stream.<T>builder();
    122 
    123                 C8Alias<T>.Builder add(T x)
    124                 {
    125                         builder.accept(x);
    126                         return this;
    127                 }
    128 
    129                 java.util.stream.Stream<T> build()
    130                 {
    131                         return builder.<T>build();
    132                 }
    133         }
    134 
    135         static <A> C8Alias<A>.Builder builder(A name)
    136         {
    137                 return new C8Alias<>(name).new Builder();
    138         }
    139 }