684 lines
27 KiB
Java
684 lines
27 KiB
Java
/*
|
|
* Copyright (c) 2003, 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
|
|
* particular file as subject to the "Classpath" exception as provided
|
|
* by Oracle in the LICENSE file that accompanied this code.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
package com.sun.tools.javac.comp;
|
|
|
|
import java.util.Map;
|
|
|
|
import com.sun.tools.javac.util.*;
|
|
import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
|
|
import com.sun.tools.javac.code.*;
|
|
import com.sun.tools.javac.code.Symbol.*;
|
|
import com.sun.tools.javac.tree.*;
|
|
import com.sun.tools.javac.tree.JCTree.*;
|
|
|
|
import static com.sun.tools.javac.code.TypeTag.ARRAY;
|
|
import static com.sun.tools.javac.code.TypeTag.CLASS;
|
|
import static com.sun.tools.javac.tree.JCTree.Tag.*;
|
|
import javax.lang.model.type.ErrorType;
|
|
|
|
/** Enter annotations on symbols. Annotations accumulate in a queue,
|
|
* which is processed at the top level of any set of recursive calls
|
|
* requesting it be processed.
|
|
*
|
|
* <p><b>This is NOT part of any supported API.
|
|
* If you write code that depends on this, you do so at your own risk.
|
|
* This code and its internal interfaces are subject to change or
|
|
* deletion without notice.</b>
|
|
*/
|
|
public class Annotate {
|
|
protected static final Context.Key<Annotate> annotateKey =
|
|
new Context.Key<Annotate>();
|
|
|
|
public static Annotate instance(Context context) {
|
|
Annotate instance = context.get(annotateKey);
|
|
if (instance == null)
|
|
instance = new Annotate(context);
|
|
return instance;
|
|
}
|
|
|
|
final Attr attr;
|
|
final TreeMaker make;
|
|
final Log log;
|
|
final Symtab syms;
|
|
final Names names;
|
|
final Resolve rs;
|
|
final Types types;
|
|
final ConstFold cfolder;
|
|
final Check chk;
|
|
|
|
protected Annotate(Context context) {
|
|
context.put(annotateKey, this);
|
|
attr = Attr.instance(context);
|
|
make = TreeMaker.instance(context);
|
|
log = Log.instance(context);
|
|
syms = Symtab.instance(context);
|
|
names = Names.instance(context);
|
|
rs = Resolve.instance(context);
|
|
types = Types.instance(context);
|
|
cfolder = ConstFold.instance(context);
|
|
chk = Check.instance(context);
|
|
}
|
|
|
|
/* ********************************************************************
|
|
* Queue maintenance
|
|
*********************************************************************/
|
|
|
|
private int enterCount = 0;
|
|
|
|
ListBuffer<Worker> q = new ListBuffer<Worker>();
|
|
ListBuffer<Worker> typesQ = new ListBuffer<Worker>();
|
|
ListBuffer<Worker> repeatedQ = new ListBuffer<Worker>();
|
|
ListBuffer<Worker> afterRepeatedQ = new ListBuffer<Worker>();
|
|
ListBuffer<Worker> validateQ = new ListBuffer<Worker>();
|
|
|
|
public void earlier(Worker a) {
|
|
q.prepend(a);
|
|
}
|
|
|
|
public void normal(Worker a) {
|
|
q.append(a);
|
|
}
|
|
|
|
public void typeAnnotation(Worker a) {
|
|
typesQ.append(a);
|
|
}
|
|
|
|
public void repeated(Worker a) {
|
|
repeatedQ.append(a);
|
|
}
|
|
|
|
public void afterRepeated(Worker a) {
|
|
afterRepeatedQ.append(a);
|
|
}
|
|
|
|
public void validate(Worker a) {
|
|
validateQ.append(a);
|
|
}
|
|
|
|
/** Called when the Enter phase starts. */
|
|
public void enterStart() {
|
|
enterCount++;
|
|
}
|
|
|
|
/** Called after the Enter phase completes. */
|
|
public void enterDone() {
|
|
enterCount--;
|
|
flush();
|
|
}
|
|
|
|
/** Variant which allows for a delayed flush of annotations.
|
|
* Needed by ClassReader */
|
|
public void enterDoneWithoutFlush() {
|
|
enterCount--;
|
|
}
|
|
|
|
public void flush() {
|
|
if (enterCount != 0) return;
|
|
enterCount++;
|
|
try {
|
|
while (q.nonEmpty()) {
|
|
q.next().run();
|
|
}
|
|
while (typesQ.nonEmpty()) {
|
|
typesQ.next().run();
|
|
}
|
|
while (repeatedQ.nonEmpty()) {
|
|
repeatedQ.next().run();
|
|
}
|
|
while (afterRepeatedQ.nonEmpty()) {
|
|
afterRepeatedQ.next().run();
|
|
}
|
|
while (validateQ.nonEmpty()) {
|
|
validateQ.next().run();
|
|
}
|
|
} finally {
|
|
enterCount--;
|
|
}
|
|
}
|
|
|
|
/** A client that needs to run during {@link #flush()} registers an worker
|
|
* into one of the queues defined in this class. The queues are: {@link #earlier(Worker)},
|
|
* {@link #normal(Worker)}, {@link #typeAnnotation(Worker)}, {@link #repeated(Worker)},
|
|
* {@link #afterRepeated(Worker)}, {@link #validate(Worker)}.
|
|
* The {@link Worker#run()} method will called inside the {@link #flush()}
|
|
* call. Queues are empties in the abovementioned order.
|
|
*/
|
|
public interface Worker {
|
|
void run();
|
|
String toString();
|
|
}
|
|
|
|
/**
|
|
* This context contains all the information needed to synthesize new
|
|
* annotations trees by the completer for repeating annotations.
|
|
*/
|
|
public class AnnotateRepeatedContext<T extends Attribute.Compound> {
|
|
public final Env<AttrContext> env;
|
|
public final Map<Symbol.TypeSymbol, ListBuffer<T>> annotated;
|
|
public final Map<T, JCDiagnostic.DiagnosticPosition> pos;
|
|
public final Log log;
|
|
public final boolean isTypeCompound;
|
|
|
|
public AnnotateRepeatedContext(Env<AttrContext> env,
|
|
Map<Symbol.TypeSymbol, ListBuffer<T>> annotated,
|
|
Map<T, JCDiagnostic.DiagnosticPosition> pos,
|
|
Log log,
|
|
boolean isTypeCompound) {
|
|
Assert.checkNonNull(env);
|
|
Assert.checkNonNull(annotated);
|
|
Assert.checkNonNull(pos);
|
|
Assert.checkNonNull(log);
|
|
|
|
this.env = env;
|
|
this.annotated = annotated;
|
|
this.pos = pos;
|
|
this.log = log;
|
|
this.isTypeCompound = isTypeCompound;
|
|
}
|
|
|
|
/**
|
|
* Process a list of repeating annotations returning a new
|
|
* Attribute.Compound that is the attribute for the synthesized tree
|
|
* for the container.
|
|
*
|
|
* @param repeatingAnnotations a List of repeating annotations
|
|
* @return a new Attribute.Compound that is the container for the repeatingAnnotations
|
|
*/
|
|
public T processRepeatedAnnotations(List<T> repeatingAnnotations, Symbol sym) {
|
|
return Annotate.this.processRepeatedAnnotations(repeatingAnnotations, this, sym);
|
|
}
|
|
|
|
/**
|
|
* Queue the Worker a on the repeating annotations queue of the
|
|
* Annotate instance this context belongs to.
|
|
*
|
|
* @param a the Worker to enqueue for repeating annotation annotating
|
|
*/
|
|
public void annotateRepeated(Worker a) {
|
|
Annotate.this.repeated(a);
|
|
}
|
|
}
|
|
|
|
/* ********************************************************************
|
|
* Compute an attribute from its annotation.
|
|
*********************************************************************/
|
|
|
|
/** Process a single compound annotation, returning its
|
|
* Attribute. Used from MemberEnter for attaching the attributes
|
|
* to the annotated symbol.
|
|
*/
|
|
Attribute.Compound enterAnnotation(JCAnnotation a,
|
|
Type expected,
|
|
Env<AttrContext> env) {
|
|
return enterAnnotation(a, expected, env, false);
|
|
}
|
|
|
|
Attribute.TypeCompound enterTypeAnnotation(JCAnnotation a,
|
|
Type expected,
|
|
Env<AttrContext> env) {
|
|
return (Attribute.TypeCompound) enterAnnotation(a, expected, env, true);
|
|
}
|
|
|
|
// boolean typeAnnotation determines whether the method returns
|
|
// a Compound (false) or TypeCompound (true).
|
|
Attribute.Compound enterAnnotation(JCAnnotation a,
|
|
Type expected,
|
|
Env<AttrContext> env,
|
|
boolean typeAnnotation) {
|
|
// The annotation might have had its type attributed (but not checked)
|
|
// by attr.attribAnnotationTypes during MemberEnter, in which case we do not
|
|
// need to do it again.
|
|
Type at = (a.annotationType.type != null ? a.annotationType.type
|
|
: attr.attribType(a.annotationType, env));
|
|
a.type = chk.checkType(a.annotationType.pos(), at, expected);
|
|
if (a.type.isErroneous()) {
|
|
// Need to make sure nested (anno)trees does not have null as .type
|
|
attr.postAttr(a);
|
|
|
|
if (typeAnnotation) {
|
|
return new Attribute.TypeCompound(a.type, List.<Pair<MethodSymbol,Attribute>>nil(),
|
|
new TypeAnnotationPosition());
|
|
} else {
|
|
return new Attribute.Compound(a.type, List.<Pair<MethodSymbol,Attribute>>nil());
|
|
}
|
|
}
|
|
if ((a.type.tsym.flags() & Flags.ANNOTATION) == 0) {
|
|
log.error(a.annotationType.pos(),
|
|
"not.annotation.type", a.type.toString());
|
|
|
|
// Need to make sure nested (anno)trees does not have null as .type
|
|
attr.postAttr(a);
|
|
|
|
if (typeAnnotation) {
|
|
return new Attribute.TypeCompound(a.type, List.<Pair<MethodSymbol,Attribute>>nil(), null);
|
|
} else {
|
|
return new Attribute.Compound(a.type, List.<Pair<MethodSymbol,Attribute>>nil());
|
|
}
|
|
}
|
|
List<JCExpression> args = a.args;
|
|
if (args.length() == 1 && !args.head.hasTag(ASSIGN)) {
|
|
// special case: elided "value=" assumed
|
|
args.head = make.at(args.head.pos).
|
|
Assign(make.Ident(names.value), args.head);
|
|
}
|
|
ListBuffer<Pair<MethodSymbol,Attribute>> buf =
|
|
new ListBuffer<>();
|
|
for (List<JCExpression> tl = args; tl.nonEmpty(); tl = tl.tail) {
|
|
JCExpression t = tl.head;
|
|
if (!t.hasTag(ASSIGN)) {
|
|
log.error(t.pos(), "annotation.value.must.be.name.value");
|
|
continue;
|
|
}
|
|
JCAssign assign = (JCAssign)t;
|
|
if (!assign.lhs.hasTag(IDENT)) {
|
|
log.error(t.pos(), "annotation.value.must.be.name.value");
|
|
continue;
|
|
}
|
|
JCIdent left = (JCIdent)assign.lhs;
|
|
Symbol method = rs.resolveQualifiedMethod(assign.rhs.pos(),
|
|
env,
|
|
a.type,
|
|
left.name,
|
|
List.<Type>nil(),
|
|
null);
|
|
left.sym = method;
|
|
left.type = method.type;
|
|
if (method.owner != a.type.tsym)
|
|
log.error(left.pos(), "no.annotation.member", left.name, a.type);
|
|
Type result = method.type.getReturnType();
|
|
Attribute value = enterAttributeValue(result, assign.rhs, env);
|
|
if (!method.type.isErroneous())
|
|
buf.append(new Pair<>((MethodSymbol)method, value));
|
|
t.type = result;
|
|
}
|
|
if (typeAnnotation) {
|
|
if (a.attribute == null || !(a.attribute instanceof Attribute.TypeCompound)) {
|
|
// Create a new TypeCompound
|
|
Attribute.TypeCompound tc = new Attribute.TypeCompound(a.type, buf.toList(), new TypeAnnotationPosition());
|
|
a.attribute = tc;
|
|
return tc;
|
|
} else {
|
|
// Use an existing TypeCompound
|
|
return a.attribute;
|
|
}
|
|
} else {
|
|
Attribute.Compound ac = new Attribute.Compound(a.type, buf.toList());
|
|
a.attribute = ac;
|
|
return ac;
|
|
}
|
|
}
|
|
|
|
Attribute enterAttributeValue(Type expected,
|
|
JCExpression tree,
|
|
Env<AttrContext> env) {
|
|
//first, try completing the attribution value sym - if a completion
|
|
//error is thrown, we should recover gracefully, and display an
|
|
//ordinary resolution diagnostic.
|
|
try {
|
|
expected.tsym.complete();
|
|
} catch(CompletionFailure e) {
|
|
log.error(tree.pos(), "cant.resolve", Kinds.kindName(e.sym), e.sym);
|
|
expected = syms.errType;
|
|
}
|
|
if (expected.hasTag(ARRAY)) {
|
|
if (!tree.hasTag(NEWARRAY)) {
|
|
tree = make.at(tree.pos).
|
|
NewArray(null, List.<JCExpression>nil(), List.of(tree));
|
|
}
|
|
JCNewArray na = (JCNewArray)tree;
|
|
if (na.elemtype != null) {
|
|
log.error(na.elemtype.pos(), "new.not.allowed.in.annotation");
|
|
}
|
|
ListBuffer<Attribute> buf = new ListBuffer<Attribute>();
|
|
for (List<JCExpression> l = na.elems; l.nonEmpty(); l=l.tail) {
|
|
buf.append(enterAttributeValue(types.elemtype(expected),
|
|
l.head,
|
|
env));
|
|
}
|
|
na.type = expected;
|
|
return new Attribute.
|
|
Array(expected, buf.toArray(new Attribute[buf.length()]));
|
|
}
|
|
if (tree.hasTag(NEWARRAY)) { //error recovery
|
|
if (!expected.isErroneous())
|
|
log.error(tree.pos(), "annotation.value.not.allowable.type");
|
|
JCNewArray na = (JCNewArray)tree;
|
|
if (na.elemtype != null) {
|
|
log.error(na.elemtype.pos(), "new.not.allowed.in.annotation");
|
|
}
|
|
for (List<JCExpression> l = na.elems; l.nonEmpty(); l=l.tail) {
|
|
enterAttributeValue(syms.errType,
|
|
l.head,
|
|
env);
|
|
}
|
|
return new Attribute.Error(syms.errType);
|
|
}
|
|
if ((expected.tsym.flags() & Flags.ANNOTATION) != 0) {
|
|
if (tree.hasTag(ANNOTATION)) {
|
|
return enterAnnotation((JCAnnotation)tree, expected, env);
|
|
} else {
|
|
log.error(tree.pos(), "annotation.value.must.be.annotation");
|
|
expected = syms.errType;
|
|
}
|
|
}
|
|
if (tree.hasTag(ANNOTATION)) { //error recovery
|
|
if (!expected.isErroneous())
|
|
log.error(tree.pos(), "annotation.not.valid.for.type", expected);
|
|
enterAnnotation((JCAnnotation)tree, syms.errType, env);
|
|
return new Attribute.Error(((JCAnnotation)tree).annotationType.type);
|
|
}
|
|
if (expected.isPrimitive() || types.isSameType(expected, syms.stringType)) {
|
|
Type result = attr.attribExpr(tree, env, expected);
|
|
if (result.isErroneous())
|
|
return new Attribute.Error(result.getOriginalType());
|
|
if (result.constValue() == null) {
|
|
log.error(tree.pos(), "attribute.value.must.be.constant");
|
|
return new Attribute.Error(expected);
|
|
}
|
|
result = cfolder.coerce(result, expected);
|
|
return new Attribute.Constant(expected, result.constValue());
|
|
}
|
|
if (expected.tsym == syms.classType.tsym) {
|
|
Type result = attr.attribExpr(tree, env, expected);
|
|
if (result.isErroneous()) {
|
|
// Does it look like an unresolved class literal?
|
|
if (TreeInfo.name(tree) == names._class &&
|
|
((JCFieldAccess) tree).selected.type.isErroneous()) {
|
|
Name n = (((JCFieldAccess) tree).selected).type.tsym.flatName();
|
|
return new Attribute.UnresolvedClass(expected,
|
|
types.createErrorType(n,
|
|
syms.unknownSymbol, syms.classType));
|
|
} else {
|
|
return new Attribute.Error(result.getOriginalType());
|
|
}
|
|
}
|
|
|
|
// Class literals look like field accesses of a field named class
|
|
// at the tree level
|
|
if (TreeInfo.name(tree) != names._class) {
|
|
log.error(tree.pos(), "annotation.value.must.be.class.literal");
|
|
return new Attribute.Error(syms.errType);
|
|
}
|
|
return new Attribute.Class(types,
|
|
(((JCFieldAccess) tree).selected).type);
|
|
}
|
|
if (expected.hasTag(CLASS) &&
|
|
(expected.tsym.flags() & Flags.ENUM) != 0) {
|
|
Type result = attr.attribExpr(tree, env, expected);
|
|
Symbol sym = TreeInfo.symbol(tree);
|
|
if (sym == null ||
|
|
TreeInfo.nonstaticSelect(tree) ||
|
|
sym.kind != Kinds.VAR ||
|
|
(sym.flags() & Flags.ENUM) == 0) {
|
|
log.error(tree.pos(), "enum.annotation.must.be.enum.constant");
|
|
return new Attribute.Error(result.getOriginalType());
|
|
}
|
|
VarSymbol enumerator = (VarSymbol) sym;
|
|
return new Attribute.Enum(expected, enumerator);
|
|
}
|
|
//error recovery:
|
|
if (!expected.isErroneous())
|
|
log.error(tree.pos(), "annotation.value.not.allowable.type");
|
|
return new Attribute.Error(attr.attribExpr(tree, env, expected));
|
|
}
|
|
|
|
/* *********************************
|
|
* Support for repeating annotations
|
|
***********************************/
|
|
|
|
/* Process repeated annotations. This method returns the
|
|
* synthesized container annotation or null IFF all repeating
|
|
* annotation are invalid. This method reports errors/warnings.
|
|
*/
|
|
private <T extends Attribute.Compound> T processRepeatedAnnotations(List<T> annotations,
|
|
AnnotateRepeatedContext<T> ctx,
|
|
Symbol on) {
|
|
T firstOccurrence = annotations.head;
|
|
List<Attribute> repeated = List.nil();
|
|
Type origAnnoType = null;
|
|
Type arrayOfOrigAnnoType = null;
|
|
Type targetContainerType = null;
|
|
MethodSymbol containerValueSymbol = null;
|
|
|
|
Assert.check(!annotations.isEmpty() &&
|
|
!annotations.tail.isEmpty()); // i.e. size() > 1
|
|
|
|
int count = 0;
|
|
for (List<T> al = annotations;
|
|
!al.isEmpty();
|
|
al = al.tail)
|
|
{
|
|
count++;
|
|
|
|
// There must be more than a single anno in the annotation list
|
|
Assert.check(count > 1 || !al.tail.isEmpty());
|
|
|
|
T currentAnno = al.head;
|
|
|
|
origAnnoType = currentAnno.type;
|
|
if (arrayOfOrigAnnoType == null) {
|
|
arrayOfOrigAnnoType = types.makeArrayType(origAnnoType);
|
|
}
|
|
|
|
// Only report errors if this isn't the first occurrence I.E. count > 1
|
|
boolean reportError = count > 1;
|
|
Type currentContainerType = getContainingType(currentAnno, ctx.pos.get(currentAnno), reportError);
|
|
if (currentContainerType == null) {
|
|
continue;
|
|
}
|
|
// Assert that the target Container is == for all repeated
|
|
// annos of the same annotation type, the types should
|
|
// come from the same Symbol, i.e. be '=='
|
|
Assert.check(targetContainerType == null || currentContainerType == targetContainerType);
|
|
targetContainerType = currentContainerType;
|
|
|
|
containerValueSymbol = validateContainer(targetContainerType, origAnnoType, ctx.pos.get(currentAnno));
|
|
|
|
if (containerValueSymbol == null) { // Check of CA type failed
|
|
// errors are already reported
|
|
continue;
|
|
}
|
|
|
|
repeated = repeated.prepend(currentAnno);
|
|
}
|
|
|
|
if (!repeated.isEmpty()) {
|
|
repeated = repeated.reverse();
|
|
TreeMaker m = make.at(ctx.pos.get(firstOccurrence));
|
|
Pair<MethodSymbol, Attribute> p =
|
|
new Pair<MethodSymbol, Attribute>(containerValueSymbol,
|
|
new Attribute.Array(arrayOfOrigAnnoType, repeated));
|
|
if (ctx.isTypeCompound) {
|
|
/* TODO: the following code would be cleaner:
|
|
Attribute.TypeCompound at = new Attribute.TypeCompound(targetContainerType, List.of(p),
|
|
((Attribute.TypeCompound)annotations.head).position);
|
|
JCTypeAnnotation annoTree = m.TypeAnnotation(at);
|
|
at = enterTypeAnnotation(annoTree, targetContainerType, ctx.env);
|
|
*/
|
|
// However, we directly construct the TypeCompound to keep the
|
|
// direct relation to the contained TypeCompounds.
|
|
Attribute.TypeCompound at = new Attribute.TypeCompound(targetContainerType, List.of(p),
|
|
((Attribute.TypeCompound)annotations.head).position);
|
|
|
|
// TODO: annotation applicability checks from below?
|
|
|
|
at.setSynthesized(true);
|
|
|
|
@SuppressWarnings("unchecked")
|
|
T x = (T) at;
|
|
return x;
|
|
} else {
|
|
Attribute.Compound c = new Attribute.Compound(targetContainerType, List.of(p));
|
|
JCAnnotation annoTree = m.Annotation(c);
|
|
|
|
if (!chk.annotationApplicable(annoTree, on))
|
|
log.error(annoTree.pos(), "invalid.repeatable.annotation.incompatible.target", targetContainerType, origAnnoType);
|
|
|
|
if (!chk.validateAnnotationDeferErrors(annoTree))
|
|
log.error(annoTree.pos(), "duplicate.annotation.invalid.repeated", origAnnoType);
|
|
|
|
c = enterAnnotation(annoTree, targetContainerType, ctx.env);
|
|
c.setSynthesized(true);
|
|
|
|
@SuppressWarnings("unchecked")
|
|
T x = (T) c;
|
|
return x;
|
|
}
|
|
} else {
|
|
return null; // errors should have been reported elsewhere
|
|
}
|
|
}
|
|
|
|
/** Fetches the actual Type that should be the containing annotation. */
|
|
private Type getContainingType(Attribute.Compound currentAnno,
|
|
DiagnosticPosition pos,
|
|
boolean reportError)
|
|
{
|
|
Type origAnnoType = currentAnno.type;
|
|
TypeSymbol origAnnoDecl = origAnnoType.tsym;
|
|
|
|
// Fetch the Repeatable annotation from the current
|
|
// annotation's declaration, or null if it has none
|
|
Attribute.Compound ca = origAnnoDecl.attribute(syms.repeatableType.tsym);
|
|
if (ca == null) { // has no Repeatable annotation
|
|
if (reportError)
|
|
log.error(pos, "duplicate.annotation.missing.container", origAnnoType, syms.repeatableType);
|
|
return null;
|
|
}
|
|
|
|
return filterSame(extractContainingType(ca, pos, origAnnoDecl),
|
|
origAnnoType);
|
|
}
|
|
|
|
// returns null if t is same as 's', returns 't' otherwise
|
|
private Type filterSame(Type t, Type s) {
|
|
if (t == null || s == null) {
|
|
return t;
|
|
}
|
|
|
|
return types.isSameType(t, s) ? null : t;
|
|
}
|
|
|
|
/** Extract the actual Type to be used for a containing annotation. */
|
|
private Type extractContainingType(Attribute.Compound ca,
|
|
DiagnosticPosition pos,
|
|
TypeSymbol annoDecl)
|
|
{
|
|
// The next three checks check that the Repeatable annotation
|
|
// on the declaration of the annotation type that is repeating is
|
|
// valid.
|
|
|
|
// Repeatable must have at least one element
|
|
if (ca.values.isEmpty()) {
|
|
log.error(pos, "invalid.repeatable.annotation", annoDecl);
|
|
return null;
|
|
}
|
|
Pair<MethodSymbol,Attribute> p = ca.values.head;
|
|
Name name = p.fst.name;
|
|
if (name != names.value) { // should contain only one element, named "value"
|
|
log.error(pos, "invalid.repeatable.annotation", annoDecl);
|
|
return null;
|
|
}
|
|
if (!(p.snd instanceof Attribute.Class)) { // check that the value of "value" is an Attribute.Class
|
|
log.error(pos, "invalid.repeatable.annotation", annoDecl);
|
|
return null;
|
|
}
|
|
|
|
return ((Attribute.Class)p.snd).getValue();
|
|
}
|
|
|
|
/* Validate that the suggested targetContainerType Type is a valid
|
|
* container type for repeated instances of originalAnnoType
|
|
* annotations. Return null and report errors if this is not the
|
|
* case, return the MethodSymbol of the value element in
|
|
* targetContainerType if it is suitable (this is needed to
|
|
* synthesize the container). */
|
|
private MethodSymbol validateContainer(Type targetContainerType,
|
|
Type originalAnnoType,
|
|
DiagnosticPosition pos) {
|
|
MethodSymbol containerValueSymbol = null;
|
|
boolean fatalError = false;
|
|
|
|
// Validate that there is a (and only 1) value method
|
|
Scope scope = targetContainerType.tsym.members();
|
|
int nr_value_elems = 0;
|
|
boolean error = false;
|
|
for(Symbol elm : scope.getElementsByName(names.value)) {
|
|
nr_value_elems++;
|
|
|
|
if (nr_value_elems == 1 &&
|
|
elm.kind == Kinds.MTH) {
|
|
containerValueSymbol = (MethodSymbol)elm;
|
|
} else {
|
|
error = true;
|
|
}
|
|
}
|
|
if (error) {
|
|
log.error(pos,
|
|
"invalid.repeatable.annotation.multiple.values",
|
|
targetContainerType,
|
|
nr_value_elems);
|
|
return null;
|
|
} else if (nr_value_elems == 0) {
|
|
log.error(pos,
|
|
"invalid.repeatable.annotation.no.value",
|
|
targetContainerType);
|
|
return null;
|
|
}
|
|
|
|
// validate that the 'value' element is a method
|
|
// probably "impossible" to fail this
|
|
if (containerValueSymbol.kind != Kinds.MTH) {
|
|
log.error(pos,
|
|
"invalid.repeatable.annotation.invalid.value",
|
|
targetContainerType);
|
|
fatalError = true;
|
|
}
|
|
|
|
// validate that the 'value' element has the correct return type
|
|
// i.e. array of original anno
|
|
Type valueRetType = containerValueSymbol.type.getReturnType();
|
|
Type expectedType = types.makeArrayType(originalAnnoType);
|
|
if (!(types.isArray(valueRetType) &&
|
|
types.isSameType(expectedType, valueRetType))) {
|
|
log.error(pos,
|
|
"invalid.repeatable.annotation.value.return",
|
|
targetContainerType,
|
|
valueRetType,
|
|
expectedType);
|
|
fatalError = true;
|
|
}
|
|
if (error) {
|
|
fatalError = true;
|
|
}
|
|
|
|
// The conditions for a valid containing annotation are made
|
|
// in Check.validateRepeatedAnnotaton();
|
|
|
|
return fatalError ? null : containerValueSymbol;
|
|
}
|
|
}
|