/* * Copyright (c) 2012, 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.code; import java.util.Map; import javax.tools.JavaFileObject; import com.sun.tools.javac.comp.Annotate; import com.sun.tools.javac.comp.AttrContext; import com.sun.tools.javac.comp.Env; import com.sun.tools.javac.util.*; import com.sun.tools.javac.util.Assert; import com.sun.tools.javac.util.List; import com.sun.tools.javac.util.Log; import com.sun.tools.javac.util.Pair; import static com.sun.tools.javac.code.Kinds.PCK; /** * Container for all annotations (attributes in javac) on a Symbol. * * This class is explicitly mutable. Its contents will change when attributes * are annotated onto the Symbol. However this class depends on the facts that * List (in javac) is immutable. * * An instance of this class can be in one of three states: * * NOT_STARTED indicates that the Symbol this instance belongs to has not been * annotated (yet). Specifically if the declaration is not annotated this * instance will never move past NOT_STARTED. You can never go back to * NOT_STARTED. * * IN_PROGRESS annotations have been found on the declaration. Will be processed * later. You can reset to IN_PROGRESS. While IN_PROGRESS you can set the list * of attributes (and this moves out of the IN_PROGRESS state). * * "unnamed" this SymbolMetadata contains some attributes, possibly the final set. * While in this state you can only prepend or append to the attributes not set * it directly. You can also move back to the IN_PROGRESS state using reset(). * *

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. */ public class SymbolMetadata { private static final List DECL_NOT_STARTED = List.of(null); private static final List DECL_IN_PROGRESS = List.of(null); /* * This field should never be null */ private List attributes = DECL_NOT_STARTED; /* * Type attributes for this symbol. * This field should never be null. */ private List type_attributes = List.nil(); /* * Type attributes of initializers in this class. * Unused if the current symbol is not a ClassSymbol. */ private List init_type_attributes = List.nil(); /* * Type attributes of class initializers in this class. * Unused if the current symbol is not a ClassSymbol. */ private List clinit_type_attributes = List.nil(); /* * The Symbol this SymbolMetadata instance belongs to */ private final Symbol sym; public SymbolMetadata(Symbol sym) { this.sym = sym; } public List getDeclarationAttributes() { return filterDeclSentinels(attributes); } public List getTypeAttributes() { return type_attributes; } public List getInitTypeAttributes() { return init_type_attributes; } public List getClassInitTypeAttributes() { return clinit_type_attributes; } public void setDeclarationAttributes(List a) { Assert.check(pendingCompletion() || !isStarted()); if (a == null) { throw new NullPointerException(); } attributes = a; } public void setTypeAttributes(List a) { if (a == null) { throw new NullPointerException(); } type_attributes = a; } public void setInitTypeAttributes(List a) { if (a == null) { throw new NullPointerException(); } init_type_attributes = a; } public void setClassInitTypeAttributes(List a) { if (a == null) { throw new NullPointerException(); } clinit_type_attributes = a; } public void setAttributes(SymbolMetadata other) { if (other == null) { throw new NullPointerException(); } setDeclarationAttributes(other.getDeclarationAttributes()); setTypeAttributes(other.getTypeAttributes()); setInitTypeAttributes(other.getInitTypeAttributes()); setClassInitTypeAttributes(other.getClassInitTypeAttributes()); } public void setDeclarationAttributesWithCompletion(final Annotate.AnnotateRepeatedContext ctx) { Assert.check(pendingCompletion() || (!isStarted() && sym.kind == PCK)); this.setDeclarationAttributes(getAttributesForCompletion(ctx)); } public void appendTypeAttributesWithCompletion(final Annotate.AnnotateRepeatedContext ctx) { this.appendUniqueTypes(getAttributesForCompletion(ctx)); } private List getAttributesForCompletion( final Annotate.AnnotateRepeatedContext ctx) { Map> annotated = ctx.annotated; boolean atLeastOneRepeated = false; List buf = List.nil(); for (ListBuffer lb : annotated.values()) { if (lb.size() == 1) { buf = buf.prepend(lb.first()); } else { // repeated // This will break when other subtypes of Attributs.Compound // are introduced, because PlaceHolder is a subtype of TypeCompound. T res; @SuppressWarnings("unchecked") T ph = (T) new Placeholder<>(ctx, lb.toList(), sym); res = ph; buf = buf.prepend(res); atLeastOneRepeated = true; } } if (atLeastOneRepeated) { // The Symbol s is now annotated with a combination of // finished non-repeating annotations and placeholders for // repeating annotations. // // We need to do this in two passes because when creating // a container for a repeating annotation we must // guarantee that the @Repeatable on the // contained annotation is fully annotated // // The way we force this order is to do all repeating // annotations in a pass after all non-repeating are // finished. This will work because @Repeatable // is non-repeating and therefore will be annotated in the // fist pass. // Queue a pass that will replace Attribute.Placeholders // with Attribute.Compound (made from synthesized containers). ctx.annotateRepeated(new Annotate.Worker() { @Override public String toString() { return "repeated annotation pass of: " + sym + " in: " + sym.owner; } @Override public void run() { complete(ctx); } }); } // Add non-repeating attributes return buf.reverse(); } public SymbolMetadata reset() { attributes = DECL_IN_PROGRESS; return this; } public boolean isEmpty() { return !isStarted() || pendingCompletion() || attributes.isEmpty(); } public boolean isTypesEmpty() { return type_attributes.isEmpty(); } public boolean pendingCompletion() { return attributes == DECL_IN_PROGRESS; } public SymbolMetadata append(List l) { attributes = filterDeclSentinels(attributes); if (l.isEmpty()) { // no-op } else if (attributes.isEmpty()) { attributes = l; } else { attributes = attributes.appendList(l); } return this; } public SymbolMetadata appendUniqueTypes(List l) { if (l.isEmpty()) { // no-op } else if (type_attributes.isEmpty()) { type_attributes = l; } else { // TODO: in case we expect a large number of annotations, this // might be inefficient. for (Attribute.TypeCompound tc : l) { if (!type_attributes.contains(tc)) type_attributes = type_attributes.append(tc); } } return this; } public SymbolMetadata appendInitTypeAttributes(List l) { if (l.isEmpty()) { // no-op } else if (init_type_attributes.isEmpty()) { init_type_attributes = l; } else { init_type_attributes = init_type_attributes.appendList(l); } return this; } public SymbolMetadata appendClassInitTypeAttributes(List l) { if (l.isEmpty()) { // no-op } else if (clinit_type_attributes.isEmpty()) { clinit_type_attributes = l; } else { clinit_type_attributes = clinit_type_attributes.appendList(l); } return this; } public SymbolMetadata prepend(List l) { attributes = filterDeclSentinels(attributes); if (l.isEmpty()) { // no-op } else if (attributes.isEmpty()) { attributes = l; } else { attributes = attributes.prependList(l); } return this; } private List filterDeclSentinels(List a) { return (a == DECL_IN_PROGRESS || a == DECL_NOT_STARTED) ? List.nil() : a; } private boolean isStarted() { return attributes != DECL_NOT_STARTED; } private List getPlaceholders() { List res = List.nil(); for (Attribute.Compound a : filterDeclSentinels(attributes)) { if (a instanceof Placeholder) { res = res.prepend(a); } } return res.reverse(); } private List getTypePlaceholders() { List res = List.nil(); for (Attribute.TypeCompound a : type_attributes) { if (a instanceof Placeholder) { res = res.prepend(a); } } return res.reverse(); } /* * Replace Placeholders for repeating annotations with their containers */ private void complete(Annotate.AnnotateRepeatedContext ctx) { Log log = ctx.log; Env env = ctx.env; JavaFileObject oldSource = log.useSource(env.toplevel.sourcefile); try { // TODO: can we reduce duplication in the following branches? if (ctx.isTypeCompound) { Assert.check(!isTypesEmpty()); if (isTypesEmpty()) { return; } List result = List.nil(); for (Attribute.TypeCompound a : getTypeAttributes()) { if (a instanceof Placeholder) { @SuppressWarnings("unchecked") Placeholder ph = (Placeholder) a; Attribute.TypeCompound replacement = replaceOne(ph, ph.getRepeatedContext()); if (null != replacement) { result = result.prepend(replacement); } } else { result = result.prepend(a); } } type_attributes = result.reverse(); Assert.check(SymbolMetadata.this.getTypePlaceholders().isEmpty()); } else { Assert.check(!pendingCompletion()); if (isEmpty()) { return; } List result = List.nil(); for (Attribute.Compound a : getDeclarationAttributes()) { if (a instanceof Placeholder) { @SuppressWarnings("unchecked") Attribute.Compound replacement = replaceOne((Placeholder) a, ctx); if (null != replacement) { result = result.prepend(replacement); } } else { result = result.prepend(a); } } attributes = result.reverse(); Assert.check(SymbolMetadata.this.getPlaceholders().isEmpty()); } } finally { log.useSource(oldSource); } } private T replaceOne(Placeholder placeholder, Annotate.AnnotateRepeatedContext ctx) { Log log = ctx.log; // Process repeated annotations T validRepeated = ctx.processRepeatedAnnotations(placeholder.getPlaceholderFor(), sym); if (validRepeated != null) { // Check that the container isn't manually // present along with repeated instances of // its contained annotation. ListBuffer manualContainer = ctx.annotated.get(validRepeated.type.tsym); if (manualContainer != null) { log.error(ctx.pos.get(manualContainer.first()), "invalid.repeatable.annotation.repeated.and.container.present", manualContainer.first().type.tsym); } } // A null return will delete the Placeholder return validRepeated; } private static class Placeholder extends Attribute.TypeCompound { private final Annotate.AnnotateRepeatedContext ctx; private final List placeholderFor; private final Symbol on; public Placeholder(Annotate.AnnotateRepeatedContext ctx, List placeholderFor, Symbol on) { super(on.type, List.>nil(), ctx.isTypeCompound ? ((Attribute.TypeCompound)placeholderFor.head).position : // Eventually, we will need to get rid of this use // of unknown, either by using null, or by throwing // an assertion failure here. TypeAnnotationPosition.unknown); this.ctx = ctx; this.placeholderFor = placeholderFor; this.on = on; } @Override public String toString() { return ""; } public List getPlaceholderFor() { return placeholderFor; } public Annotate.AnnotateRepeatedContext getRepeatedContext() { return ctx; } } }