1 /*

     2  * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package com.sun.tools.javac.code;

    27 

    28 import java.util.Map;

    29 

    30 import javax.tools.JavaFileObject;

    31 

    32 import com.sun.tools.javac.comp.Annotate;

    33 import com.sun.tools.javac.comp.AttrContext;

    34 import com.sun.tools.javac.comp.Env;

    35 import com.sun.tools.javac.util.*;

    36 import com.sun.tools.javac.util.Assert;

    37 import com.sun.tools.javac.util.List;

    38 import com.sun.tools.javac.util.Log;

    39 import com.sun.tools.javac.util.Pair;

    40 import static com.sun.tools.javac.code.Kinds.PCK;

    41 

    42 /**

    43  * Container for all annotations (attributes in javac) on a Symbol.

    44  *

    45  * This class is explicitly mutable. Its contents will change when attributes

    46  * are annotated onto the Symbol. However this class depends on the facts that

    47  * List (in javac) is immutable.

    48  *

    49  * An instance of this class can be in one of three states:

    50  *

    51  * NOT_STARTED indicates that the Symbol this instance belongs to has not been

    52  * annotated (yet). Specifically if the declaration is not annotated this

    53  * instance will never move past NOT_STARTED. You can never go back to

    54  * NOT_STARTED.

    55  *

    56  * IN_PROGRESS annotations have been found on the declaration. Will be processed

    57  * later. You can reset to IN_PROGRESS. While IN_PROGRESS you can set the list

    58  * of attributes (and this moves out of the IN_PROGRESS state).

    59  *

    60  * "unnamed" this Annotations contains some attributes, possibly the final set.

    61  * While in this state you can only prepend or append to the attributes not set

    62  * it directly. You can also move back to the IN_PROGRESS state using reset().

    63  *

    64  * <p><b>This is NOT part of any supported API. If you write code that depends

    65  * on this, you do so at your own risk. This code and its internal interfaces

    66  * are subject to change or deletion without notice.</b>

    67  */

    68 public class Annotations {

    69 

    70     private static final List<Attribute.Compound> DECL_NOT_STARTED = List.of(null);

    71     private static final List<Attribute.Compound> DECL_IN_PROGRESS = List.of(null);

    72 

    73     /*

    74      * This field should never be null

    75      */

    76     private List<Attribute.Compound> attributes = DECL_NOT_STARTED;

    77 

    78     /*

    79      * Type attributes for this symbol.

    80      * This field should never be null.

    81      */

    82     private List<Attribute.TypeCompound> type_attributes = List.<Attribute.TypeCompound>nil();

    83 

    84     /*

    85      * Type attributes of initializers in this class.

    86      * Unused if the current symbol is not a ClassSymbol.

    87      */

    88     private List<Attribute.TypeCompound> init_type_attributes = List.<Attribute.TypeCompound>nil();

    89 

    90     /*

    91      * Type attributes of class initializers in this class.

    92      * Unused if the current symbol is not a ClassSymbol.

    93      */

    94     private List<Attribute.TypeCompound> clinit_type_attributes = List.<Attribute.TypeCompound>nil();

    95 

    96     /*

    97      * The Symbol this Annotations instance belongs to

    98      */

    99     private final Symbol sym;

   100 

   101     public Annotations(Symbol sym) {

   102         this.sym = sym;

   103     }

   104 

   105     public List<Attribute.Compound> getDeclarationAttributes() {

   106         return filterDeclSentinels(attributes);

   107     }

   108 

   109     public List<Attribute.TypeCompound> getTypeAttributes() {

   110         return type_attributes;

   111     }

   112 

   113     public List<Attribute.TypeCompound> getInitTypeAttributes() {

   114         return init_type_attributes;

   115     }

   116 

   117     public List<Attribute.TypeCompound> getClassInitTypeAttributes() {

   118         return clinit_type_attributes;

   119     }

   120 

   121     public void setDeclarationAttributes(List<Attribute.Compound> a) {

   122         Assert.check(pendingCompletion() || !isStarted());

   123         if (a == null) {

   124             throw new NullPointerException();

   125         }

   126         attributes = a;

   127     }

   128 

   129     public void setTypeAttributes(List<Attribute.TypeCompound> a) {

   130         if (a == null) {

   131             throw new NullPointerException();

   132         }

   133         type_attributes = a;

   134     }

   135 

   136     public void setInitTypeAttributes(List<Attribute.TypeCompound> a) {

   137         if (a == null) {

   138             throw new NullPointerException();

   139         }

   140         init_type_attributes = a;

   141     }

   142 

   143     public void setClassInitTypeAttributes(List<Attribute.TypeCompound> a) {

   144         if (a == null) {

   145             throw new NullPointerException();

   146         }

   147         clinit_type_attributes = a;

   148     }

   149 

   150     public void setAttributes(Annotations other) {

   151         if (other == null) {

   152             throw new NullPointerException();

   153         }

   154         setDeclarationAttributes(other.getDeclarationAttributes());

   155         setTypeAttributes(other.getTypeAttributes());

   156         setInitTypeAttributes(other.getInitTypeAttributes());

   157         setClassInitTypeAttributes(other.getClassInitTypeAttributes());

   158     }

   159 

   160     public void setDeclarationAttributesWithCompletion(final Annotate.AnnotateRepeatedContext<Attribute.Compound> ctx) {

   161         Assert.check(pendingCompletion() || (!isStarted() && sym.kind == PCK));

   162         this.setDeclarationAttributes(getAttributesForCompletion(ctx));

   163     }

   164 

   165     public void appendTypeAttributesWithCompletion(final Annotate.AnnotateRepeatedContext<Attribute.TypeCompound> ctx) {

   166         this.appendUniqueTypes(getAttributesForCompletion(ctx));

   167     }

   168 

   169     private <T extends Attribute.Compound> List<T> getAttributesForCompletion(

   170             final Annotate.AnnotateRepeatedContext<T> ctx) {

   171 

   172         Map<Symbol.TypeSymbol, ListBuffer<T>> annotated = ctx.annotated;

   173         boolean atLeastOneRepeated = false;

   174         List<T> buf = List.<T>nil();

   175         for (ListBuffer<T> lb : annotated.values()) {

   176             if (lb.size() == 1) {

   177                 buf = buf.prepend(lb.first());

   178             } else { // repeated

   179                 // This will break when other subtypes of Attributs.Compound

   180                 // are introduced, because PlaceHolder is a subtype of TypeCompound.

   181                 T res;

   182                 @SuppressWarnings("unchecked")

   183                 T ph = (T) new Placeholder<T>(ctx, lb.toList(), sym);

   184                 res = ph;

   185                 buf = buf.prepend(res);

   186                 atLeastOneRepeated = true;

   187             }

   188         }

   189 

   190         if (atLeastOneRepeated) {

   191             // The Symbol s is now annotated with a combination of

   192             // finished non-repeating annotations and placeholders for

   193             // repeating annotations.

   194             //

   195             // We need to do this in two passes because when creating

   196             // a container for a repeating annotation we must

   197             // guarantee that the @Repeatable on the

   198             // contained annotation is fully annotated

   199             //

   200             // The way we force this order is to do all repeating

   201             // annotations in a pass after all non-repeating are

   202             // finished. This will work because @Repeatable

   203             // is non-repeating and therefore will be annotated in the

   204             // fist pass.

   205 

   206             // Queue a pass that will replace Attribute.Placeholders

   207             // with Attribute.Compound (made from synthesized containers).

   208             ctx.annotateRepeated(new Annotate.Annotator() {

   209                 @Override

   210                 public String toString() {

   211                     return "repeated annotation pass of: " + sym + " in: " + sym.owner;

   212                 }

   213 

   214                 @Override

   215                 public void enterAnnotation() {

   216                     complete(ctx);

   217                 }

   218             });

   219         }

   220         // Add non-repeating attributes

   221         return buf.reverse();

   222     }

   223 

   224     public Annotations reset() {

   225         attributes = DECL_IN_PROGRESS;

   226         return this;

   227     }

   228 

   229     public boolean isEmpty() {

   230         return !isStarted()

   231                 || pendingCompletion()

   232                 || attributes.isEmpty();

   233     }

   234 

   235     public boolean isTypesEmpty() {

   236         return type_attributes.isEmpty();

   237     }

   238 

   239     public boolean pendingCompletion() {

   240         return attributes == DECL_IN_PROGRESS;

   241     }

   242 

   243     public Annotations append(List<Attribute.Compound> l) {

   244         attributes = filterDeclSentinels(attributes);

   245 

   246         if (l.isEmpty()) {

   247             ; // no-op

   248         } else if (attributes.isEmpty()) {

   249             attributes = l;

   250         } else {

   251             attributes = attributes.appendList(l);

   252         }

   253         return this;

   254     }

   255 

   256     public Annotations appendUniqueTypes(List<Attribute.TypeCompound> l) {

   257         if (l.isEmpty()) {

   258             ; // no-op

   259         } else if (type_attributes.isEmpty()) {

   260             type_attributes = l;

   261         } else {

   262             // TODO: in case we expect a large number of annotations, this

   263             // might be inefficient.

   264             for (Attribute.TypeCompound tc : l) {

   265                 if (!type_attributes.contains(tc))

   266                     type_attributes = type_attributes.append(tc);

   267             }

   268         }

   269         return this;

   270     }

   271 

   272     public Annotations appendInitTypeAttributes(List<Attribute.TypeCompound> l) {

   273         if (l.isEmpty()) {

   274             ; // no-op

   275         } else if (init_type_attributes.isEmpty()) {

   276             init_type_attributes = l;

   277         } else {

   278             init_type_attributes = init_type_attributes.appendList(l);

   279         }

   280         return this;

   281     }

   282 

   283     public Annotations appendClassInitTypeAttributes(List<Attribute.TypeCompound> l) {

   284         if (l.isEmpty()) {

   285             ; // no-op

   286         } else if (clinit_type_attributes.isEmpty()) {

   287             clinit_type_attributes = l;

   288         } else {

   289             clinit_type_attributes = clinit_type_attributes.appendList(l);

   290         }

   291         return this;

   292     }

   293 

   294     public Annotations prepend(List<Attribute.Compound> l) {

   295         attributes = filterDeclSentinels(attributes);

   296 

   297         if (l.isEmpty()) {

   298             ; // no-op

   299         } else if (attributes.isEmpty()) {

   300             attributes = l;

   301         } else {

   302             attributes = attributes.prependList(l);

   303         }

   304         return this;

   305     }

   306 

   307     private List<Attribute.Compound> filterDeclSentinels(List<Attribute.Compound> a) {

   308         return (a == DECL_IN_PROGRESS || a == DECL_NOT_STARTED)

   309                 ? List.<Attribute.Compound>nil()

   310                 : a;

   311     }

   312 

   313     private boolean isStarted() {

   314         return attributes != DECL_NOT_STARTED;

   315     }

   316 

   317     private List<Attribute.Compound> getPlaceholders() {

   318         List<Attribute.Compound> res = List.<Attribute.Compound>nil();

   319         for (Attribute.Compound a : filterDeclSentinels(attributes)) {

   320             if (a instanceof Placeholder) {

   321                 res = res.prepend(a);

   322             }

   323         }

   324         return res.reverse();

   325     }

   326 

   327     private List<Attribute.TypeCompound> getTypePlaceholders() {

   328         List<Attribute.TypeCompound> res = List.<Attribute.TypeCompound>nil();

   329         for (Attribute.TypeCompound a : type_attributes) {

   330             if (a instanceof Placeholder) {

   331                 res = res.prepend(a);

   332             }

   333         }

   334         return res.reverse();

   335     }

   336 

   337     /*

   338      * Replace Placeholders for repeating annotations with their containers

   339      */

   340     private <T extends Attribute.Compound> void complete(Annotate.AnnotateRepeatedContext<T> ctx) {

   341         Log log = ctx.log;

   342         Env<AttrContext> env = ctx.env;

   343         JavaFileObject oldSource = log.useSource(env.toplevel.sourcefile);

   344         try {

   345             // TODO: can we reduce duplication in the following branches?

   346             if (ctx.isTypeCompound) {

   347                 Assert.check(!isTypesEmpty());

   348 

   349                 if (isTypesEmpty()) {

   350                     return;

   351                 }

   352 

   353                 List<Attribute.TypeCompound> result = List.nil();

   354                 for (Attribute.TypeCompound a : getTypeAttributes()) {

   355                     if (a instanceof Placeholder) {

   356                         @SuppressWarnings("unchecked")

   357                         Placeholder<Attribute.TypeCompound> ph = (Placeholder<Attribute.TypeCompound>) a;

   358                         Attribute.TypeCompound replacement = replaceOne(ph, ph.getRepeatedContext());

   359 

   360                         if (null != replacement) {

   361                             result = result.prepend(replacement);

   362                         }

   363                     } else {

   364                         result = result.prepend(a);

   365                     }

   366                 }

   367 

   368                 type_attributes = result.reverse();

   369 

   370                 Assert.check(Annotations.this.getTypePlaceholders().isEmpty());

   371             } else {

   372                 Assert.check(!pendingCompletion());

   373 

   374                 if (isEmpty()) {

   375                     return;

   376                 }

   377 

   378                 List<Attribute.Compound> result = List.nil();

   379                 for (Attribute.Compound a : getDeclarationAttributes()) {

   380                     if (a instanceof Placeholder) {

   381                         @SuppressWarnings("unchecked")

   382                         Attribute.Compound replacement = replaceOne((Placeholder<T>) a, ctx);

   383 

   384                         if (null != replacement) {

   385                             result = result.prepend(replacement);

   386                         }

   387                     } else {

   388                         result = result.prepend(a);

   389                     }

   390                 }

   391 

   392                 attributes = result.reverse();

   393 

   394                 Assert.check(Annotations.this.getPlaceholders().isEmpty());

   395             }

   396         } finally {

   397             log.useSource(oldSource);

   398         }

   399     }

   400 

   401     private <T extends Attribute.Compound> T replaceOne(Placeholder<T> placeholder, Annotate.AnnotateRepeatedContext<T> ctx) {

   402         Log log = ctx.log;

   403 

   404         // Process repeated annotations

   405         T validRepeated = ctx.processRepeatedAnnotations(placeholder.getPlaceholderFor(), sym);

   406 

   407         if (validRepeated != null) {

   408             // Check that the container isn't manually

   409             // present along with repeated instances of

   410             // its contained annotation.

   411             ListBuffer<T> manualContainer = ctx.annotated.get(validRepeated.type.tsym);

   412             if (manualContainer != null) {

   413                 log.error(ctx.pos.get(manualContainer.first()), "invalid.repeatable.annotation.repeated.and.container.present",

   414                         manualContainer.first().type.tsym);

   415             }

   416         }

   417 

   418         // A null return will delete the Placeholder

   419         return validRepeated;

   420     }

   421 

   422     private static class Placeholder<T extends Attribute.Compound> extends Attribute.TypeCompound {

   423 

   424         private final Annotate.AnnotateRepeatedContext<T> ctx;

   425         private final List<T> placeholderFor;

   426         private final Symbol on;

   427 

   428         public Placeholder(Annotate.AnnotateRepeatedContext<T> ctx, List<T> placeholderFor, Symbol on) {

   429             super(on.type, List.<Pair<Symbol.MethodSymbol, Attribute>>nil(),

   430                     ctx.isTypeCompound ?

   431                             ((Attribute.TypeCompound)placeholderFor.head).position :

   432                                 null);

   433             this.ctx = ctx;

   434             this.placeholderFor = placeholderFor;

   435             this.on = on;

   436         }

   437 

   438         @Override

   439         public String toString() {

   440             return "<placeholder: " + placeholderFor + " on: " + on + ">";

   441         }

   442 

   443         public List<T> getPlaceholderFor() {

   444             return placeholderFor;

   445         }

   446 

   447         public Annotate.AnnotateRepeatedContext<T> getRepeatedContext() {

   448             return ctx;

   449         }

   450     }

   451 }