code: package com.puppycrawl.tools.checkstyle.grammar.antlr4;
  
  import java.awt.*;
  import java.lang.annotation.ElementType;
  import java.lang.annotation.Target;
  import java.lang.reflect.AnnotatedElement;
  import java.util.List;
  import java.util.Map;
  import java.util.TreeSet;
  
  import javax.net.ssl.KeyManager;
  
  public class InputAntlr4AstRegressionNewTypeTree {
          private static class Slot {
          double sin2Phi = 2 * StrictMath.sin(1.618033988749895);
          public int[] ci;
      }
  
      private static class Transformer {
  
      }
  
      private static class Ef {
          Transformer[] transformers = new Transformer[10];
          static boolean forward = true;
      }
  
      void goodMethod() {
          Slot slot = new Slot();
          slot.ci[5] = 10; // ok
          slot.ci = new int[6]; // ok
          double[] cZ = {1.1, 1.2}; // ok
          final double   dnZ = slot.sin2Phi               * cZ[1]; // ok
  
          final Ef ef = new Ef();
          final Transformer transformer =
              ef.forward ? ef.transformers[ef.transformers.length - 1] // ok
                      : ef.transformers[0]; // ok
  
      }
  
      void badMethod() {
          Slot slot = new Slot();
          slot.ci [5] = 10; // violation
          slot.ci = new int [6]; // violation
          double [] cZ = {1.1, 1.2}; // violation
          final double   dnZ = slot.sin2Phi               * cZ [1]; // violation
  
          final Ef ef = new Ef();
          final Transformer transformer =
              ef.forward ? ef.transformers [ef.transformers.length - 1] // violation
                      : ef.transformers [0]; // violation
  
          int[][
                  ]
                   a
                    []
                          [] ; // violation
                  int[][
                   ]
                   b
                   [] // violation
                          [] ; // violation
      }
  
      void varargLong(@I String @L [] @K [] @J ... vararg2) { } // ok
      @SuppressWarnings("unused")
      void withUpperBound(List<? extends int[][]> list) {}
  
      private static class SSLSecurity {
          static KeyManager[] truncateArray(KeyManager[] kmaw,
                                            KeyManager[] keyManagers) {
              return null;
          }
      }
  
  
      void method3(int x) {
          KeyManager[] kmaw = null;
           if (x == 1) {
               kmaw = (javax.net.ssl.KeyManager[])
                         SSLSecurity.truncateArray(kmaw,
                             new javax.net.ssl.KeyManager [3]); // violation
           }
      }
  
      enum FPMethodArgs {
  
          IGNN,
          IIGNN,
          GNNII,
          GNNC;
  
          public Class<?>[] getMethodArguments(boolean isFPType) {
              Class<?> N = (isFPType) ? Float.TYPE : Integer.TYPE;
              Class<?> G = (isFPType) ? Graphics2D.class : Graphics.class;
              switch (this) {
                  case IGNN:
                      return new Class<?>[]{Integer.TYPE, G, N, N};
                  case IIGNN:
                      return new Class<?>[]{Integer.TYPE, Integer.TYPE, G, N, N};
                  case GNNII:
                      return new Class<?>[]{G, N, N, Integer.TYPE, Integer.TYPE};
                  case GNNC:
                      return new Class<?>[]{G, N, N, Character.TYPE};
                  default:
                      throw new RuntimeException("Unknown method arguments!");
              }
          }
      }
  
      public static class IntData {
          int[] xorData;
  
          IntData(Object srcPixel, Object xorPixel) {
              this.xorData = (int[]) srcPixel; // violation
              this.xorData = (int[]) xorPixel; // violation
          }
  
          protected void xorPixel(Object pixData) {
              int[] dstData = (int[]) pixData; // violation
              for (int i = 0; i < dstData.length; i++) {
                  dstData[i] ^= xorData[i];
              }
          }
  
          Object[] getXorData() {
              return new Object[5];
          }
  
          void method6() {
              if (getXorData().length == 5
                      && this.getXorData()[1] != IntData.class // ok
                      || this.getXorData()[5] != IntData.class) {
                  System.out.println(getXorData().length);
              }
          }
  
      }
      protected TreeSet<byte []> sortedPrefixes = createTreeSet(); // violation
  
      TreeSet<byte[]> createTreeSet() { // ok
          return null;
      } // ok
  
      public Object newInstance(Object[] objects){
              // Run constructor
          InputAntlr4AstRegressionNewTypeTree tmpConstructor = null;
          return tmpConstructor.newInstance((Object[])null);
      }
  
      public TypeVariable<Class<String>>[] getTypeParameters() {
          ClassRepository info = getGenericInfo();
          if (info != null)
              return (TypeVariable<Class<String>>[])info.getTypeParameters();
          else
              return (TypeVariable<Class<String>>[])new TypeVariable<?>[0];
      }
      class ClassRepository {
  
          public Object getTypeParameters() {
              return null;
          }
      }
      class TypeVariable<E> {
  
      }
  
      private ClassRepository getGenericInfo() {
          return null;
      }
      String[] c, d[]; // ok
      String [] e, f []; // violation
  
      public enum Stooge {
          MOE, CURLY, LARRY,
      }
      static void checkArrayTypes1(ArrayTypes at, AnnotatedElement e) {
          if (!(at.cls()[0]  == Map.class    &&
                at.e()[0]    == Stooge.MOE  )) {
  
          }
      }
  
      static class ArrayTypes {
          Object[] cls;
  
          public Stooge[] e() {
              return null;
          }
  
  
  
          Object[] cls() {
              return cls;
          }
  
          public int[] a() {
              return null;
          }
      }
      int[][
      ]
       w
       [] // violation
              [] ; // violation
      int[][
       ]
       z
      [] // violation
              [] ; // violation
  
      static class P {
          private int x;
  
          public void set3(P p) {
                synchronized (this) { // violation
                    p.x = get()[0];
                }
            }
  
          public void set4(P p) {
                synchronized(this) { // ok
                    p.x = get()[0];
                }
            }
  
          private int[] get() {
              return null;
          }
      }
  
      private @Nullable int array2 @Nullable [] @Nullable [];
  }
  
  
  @Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER})
  @interface Nullable{}
  
  @Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER})
  @interface I {}
  
  @Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER})
  @interface J {}
  
  @Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER})
  @interface K {}
  
  @Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER})
  @interface L {}
  