vim

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

java_methods_indent4_signature.java (3971B)


      1 // VIM_TEST_SETUP let g:java_highlight_functions = 'indent4'
      2 // VIM_TEST_SETUP let g:java_highlight_signature = 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 Indent4$MethodsTests
      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 Indent4$MethodsTests() { }
     46     <T extends Comparable<T>> Indent4$MethodsTests(T t, Void v) { }
     47     private <T extends Comparable<T>> Indent4$MethodsTests(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     Indent4$MethodsTests.<α, β>μʭʭ$98_(ƒ)[0];
     76     }
     77 
     78     public static Class<?> classLock() { return Indent4$MethodsTests.class; }
     79 
     80     @Override @SuppressWarnings("cast")
     81     public String toString() { return (String) "Indent4$MethodsTests"; }
     82 }
     83 
     84 enum E4$
     85 {
     86     @SuppressWarnings("bespoke") A("a"),
     87     B("b"
     88         /*\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\*/),
     89     C("c", new Thread(
     90 
     91         () -> {
     92     })), D("d", (java.util.function.BooleanSupplier) () -> true),
     93     E("e", new char[] { 'a', 'b', 'c', 'd' }), F("f", new Object() {
     94         transient String name = "";
     95         @Override public String toString() { return this.name; }
     96     }), //\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//\//
     97     G("g"), @Deprecated H("h");
     98 
     99     final String s;
    100     private E4$(String s) { this.s = s; }
    101     private <δ> E4$(String s, δ dummy) { this(s); }
    102 
    103     @Override public String toString() { return name().toUpperCase(); }
    104 }
    105 
    106 class C4$Alias<T>
    107 {
    108     final T name; C4$Alias(T name) { this.name = name; }
    109 
    110     class Builder
    111     {
    112         final java.util.stream.Stream.Builder<T> builder =
    113             java.util.stream.Stream.<T>builder();
    114 
    115         C4$Alias<T>.Builder add(T x)
    116         {
    117             builder.accept(x);
    118             return this;
    119         }
    120 
    121         java.util.stream.Stream<T> build()
    122         {
    123             return builder.<T>build();
    124         }
    125     }
    126 
    127     static <A> C4$Alias<A>.Builder builder(A name)
    128     {
    129         return new C4$Alias<>(name).new Builder();
    130     }
    131 }