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

equal deleted inserted replaced

-:5a8d00abf076
+:ee1eebe7e210
 /*
-* Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1999, 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
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.Set;
 import java.util.HashSet;
+import javax.lang.model.type.TypeKind;
 import javax.tools.JavaFileManager;
 import javax.tools.FileObject;
 import javax.tools.JavaFileObject;
 import com.sun.tools.javac.code.*;
 import com.sun.tools.javac.code.Attribute.RetentionPolicy;
+import com.sun.tools.javac.code.Attribute.TypeCompound;
 import com.sun.tools.javac.code.Symbol.*;
 import com.sun.tools.javac.code.Type.*;
 import com.sun.tools.javac.code.Types.UniqueType;
 import com.sun.tools.javac.file.BaseFileObject;
 import com.sun.tools.javac.jvm.Pool.DynamicMethod;
 import com.sun.tools.javac.jvm.Pool.Method;
 import com.sun.tools.javac.jvm.Pool.MethodHandle;
 import com.sun.tools.javac.jvm.Pool.Variable;
 import com.sun.tools.javac.util.*;
-import static com.sun.tools.javac.code.BoundKind.*;
 import static com.sun.tools.javac.code.Flags.*;
 import static com.sun.tools.javac.code.Kinds.*;
 import static com.sun.tools.javac.code.TypeTag.*;
 import static com.sun.tools.javac.jvm.UninitializedType.*;
 import static com.sun.tools.javac.main.Option.*;
 */
 public class ClassWriter extends ClassFile {
 protected static final Context.Key<ClassWriter> classWriterKey =
 new Context.Key<ClassWriter>();
-private final Symtab syms;
 private final Options options;
 /** Switch: verbose output.
 */
 private boolean verbose;
-/** Switch: scramble private names.
+/** Switch: scramble private field names.
 */
 private boolean scramble;
-/** Switch: scramble private names.
+/** Switch: scramble all field names.
 */
 private boolean scrambleAll;
 /** Switch: retrofit mode.
 */
 /** Switch: generate CharacterRangeTable attribute.
 */
 private boolean genCrt;
-/** Switch: describe the generated stackmap
+/** Switch: describe the generated stackmap.
 */
 boolean debugstackmap;
 /**
 * Target class version.
 /** Type utilities. */
 private Types types;
 /** The initial sizes of the data and constant pool buffers.
-*  sizes are increased when buffers get full.
+*  Sizes are increased when buffers get full.
 */
 static final int DATA_BUF_SIZE = 0x0fff0;
 static final int POOL_BUF_SIZE = 0x1fff0;
 /** An output buffer for member info.
 protected ClassWriter(Context context) {
 context.put(classWriterKey, this);
 log = Log.instance(context);
 names = Names.instance(context);
-syms = Symtab.instance(context);
 options = Options.instance(context);
 target = Target.instance(context);
 source = Source.instance(context);
 types = Types.instance(context);
 fileManager = context.get(JavaFileManager.class);
 ******************************************************************/
 /** Assemble signature of given type in string buffer.
 */
 void assembleSig(Type type) {
+type = type.unannotatedType();
 switch (type.getTag()) {
 case BYTE:
 sigbuf.appendByte('B');
 break;
 case SHORT:
 }
 return false;
 }
 void assembleClassSig(Type type) {
+type = type.unannotatedType();
 ClassType ct = (ClassType)type;
 ClassSymbol c = (ClassSymbol)ct.tsym;
 enterInner(c);
 Type outer = ct.getEnclosingType();
 if (outer.allparams().nonEmpty()) {
 databuf.appendChar(pool.put(typeSig(sym.type)));
 endAttr(alenIdx);
 acount++;
 }
 acount += writeJavaAnnotations(sym.getRawAttributes());
+acount += writeTypeAnnotations(sym.getRawTypeAttributes());
 return acount;
 }
 /**
 * Write method parameter names attribute.
 attrCount++;
 }
 return attrCount;
 }
+int writeTypeAnnotations(List<Attribute.TypeCompound> typeAnnos) {
+if (typeAnnos.isEmpty()) return 0;
+ListBuffer<Attribute.TypeCompound> visibles = ListBuffer.lb();
+ListBuffer<Attribute.TypeCompound> invisibles = ListBuffer.lb();
+for (Attribute.TypeCompound tc : typeAnnos) {
+if (tc.position == null || tc.position.type == TargetType.UNKNOWN) {
+boolean found = false;
+// TODO: the position for the container annotation of a
+// repeating type annotation has to be set.
+// This cannot be done when the container is created, because
+// then the position is not determined yet.
+// How can we link these pieces better together?
+if (tc.values.size() == 1) {
+Pair<MethodSymbol, Attribute> val = tc.values.get(0);
+if (val.fst.getSimpleName().contentEquals("value") &&
+val.snd instanceof Attribute.Array) {
+Attribute.Array arr = (Attribute.Array) val.snd;
+if (arr.values.length != 0 &&
+arr.values[0] instanceof Attribute.TypeCompound) {
+TypeCompound atycomp = (Attribute.TypeCompound) arr.values[0];
+if (atycomp.position.type != TargetType.UNKNOWN) {
+tc.position = atycomp.position;
+found = true;
+}
+}
+}
+}
+if (!found) {
+// This happens for nested types like @A Outer. @B Inner.
+// For method parameters we get the annotation twice! Once with
+// a valid position, once unknown.
+// TODO: find a cleaner solution.
+// System.err.println("ClassWriter: Position UNKNOWN in type annotation: " + tc);
+continue;
+}
+}
+if (!tc.position.emitToClassfile())
+continue;
+switch (types.getRetention(tc)) {
+case SOURCE: break;
+case CLASS: invisibles.append(tc); break;
+case RUNTIME: visibles.append(tc); break;
+default: ;// /* fail soft */ throw new AssertionError(vis);
+}
+}
+int attrCount = 0;
+if (visibles.length() != 0) {
+int attrIndex = writeAttr(names.RuntimeVisibleTypeAnnotations);
+databuf.appendChar(visibles.length());
+for (Attribute.TypeCompound p : visibles)
+writeTypeAnnotation(p);
+endAttr(attrIndex);
+attrCount++;
+}
+if (invisibles.length() != 0) {
+int attrIndex = writeAttr(names.RuntimeInvisibleTypeAnnotations);
+databuf.appendChar(invisibles.length());
+for (Attribute.TypeCompound p : invisibles)
+writeTypeAnnotation(p);
+endAttr(attrIndex);
+attrCount++;
+}
+return attrCount;
+}
 /** A visitor to write an attribute including its leading
 *  single-character marker.
 */
 class AttributeWriter implements Attribute.Visitor {
 public void visitConstant(Attribute.Constant _value) {
 for (Pair<Symbol.MethodSymbol,Attribute> p : c.values) {
 databuf.appendChar(pool.put(p.fst.name));
 p.snd.accept(awriter);
 }
 }
+void writeTypeAnnotation(Attribute.TypeCompound c) {
+writePosition(c.position);
+writeCompoundAttribute(c);
+}
+void writePosition(TypeAnnotationPosition p) {
+databuf.appendByte(p.type.targetTypeValue()); // TargetType tag is a byte
+switch (p.type) {
+// type cast
+case CAST:
+// instanceof
+case INSTANCEOF:
+// new expression
+case NEW:
+databuf.appendChar(p.offset);
+break;
+// local variable
+case LOCAL_VARIABLE:
+// resource variable
+case RESOURCE_VARIABLE:
+databuf.appendChar(p.lvarOffset.length);  // for table length
+for (int i = 0; i < p.lvarOffset.length; ++i) {
+databuf.appendChar(p.lvarOffset[i]);
+databuf.appendChar(p.lvarLength[i]);
+databuf.appendChar(p.lvarIndex[i]);
+}
+break;
+// exception parameter
+case EXCEPTION_PARAMETER:
+databuf.appendByte(p.exception_index);
+break;
+// method receiver
+case METHOD_RECEIVER:
+// Do nothing
+break;
+// type parameter
+case CLASS_TYPE_PARAMETER:
+case METHOD_TYPE_PARAMETER:
+databuf.appendByte(p.parameter_index);
+break;
+// type parameter bound
+case CLASS_TYPE_PARAMETER_BOUND:
+case METHOD_TYPE_PARAMETER_BOUND:
+databuf.appendByte(p.parameter_index);
+databuf.appendByte(p.bound_index);
+break;
+// class extends or implements clause
+case CLASS_EXTENDS:
+databuf.appendChar(p.type_index);
+break;
+// throws
+case THROWS:
+databuf.appendChar(p.type_index);
+break;
+// method parameter
+case METHOD_FORMAL_PARAMETER:
+databuf.appendByte(p.parameter_index);
+break;
+// method/constructor/reference type argument
+case CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT:
+case METHOD_INVOCATION_TYPE_ARGUMENT:
+case METHOD_REFERENCE_TYPE_ARGUMENT:
+databuf.appendChar(p.offset);
+databuf.appendByte(p.type_index);
+break;
+// We don't need to worry about these
+case METHOD_RETURN:
+case FIELD:
+break;
+// lambda formal parameter
+case LAMBDA_FORMAL_PARAMETER:
+databuf.appendByte(p.parameter_index);
+break;
+case UNKNOWN:
+throw new AssertionError("jvm.ClassWriter: UNKNOWN target type should never occur!");
+default:
+throw new AssertionError("jvm.ClassWriter: Unknown target type for position: " + p);
+}
+{ // Append location data for generics/arrays.
+databuf.appendByte(p.location.size());
+java.util.List<Integer> loc = TypeAnnotationPosition.getBinaryFromTypePath(p.location);
+for (int i : loc)
+databuf.appendByte((byte)i);
+}
+}
 /**********************************************************************
 * Writing Objects
 **********************************************************************/
 /** Enter an inner class into the `innerClasses' set/queue.
 acount++;
 }
 acount += writeFlagAttrs(c.flags());
 acount += writeJavaAnnotations(c.getRawAttributes());
+acount += writeTypeAnnotations(c.getRawTypeAttributes());
 acount += writeEnclosingMethodAttribute(c);
 acount += writeExtraClassAttributes(c);
 poolbuf.appendInt(JAVA_MAGIC);
 poolbuf.appendChar(target.minorVersion);

changeset 15385	ee1eebe7e210
parent 15031	c4fad55a5681
child 15564	6d8db91563a7