package annotations.io;
/*>>>
import org.checkerframework.checker.nullness.qual.*;
*/
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.Writer;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import annotations.Annotation;
import annotations.el.AClass;
import annotations.el.AElement;
import annotations.el.AField;
import annotations.el.AMethod;
import annotations.el.AScene;
import annotations.el.ATypeElement;
import annotations.el.ATypeElementWithType;
import annotations.el.AnnotationDef;
import annotations.el.BoundLocation;
import annotations.el.DefCollector;
import annotations.el.DefException;
import annotations.el.InnerTypeLocation;
import annotations.el.LocalLocation;
import annotations.el.RelativeLocation;
import annotations.el.TypeIndexLocation;
import annotations.field.AnnotationAFT;
import annotations.field.AnnotationFieldType;
import annotations.field.ArrayAFT;
import annotations.field.BasicAFT;
import annotations.field.ClassTokenAFT;
import annotations.util.Strings;
import com.sun.tools.javac.code.TypeAnnotationPosition.TypePathEntry;
/**
* IndexFileWriter provides two static methods named <code>write</code>
* that write a given {@link AScene} to a given {@link Writer} or filename,
* in index file format.
*/
public final class IndexFileWriter {
final AScene scene;
private static final String INDENT = " ";
void printAnnotationDefBody(AnnotationDef d) {
for (Map. Entry<String, AnnotationFieldType> f : d.fieldTypes.entrySet()) {
String fieldname = f.getKey();
AnnotationFieldType fieldType = f.getValue();
pw.println(INDENT + fieldType + " " + fieldname);
}
pw.println();
}
private class OurDefCollector extends DefCollector {
OurDefCollector() throws DefException {
super(IndexFileWriter.this.scene);
}
@Override
protected void visitAnnotationDef(AnnotationDef d) {
if (!d.name.contains("+")) {
pw.println("package " + annotations.io.IOUtils.packagePart(d.name) + ":");
pw.print("annotation @" + annotations.io.IOUtils.basenamePart(d.name) + ":");
// TODO: We would only print Retention and Target annotations
printAnnotations(requiredMetaannotations(d.tlAnnotationsHere));
pw.println();
printAnnotationDefBody(d);
}
}
private Collection<Annotation> requiredMetaannotations(
Collection<Annotation> annos) {
Set<Annotation> results = new HashSet<Annotation>();
for (Annotation a : annos) {
String aName = a.def.name;
if (aName.equals(Retention.class.getCanonicalName())
|| aName.equals(Target.class.getCanonicalName())) {
results.add(a);
}
}
return results;
}
}
final PrintWriter pw;
private void printValue(AnnotationFieldType aft, Object o) {
if (aft instanceof AnnotationAFT) {
printAnnotation((Annotation) o);
} else if (aft instanceof ArrayAFT) {
ArrayAFT aaft = (ArrayAFT) aft;
pw.print('{');
if (!(o instanceof List)) {
printValue(aaft.elementType, o);
} else {
List<?> l =
(List<?>) o;
// watch out--could be an empty array of unknown type
// (see AnnotationBuilder#addEmptyArrayField)
if (aaft.elementType == null) {
if (l.size() != 0) {
throw new AssertionError();
}
} else {
boolean first = true;
for (Object o2 : l) {
if (!first) {
pw.print(',');
}
printValue(aaft.elementType, o2);
first = false;
}
}
}
pw.print('}');
} else if (aft instanceof ClassTokenAFT) {
pw.print(aft.format(o));
} else if (aft instanceof BasicAFT && o instanceof String) {
pw.print(Strings.escape((String) o));
} else {
pw.print(o.toString());
}
}
private void printAnnotation(Annotation a) {
pw.print("@" + a.def().name);
if (!a.fieldValues.isEmpty()) {
pw.print('(');
boolean first = true;
for (Map. Entry<String, Object> f
: a.fieldValues.entrySet()) {
if (!first) {
pw.print(',');
}
pw.print(f.getKey() + "=");
printValue(a.def().fieldTypes.get(f.getKey()), f.getValue());
first = false;
}
pw.print(')');
}
}
private void printAnnotations(Collection<? extends Annotation> annos) {
for (Annotation tla : annos) {
pw.print(' ');
printAnnotation(tla);
}
}
private void printAnnotations(AElement e) {
printAnnotations(e.tlAnnotationsHere);
}
private void printElement(String indentation,
String desc,
AElement e) {
pw.print(indentation + desc + ":");
printAnnotations(e);
pw.println();
}
private void printElementAndInnerTypes(String indentation,
String desc, AElement e) {
if (e.type != null) {
printElement(indentation, desc, e.type);
if (!e.type.innerTypes.isEmpty()) {
printInnerTypes(indentation + INDENT, e.type);
}
}
}
private void printTypeElementAndInnerTypes(String indentation,
String desc,
ATypeElement e) {
if (e.tlAnnotationsHere.isEmpty() && e.innerTypes.isEmpty() && desc.equals("type")) {
return;
}
printElement(indentation, desc, e);
printInnerTypes(indentation + INDENT, e);
}
private void printInnerTypes(String indentation, ATypeElement e) {
for (Map. Entry<InnerTypeLocation,
ATypeElement> ite : e.innerTypes.entrySet()) {
InnerTypeLocation loc = ite.getKey();
AElement it = ite.getValue();
pw.print(indentation + "inner-type");
char sep = ' ';
for (TypePathEntry l : loc.location) {
pw.print(sep);
pw.print(typePathEntryToString(l));
sep = ',';
}
pw.print(':');
printAnnotations(it);
pw.println();
}
}
private void printInnerTypes(String indentation, ATypeElement e,
ASTPath path) {
for (Map. Entry<InnerTypeLocation,
ATypeElement> ite : e.innerTypes.entrySet()) {
InnerTypeLocation loc = ite.getKey();
AElement it = ite.getValue();
pw.print(indentation + "inner-type");
char sep = ' ';
for (TypePathEntry l : loc.location) {
pw.print(sep);
pw.print(typePathEntryToString(l));
sep = ',';
}
pw.print(':');
printAnnotations(it);
pw.println();
}
}
/**
* Converts the given {@link TypePathEntry} to a string of the form
* {@code tag, arg}, where tag and arg are both integers.
*/
private String typePathEntryToString(TypePathEntry t) {
return t.tag.tag + ", " + t.arg;
}
private void printNumberedAmbigiousElements(String indentation,
String desc,
Map<Integer, ? extends AElement> nels) {
for (Map. Entry<Integer,
? extends AElement> te : nels.entrySet()) {
AElement t = te.getValue();
printAmbElementAndInnerTypes(indentation,
desc + " #" + te.getKey(), t);
}
}
private void printAmbElementAndInnerTypes(String indentation,
String desc,
AElement e) {
printElement(indentation, desc, e);
if (e.type.tlAnnotationsHere.isEmpty() && e.type.innerTypes.isEmpty()) {
return;
}
printElement(indentation + INDENT, "type", e.type);
for (Map. Entry<InnerTypeLocation, ATypeElement> ite
: e.type.innerTypes.entrySet()) {
InnerTypeLocation loc = ite.getKey();
AElement it = ite.getValue();
pw.print(indentation + INDENT + INDENT + "inner-type");
boolean first = true;
for (TypePathEntry l : loc.location) {
if (first) {
pw.print(' ');
} else {
pw.print(',');
}
pw.print(typePathEntryToString(l));
first = false;
}
pw.print(':');
printAnnotations(it);
pw.println();
}
}
private void printRelativeElements(String indentation,
String desc,
Map<RelativeLocation, ATypeElement> nels) {
for (Map. Entry<RelativeLocation, ATypeElement> te
: nels.entrySet()) {
ATypeElement t = te.getValue();
printTypeElementAndInnerTypes(indentation,
desc + " " + te.getKey().getLocationString(), t);
}
}
private void printRelativeElements(String indentation,
String desc1, String desc2,
Map<RelativeLocation, ATypeElement> nels) {
RelativeLocation prev = null;
for (Map. Entry<RelativeLocation, ATypeElement> te
: nels.entrySet()) {
ATypeElement t = te.getValue();
RelativeLocation loc = te.getKey();
boolean isOffset = loc.index < 0;
if (prev == null || loc.type_index < 0
|| (isOffset ? loc.offset != prev.offset
: loc.index != prev.index)) {
pw.print(indentation + desc1 + " ");
pw.print(isOffset ? "#" + loc.offset : "*" + loc.index);
pw.print(":");
if (loc.type_index <= 0) { printAnnotations(t); }
pw.println();
printInnerTypes(indentation + INDENT, t);
}
if (loc.type_index > 0) {
printTypeElementAndInnerTypes(indentation + INDENT,
desc2 + " " + loc.type_index, t);
}
prev = loc;
}
}
private void printBounds(String indentation,
Map<BoundLocation, ATypeElement> bounds) {
for (Map. Entry<BoundLocation, ATypeElement> be
: bounds.entrySet()) {
BoundLocation bl = be.getKey();
ATypeElement b = be.getValue();
if (bl.boundIndex == -1) {
printTypeElementAndInnerTypes(indentation,
"typeparam " + bl.paramIndex, b);
} else {
printTypeElementAndInnerTypes(indentation,
"bound " + bl.paramIndex + " &" + bl.boundIndex, b);
}
}
}
private void printExtImpls(String indentation,
Map<TypeIndexLocation, ATypeElement> extImpls) {
for (Map. Entry<TypeIndexLocation, ATypeElement> ei
: extImpls.entrySet()) {
TypeIndexLocation idx = ei.getKey();
ATypeElement ty = ei.getValue();
// reading from a short into an integer does not preserve sign?
if (idx.typeIndex == -1 || idx.typeIndex == 65535) {
printTypeElementAndInnerTypes(indentation, "extends", ty);
} else {
printTypeElementAndInnerTypes(indentation, "implements " + idx.typeIndex, ty);
}
}
}
private void printASTInsertions(String indentation,
Map<ASTPath, ATypeElement>
insertAnnotations,
Map<ASTPath, ATypeElementWithType>
insertTypecasts) {
for (Map. Entry<ASTPath, ATypeElement> e :
insertAnnotations.entrySet()) {
ASTPath path = e.getKey();
ATypeElement el = e.getValue();
pw.print(indentation + "insert-annotation " + path + ":");
printAnnotations(el);
pw.println();
printInnerTypes(INDENT, el, path);
}
for (Map. Entry<ASTPath,
ATypeElementWithType> e :
insertTypecasts.entrySet()) {
ASTPath path = e.getKey();
ATypeElementWithType el = e.getValue();
pw.print(indentation + "insert-typecast " + path + ":");
printAnnotations(el);
pw.print(" ");
printType(el.getType());
pw.println();
printInnerTypes(INDENT, el, path);
}
}
private void printType(type.Type type) {
switch (type.getKind()) {
case ARRAY:
type.ArrayType a = (type.ArrayType) type;
printType(a.getComponentType());
pw.print("[]");
break;
case BOUNDED:
type.BoundedType b = (type.BoundedType) type;
printType(b.getName());
pw.print(" ");
pw.print(b.getBoundKind());
pw.print(" ");
printType(b.getBound());
break;
case DECLARED:
type.DeclaredType d = (type.DeclaredType) type;
pw.print(d.getName());
if (!d.isWildcard()) {
type.DeclaredType inner = d.getInnerType();
Iterator<type.Type> iter = d.getTypeParameters().iterator();
// for (String s : d.getAnnotations()) {
// pw.print(s + " ");
// }
if (iter.hasNext()) {
pw.print("<");
printType(iter.next());
while (iter.hasNext()) {
pw.print(", ");
printType(iter.next());
}
pw.print(">");
}
if (inner != null) {
pw.print(".");
printType(inner);
}
}
break;
}
}
private void write() throws DefException {
// First the annotation definitions...
OurDefCollector odc = new OurDefCollector();
odc.visit();
// Then any package annotations...
for (Map. Entry<String, AElement> pe
: scene.packages.entrySet()) {
AElement elem = pe.getValue();
if (elem != null && !elem.tlAnnotationsHere.isEmpty()) {
pw.print("package " + pe.getKey() + ":");
printAnnotations(elem);
pw.println();
}
}
// And then the annotated classes
final String indent2 = INDENT + INDENT;
final String indent3 = INDENT + indent2;
for (Map. Entry<String, AClass> ce
: scene.classes.entrySet()) {
String cname = ce.getKey();
AClass c = ce.getValue();
String pkg = annotations.io.IOUtils.packagePart(cname);
String basename = annotations.io.IOUtils.basenamePart(cname);
if ("package-info".equals(basename)) {
if (!c.tlAnnotationsHere.isEmpty()) {
pw.print("package " + pkg + ":");
printAnnotations(c);
pw.println();
}
continue;
} else {
pw.println("package " + pkg + ":");
pw.print("class " + basename + ":");
printAnnotations(c);
pw.println();
}
printBounds(INDENT, c.bounds);
printExtImpls(INDENT, c.extendsImplements);
printASTInsertions(INDENT, c.insertAnnotations, c.insertTypecasts);
for (Map. Entry<String, AField> fe
: c.fields.entrySet()) {
String fname = fe.getKey();
AField f = fe.getValue();
pw.println();
printElement(INDENT, "field " + fname, f);
printTypeElementAndInnerTypes(indent2, "type", f.type);
printASTInsertions(indent2,
f.insertAnnotations, f.insertTypecasts);
}
for (Map. Entry<String, AMethod> me
: c.methods.entrySet()) {
String mkey = me.getKey();
AMethod m = me.getValue();
pw.println();
printElement(INDENT, "method " + mkey, m);
printBounds(indent2, m.bounds);
printTypeElementAndInnerTypes(indent2, "return", m.returnType);
if (!m.receiver.type.tlAnnotationsHere.isEmpty()
|| !m.receiver.type.innerTypes.isEmpty()) {
// Only output the receiver if there is something to
// say. This is a bit inconsistent with the return
// type, but so be it.
printElementAndInnerTypes(indent2, "receiver", m.receiver);
}
printNumberedAmbigiousElements(indent2,
"parameter", m.parameters);
for (Map. Entry<LocalLocation,
AField> le : m.body.locals.entrySet()) {
LocalLocation loc = le.getKey();
AElement l = le.getValue();
StringBuilder sb = new StringBuilder("local ");
sb.append(loc.varName == null
? loc.index
+ " #" + loc.scopeStart + "+" + loc.scopeLength
: loc.varName);
printElement(indent2, sb.toString(), l);
printTypeElementAndInnerTypes(indent3,
"type", l.type);
}
printRelativeElements(indent2, "typecast",
m.body.typecasts);
printRelativeElements(indent2, "instanceof",
m.body.instanceofs);
printRelativeElements(indent2, "new", m.body.news);
printRelativeElements(indent2, "reference", "typearg", m.body.refs);
printRelativeElements(indent2, "call", "typearg", m.body.calls);
for (Map. Entry<RelativeLocation,
AMethod> entry : m.body.funs.entrySet()) {
AMethod lambda = entry.getValue();
RelativeLocation loc = entry.getKey();
pw.print("lambda " + loc.getLocationString() + ":\n");
printBounds(indent3, lambda.bounds);
printTypeElementAndInnerTypes(indent3,
"return", lambda.returnType);
}
// throwsException field is not processed. Why?
printASTInsertions(indent2,
m.insertAnnotations, m.insertTypecasts);
}
pw.println();
}
}
private IndexFileWriter(AScene scene,
Writer out) throws DefException {
this.scene = scene;
pw = new PrintWriter(out);
write();
pw.flush();
}
/**
* Writes the annotations in <code>scene</code> and their definitions to
* <code>out</code> in index file format.
*
* <p>
* An {@link AScene} can contain several annotations of the same type but
* different definitions, while an index file can accommodate only a single
* definition for each annotation type. This has two consequences:
*
* <ul>
* <li>Before writing anything, this method uses a {@link DefCollector} to
* ensure that all definitions of each annotation type are identical
* (modulo unknown array types). If not, a {@link DefException} is thrown.
* <li>There is one case in which, even if a scene is written successfully,
* reading it back in produces a different scene. Consider a scene
* containing two annotations of type Foo, each with an array field bar.
* In one annotation, bar is empty and of unknown element type (see
* {@link annotations.AnnotationBuilder#addEmptyArrayField}); in the other, bar is
* of known element type. This method will
* {@linkplain AnnotationDef#unify unify} the two definitions of Foo by
* writing a single definition with known element type. When the index
* file is read into a new scene, the definitions of both annotations
* will have known element type, whereas in the original scene, one had
* unknown element type.
* </ul>
*/
public static void write(
AScene scene,
Writer out) throws DefException {
new IndexFileWriter(scene, out);
}
/**
* Writes the annotations in <code>scene</code> and their definitions to
* the file <code>filename</code> in index file format; see
* {@link #write(AScene, Writer)}.
*/
public static void write(
AScene scene,
String filename) throws IOException, DefException {
write(scene, new FileWriter(filename));
}
}