src/java.base/share/classes/sun/reflect/annotation/TypeAnnotationParser.java

*** 1,7 ****
  /*
!  * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.  Oracle designates this
--- 1,7 ----
  /*
!  * Copyright (c) 2013, 2015, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.  Oracle designates this
*** 30,40 ****
  import java.nio.ByteBuffer;
  import java.nio.BufferUnderflowException;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.List;
- import java.util.HashMap;
  import java.util.LinkedHashMap;
  import java.util.Map;
  import jdk.internal.misc.SharedSecrets;
  import jdk.internal.misc.JavaLangAccess;
  import sun.reflect.ConstantPool;
--- 30,39 ----
*** 65,86 ****
              AnnotatedElement decl,
              Class<?> container,
              Type type,
              TypeAnnotationTarget filter) {
          TypeAnnotation[] tas = parseTypeAnnotations(rawAnnotations,
!                                                     cp,
!                                                     decl,
!                                                     container);
          List<TypeAnnotation> l = new ArrayList<>(tas.length);
          for (TypeAnnotation t : tas) {
              TypeAnnotationTargetInfo ti = t.getTargetInfo();
              if (ti.getTarget() == filter)
                  l.add(t);
          }
          TypeAnnotation[] typeAnnotations = l.toArray(EMPTY_TYPE_ANNOTATION_ARRAY);
          return AnnotatedTypeFactory.buildAnnotatedType(type,
!                                                        LocationInfo.BASE_LOCATION,
                                                         typeAnnotations,
                                                         typeAnnotations,
                                                         decl);
      }
  
--- 64,84 ----
              AnnotatedElement decl,
              Class<?> container,
              Type type,
              TypeAnnotationTarget filter) {
          TypeAnnotation[] tas = parseTypeAnnotations(rawAnnotations,
!                 cp, decl, container);
! 
          List<TypeAnnotation> l = new ArrayList<>(tas.length);
          for (TypeAnnotation t : tas) {
              TypeAnnotationTargetInfo ti = t.getTargetInfo();
              if (ti.getTarget() == filter)
                  l.add(t);
          }
          TypeAnnotation[] typeAnnotations = l.toArray(EMPTY_TYPE_ANNOTATION_ARRAY);
          return AnnotatedTypeFactory.buildAnnotatedType(type,
!                 AnnotatedTypeFactory.nestingForType(type, LocationInfo.BASE_LOCATION),
                  typeAnnotations,
                  typeAnnotations,
                  decl);
      }
  
*** 108,120 ****
          Arrays.fill(result, AnnotatedTypeFactory.EMPTY_ANNOTATED_TYPE);
          @SuppressWarnings("rawtypes")
          ArrayList[] l = new ArrayList[size]; // array of ArrayList<TypeAnnotation>
  
          TypeAnnotation[] tas = parseTypeAnnotations(rawAnnotations,
!                                                     cp,
!                                                     decl,
!                                                     container);
          for (TypeAnnotation t : tas) {
              TypeAnnotationTargetInfo ti = t.getTargetInfo();
              if (ti.getTarget() == filter) {
                  int pos = ti.getCount();
                  if (l[pos] == null) {
--- 106,117 ----
          Arrays.fill(result, AnnotatedTypeFactory.EMPTY_ANNOTATED_TYPE);
          @SuppressWarnings("rawtypes")
          ArrayList[] l = new ArrayList[size]; // array of ArrayList<TypeAnnotation>
  
          TypeAnnotation[] tas = parseTypeAnnotations(rawAnnotations,
!                 cp, decl, container);
! 
          for (TypeAnnotation t : tas) {
              TypeAnnotationTargetInfo ti = t.getTargetInfo();
              if (ti.getTarget() == filter) {
                  int pos = ti.getCount();
                  if (l[pos] == null) {
*** 134,144 ****
                  typeAnnotations = list.toArray(new TypeAnnotation[list.size()]);
              } else {
                  typeAnnotations = EMPTY_TYPE_ANNOTATION_ARRAY;
              }
              result[i] = AnnotatedTypeFactory.buildAnnotatedType(types[i],
!                                                                 LocationInfo.BASE_LOCATION,
                                                                  typeAnnotations,
                                                                  typeAnnotations,
                                                                  decl);
  
          }
--- 131,141 ----
                  typeAnnotations = list.toArray(new TypeAnnotation[list.size()]);
              } else {
                  typeAnnotations = EMPTY_TYPE_ANNOTATION_ARRAY;
              }
              result[i] = AnnotatedTypeFactory.buildAnnotatedType(types[i],
!                     AnnotatedTypeFactory.nestingForType(types[i], LocationInfo.BASE_LOCATION),
                      typeAnnotations,
                      typeAnnotations,
                      decl);
  
          }
*** 276,286 ****
                              tInfo.getCount() == typeVarIndex) {
                          l.add(t);
                      }
                  }
                  res[i] = AnnotatedTypeFactory.buildAnnotatedType(bounds[i],
!                         loc,
                          l.toArray(EMPTY_TYPE_ANNOTATION_ARRAY),
                          candidates.toArray(EMPTY_TYPE_ANNOTATION_ARRAY),
                          (AnnotatedElement)decl);
              }
              return res;
--- 273,283 ----
                              tInfo.getCount() == typeVarIndex) {
                          l.add(t);
                      }
                  }
                  res[i] = AnnotatedTypeFactory.buildAnnotatedType(bounds[i],
!                         AnnotatedTypeFactory.nestingForType(bounds[i], loc),
                          l.toArray(EMPTY_TYPE_ANNOTATION_ARRAY),
                          candidates.toArray(EMPTY_TYPE_ANNOTATION_ARRAY),
                          (AnnotatedElement)decl);
              }
              return res;