jdk-sandbox: comparison src/jdk.compiler/share/classes/com/sun/tools/javac/jvm/ClassReader.java

equal deleted inserted replaced

-:e9a564028f2f
+:68c6f57c40d4
 /** A table to hold the constant pool indices for method parameter
 * names, as given in LocalVariableTable attributes.
 */
 int[] parameterNameIndices;
+/**
+* A table to hold annotations for method parameters.
+*/
+ParameterAnnotations[] parameterAnnotations;
+/**
+* A holder for parameter annotations.
+*/
+static class ParameterAnnotations {
+List<CompoundAnnotationProxy> proxies;
+void add(List<CompoundAnnotationProxy> newAnnotations) {
+if (proxies == null) {
+proxies = newAnnotations;
+} else {
+proxies = proxies.prependList(newAnnotations);
+}
+}
+}
 /**
 * Whether or not any parameter names have been found.
 */
 boolean haveParameterNameIndices;
 }
 },
 new AttributeReader(names.RuntimeInvisibleParameterAnnotations, V49, CLASS_OR_MEMBER_ATTRIBUTE) {
 protected void read(Symbol sym, int attrLen) {
-attachParameterAnnotations(sym);
+readParameterAnnotations(sym);
 }
 },
 new AttributeReader(names.RuntimeVisibleAnnotations, V49, CLASS_OR_MEMBER_ATTRIBUTE) {
 protected void read(Symbol sym, int attrLen) {
 }
 },
 new AttributeReader(names.RuntimeVisibleParameterAnnotations, V49, CLASS_OR_MEMBER_ATTRIBUTE) {
 protected void read(Symbol sym, int attrLen) {
-attachParameterAnnotations(sym);
+readParameterAnnotations(sym);
 }
 },
 // additional "legacy" v49 attributes, superceded by flags
 if (saveParameterNames) {
 sawMethodParameters = true;
 int numEntries = nextByte();
 parameterNameIndices = new int[numEntries];
 haveParameterNameIndices = true;
+int index = 0;
 for (int i = 0; i < numEntries; i++) {
 int nameIndex = nextChar();
 int flags = nextChar();
-parameterNameIndices[i] = nameIndex;
+if ((flags & (Flags.MANDATED | Flags.SYNTHETIC)) != 0) {
+continue;
+}
+parameterNameIndices[index++] = nameIndex;
 }
 }
 bp = newbp;
 }
 },
 /************************************************************************
 * Reading Java-language annotations
 ***********************************************************************/
+/**
+* Save annotations.
+*/
+List<CompoundAnnotationProxy> readAnnotations() {
+int numAttributes = nextChar();
+ListBuffer<CompoundAnnotationProxy> annotations = new ListBuffer<>();
+for (int i = 0; i < numAttributes; i++) {
+annotations.append(readCompoundAnnotation());
+}
+return annotations.toList();
+}
 /** Attach annotations.
 */
 void attachAnnotations(final Symbol sym) {
-int numAttributes = nextChar();
+attachAnnotations(sym, readAnnotations());
-if (numAttributes != 0) {
+}
-ListBuffer<CompoundAnnotationProxy> proxies = new ListBuffer<>();
-for (int i = 0; i<numAttributes; i++) {
+/**
-CompoundAnnotationProxy proxy = readCompoundAnnotation();
+* Attach annotations.
-if (proxy.type.tsym == syms.proprietaryType.tsym)
+*/
-sym.flags_field |= PROPRIETARY;
+void attachAnnotations(final Symbol sym, List<CompoundAnnotationProxy> annotations) {
-else if (proxy.type.tsym == syms.profileType.tsym) {
+if (annotations.isEmpty()) {
-if (profile != Profile.DEFAULT) {
+return;
-for (Pair<Name,Attribute> v: proxy.values) {
+}
-if (v.fst == names.value && v.snd instanceof Attribute.Constant) {
+ListBuffer<CompoundAnnotationProxy> proxies = new ListBuffer<>();
-Attribute.Constant c = (Attribute.Constant) v.snd;
+for (CompoundAnnotationProxy proxy : annotations) {
-if (c.type == syms.intType && ((Integer) c.value) > profile.value) {
+if (proxy.type.tsym == syms.proprietaryType.tsym)
-sym.flags_field |= NOT_IN_PROFILE;
+sym.flags_field |= PROPRIETARY;
-}
+else if (proxy.type.tsym == syms.profileType.tsym) {
+if (profile != Profile.DEFAULT) {
+for (Pair<Name, Attribute> v : proxy.values) {
+if (v.fst == names.value && v.snd instanceof Attribute.Constant) {
+Attribute.Constant c = (Attribute.Constant)v.snd;
+if (c.type == syms.intType && ((Integer)c.value) > profile.value) {
+sym.flags_field |= NOT_IN_PROFILE;
 }
 }
 }
-} else {
+}
-if (proxy.type.tsym == syms.annotationTargetType.tsym) {
+} else {
-target = proxy;
+if (proxy.type.tsym == syms.annotationTargetType.tsym) {
-} else if (proxy.type.tsym == syms.repeatableType.tsym) {
+target = proxy;
-repeatable = proxy;
+} else if (proxy.type.tsym == syms.repeatableType.tsym) {
-} else if (proxy.type.tsym == syms.deprecatedType.tsym) {
+repeatable = proxy;
-sym.flags_field |= (DEPRECATED | DEPRECATED_ANNOTATION);
+} else if (proxy.type.tsym == syms.deprecatedType.tsym) {
-for (Pair<Name, Attribute> v : proxy.values) {
+sym.flags_field |= (DEPRECATED | DEPRECATED_ANNOTATION);
-if (v.fst == names.forRemoval && v.snd instanceof Attribute.Constant) {
+for (Pair<Name, Attribute> v : proxy.values) {
-Attribute.Constant c = (Attribute.Constant) v.snd;
+if (v.fst == names.forRemoval && v.snd instanceof Attribute.Constant) {
-if (c.type == syms.booleanType && ((Integer) c.value) != 0) {
+Attribute.Constant c = (Attribute.Constant)v.snd;
-sym.flags_field |= DEPRECATED_REMOVAL;
+if (c.type == syms.booleanType && ((Integer)c.value) != 0) {
-}
+sym.flags_field |= DEPRECATED_REMOVAL;
 }
 }
 }
+}
 proxies.append(proxy);
 }
 }
 annotate.normal(new AnnotationCompleter(sym, proxies.toList()));
 }
-}
+/** Read parameter annotations.
-/** Attach parameter annotations.
+*/
-*/
+void readParameterAnnotations(Symbol meth) {
-void attachParameterAnnotations(final Symbol method) {
-final MethodSymbol meth = (MethodSymbol)method;
 int numParameters = buf[bp++] & 0xFF;
-List<VarSymbol> parameters = meth.params();
+if (parameterAnnotations == null) {
-int pnum = 0;
+parameterAnnotations = new ParameterAnnotations[numParameters];
-while (parameters.tail != null) {
+} else if (parameterAnnotations.length != numParameters) {
-attachAnnotations(parameters.head);
-parameters = parameters.tail;
-pnum++;
-}
-if (pnum != numParameters) {
 throw badClassFile("bad.runtime.invisible.param.annotations", meth);
+}
+for (int pnum = 0; pnum < numParameters; pnum++) {
+if (parameterAnnotations[pnum] == null) {
+parameterAnnotations[pnum] = new ParameterAnnotations();
+}
+parameterAnnotations[pnum].add(readAnnotations());
 }
 }
 void attachTypeAnnotations(final Symbol sym) {
 int numAttributes = nextChar();
 try {
 readMemberAttrs(m);
 } finally {
 currentOwner = prevOwner;
 }
-if (saveParameterNames)
+setParameters(m, type);
-setParameterNames(m, type);
 if ((flags & VARARGS) != 0) {
 final Type last = type.getParameterTypes().last();
 if (last == null || !last.hasTag(ARRAY)) {
 m.flags_field &= ~VARARGS;
 haveParameterNameIndices = false;
 sawMethodParameters = false;
 }
 /**
-* Set the parameter names for a symbol from the name index in the
+* Set the parameters for a method symbol, including any names and
-* parameterNameIndicies array. The type of the symbol may have changed
+* annotations that were read.
-* while reading the method attributes (see the Signature attribute).
+*
-* This may be because of generic information or because anonymous
+* <p>The type of the symbol may have changed while reading the
-* synthetic parameters were added.   The original type (as read from
+* method attributes (see the Signature attribute). This may be
-* the method descriptor) is used to help guess the existence of
+* because of generic information or because anonymous synthetic
+* parameters were added.   The original type (as read from the
+* method descriptor) is used to help guess the existence of
 * anonymous synthetic parameters.
-* On completion, sym.savedParameter names will either be null (if
+*/
-* no parameter names were found in the class file) or will be set to a
+void setParameters(MethodSymbol sym, Type jvmType) {
-* list of names, one per entry in sym.type.getParameterTypes, with
-* any missing names represented by the empty name.
-*/
-void setParameterNames(MethodSymbol sym, Type jvmType) {
-// if no names were found in the class file, there's nothing more to do
-if (!haveParameterNameIndices)
-return;
 // If we get parameter names from MethodParameters, then we
 // don't need to skip.
 int firstParam = 0;
 if (!sawMethodParameters) {
 firstParam = ((sym.flags() & STATIC) == 0) ? 1 : 0;
 // the code in readMethod may have skipped the first
 // parameter when setting up the MethodType. If so, we
 // make a corresponding allowance here for the position of
 // the first parameter.  Note that this assumes the
 // skipped parameter has a width of 1 -- i.e. it is not
 // a double width type (long or double.)
 if (sym.name == names.init && currentOwner.hasOuterInstance()) {
 // Sometimes anonymous classes don't have an outer
 // instance, however, there is no reliable way to tell so
 // we never strip this$n
 if (!currentOwner.name.isEmpty())
 firstParam += 1;
 }
 if (sym.type != jvmType) {
 // reading the method attributes has caused the
 // symbol's type to be changed. (i.e. the Signature
 // attribute.)  This may happen if there are hidden
 // (synthetic) parameters in the descriptor, but not
 // in the Signature.  The position of these hidden
 // parameters is unspecified; for now, assume they are
 // at the beginning, and so skip over them. The
 // primary case for this is two hidden parameters
 // passed into Enum constructors.
 int skip = Code.width(jvmType.getParameterTypes())
 - Code.width(sym.type.getParameterTypes());
 firstParam += skip;
 }
 }
 List<Name> paramNames = List.nil();
-int index = firstParam;
+ListBuffer<VarSymbol> params = new ListBuffer<>();
+int nameIndex = firstParam;
+int annotationIndex = 0;
 for (Type t: sym.type.getParameterTypes()) {
-int nameIdx = (index < parameterNameIndices.length
+Name name = parameterName(nameIndex, paramNames);
-? parameterNameIndices[index] : 0);
-Name name = nameIdx == 0 ? names.empty : readName(nameIdx);
 paramNames = paramNames.prepend(name);
-index += sawMethodParameters ? 1 : Code.width(t);
+VarSymbol param = new VarSymbol(PARAMETER, name, t, sym);
-}
+params.append(param);
-sym.savedParameterNames = paramNames.reverse();
+if (parameterAnnotations != null) {
+ParameterAnnotations annotations = parameterAnnotations[annotationIndex];
+if (annotations != null && annotations.proxies != null
+&& !annotations.proxies.isEmpty()) {
+annotate.normal(new AnnotationCompleter(param, annotations.proxies));
+}
+}
+nameIndex += sawMethodParameters ? 1 : Code.width(t);
+annotationIndex++;
+}
+if (parameterAnnotations != null && parameterAnnotations.length != annotationIndex) {
+throw badClassFile("bad.runtime.invisible.param.annotations", sym);
+}
+Assert.checkNull(sym.params);
+sym.params = params.toList();
+parameterAnnotations = null;
+parameterNameIndices = null;
+}
+// Returns the name for the parameter at position 'index', either using
+// names read from the MethodParameters, or by synthesizing a name that
+// is not on the 'exclude' list.
+private Name parameterName(int index, List<Name> exclude) {
+if (parameterNameIndices != null && index < parameterNameIndices.length
+&& parameterNameIndices[index] != 0) {
+return readName(parameterNameIndices[index]);
+}
+String prefix = "arg";
+while (true) {
+Name argName = names.fromString(prefix + exclude.size());
+if (!exclude.contains(argName))
+return argName;
+prefix += "$";
+}
 }
 /**
 * skip n bytes
 */

changeset 48430	68c6f57c40d4
parent 48427	b08405cc467a
parent 48344	89f6aa26fd6c
child 48826	c4d9d1b08e2e