pretty big refactor; introduced a new source package which should be (and is) separately compilable, i.e. has no deps on any of the others.

This is preparation work for being able to access some of these from lombok.ast without creating a cyclic dependency nightmare.

1 files changed, 453 insertions, 0 deletions

diff --git a/src/utils/lombok/bytecode/ClassFileMetaData.java b/src/utils/lombok/bytecode/ClassFileMetaData.java
new file mode 100644
index 00000000..b1e0eff3
--- /dev/null
+++ b/src/utils/lombok/bytecode/ClassFileMetaData.java
@@ -0,0 +1,453 @@
+/*
+ * Copyright © 2010 Reinier Zwitserloot and Roel Spilker.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package lombok.bytecode;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Utility to read the constant pool, header, and inheritance information of any class file.
+ */
+public class ClassFileMetaData {
+	private static final byte UTF8 = 1;
+	private static final byte INTEGER = 3;
+	private static final byte FLOAT = 4;
+	private static final byte LONG = 5;
+	private static final byte DOUBLE = 6;
+	private static final byte CLASS = 7;
+	private static final byte STRING = 8;
+	private static final byte FIELD = 9;
+	private static final byte METHOD = 10;
+	private static final byte INTERFACE_METHOD = 11;
+	private static final byte NAME_TYPE = 12;
+	// New in java7: support for methodhandles and invokedynamic
+	private static final byte METHOD_HANDLE = 15;
+	private static final byte METHOD_TYPE = 16;
+	private static final byte INVOKE_DYNAMIC = 18;
+	
+	private static final int NOT_FOUND = -1;
+	private static final int START_OF_CONSTANT_POOL = 8; 
+	
+	private final byte[] byteCode;
+	
+	private final int maxPoolSize; 
+	private final int[] offsets;
+	private final byte[] types;
+	private final String[] utf8s;
+	private final int endOfPool;
+	
+	public ClassFileMetaData(byte[] byteCode) {
+		this.byteCode = byteCode;
+		
+		maxPoolSize = readValue(START_OF_CONSTANT_POOL);
+		offsets = new int[maxPoolSize];
+		types = new byte[maxPoolSize];
+		utf8s = new String[maxPoolSize];
+		int position = 10;
+		for (int i = 1; i < maxPoolSize; i++) {
+			byte type = byteCode[position];
+			types[i] = type;
+			position++;
+			offsets[i] = position;
+			switch (type) {
+			case UTF8:
+				int length = readValue(position);
+				position += 2;
+				utf8s[i] = decodeString(position, length);
+				position += length;
+				break;
+			case CLASS:
+			case STRING:
+			case METHOD_TYPE:
+				position += 2;
+				break;
+			case METHOD_HANDLE:
+				position += 3;
+				break;
+			case INTEGER:
+			case FLOAT:
+			case FIELD:
+			case METHOD:
+			case INTERFACE_METHOD:
+			case NAME_TYPE:
+			case INVOKE_DYNAMIC:
+				position += 4;
+				break;
+			case LONG:
+			case DOUBLE:
+				position += 8;
+				i++;
+				break;
+			case 0:
+				break;
+			default:
+				throw new AssertionError("Unknown constant pool type " + type);
+			}
+		}
+		endOfPool = position;
+	}
+	
+	private String decodeString(int pos, int size) {
+		int end = pos + size;
+		
+		// the resulting string might be smaller
+		StringBuilder result = new StringBuilder(size);
+		while (pos < end) {
+			int first = (byteCode[pos++] & 0xFF);
+			if (first < 0x80) {
+				result.append((char)first);
+			} else if ((first & 0xE0) == 0xC0) {
+				int x = (first & 0x1F) << 6;
+				int y = (byteCode[pos++] & 0x3F);
+				result.append((char)(x | y));
+			} else {
+				int x = (first & 0x0F) << 12;
+				int y = (byteCode[pos++] & 0x3F) << 6;
+				int z = (byteCode[pos++] & 0x3F);
+				result.append((char)(x | y | z));
+			}
+		}
+		return result.toString();
+	}
+	
+	/**
+	 * Checks if the constant pool contains the provided 'raw' string. These are used as source material for further JVM types, such as string constants, type references, etcetera.
+	 */
+	public boolean containsUtf8(String value) {
+		return findUtf8(value) != NOT_FOUND;
+	}
+	
+	/**
+	 * Checks if the constant pool contains a reference to the provided class.
+	 * 
+	 * NB: Most uses of a type do <em>NOT</em> show up as a class in the constant pool.
+	 *    For example, the parameter types and return type of any method you invoke or declare, are stored as signatures and not as type references,
+	 *    but the type to which any method you invoke belongs, is. Read the JVM Specification for more information.
+	 * 
+	 * @param className must be provided JVM-style, such as {@code java/lang/String}
+	 */
+	public boolean usesClass(String className) {
+		return findClass(className) != NOT_FOUND;
+	}
+	
+	/**
+	 * Checks if the constant pool contains a reference to a given field, either for writing or reading.
+	 * 
+	 * @param className must be provided JVM-style, such as {@code java/lang/String}
+	 */
+	public boolean usesField(String className, String fieldName) {
+		int classIndex = findClass(className);
+		if (classIndex == NOT_FOUND) return false;
+		int fieldNameIndex = findUtf8(fieldName);
+		if (fieldNameIndex == NOT_FOUND) return false;
+		
+		for (int i = 1; i < maxPoolSize; i++) {
+			if (types[i] == FIELD && readValue(offsets[i]) == classIndex) {
+				int nameAndTypeIndex = readValue(offsets[i] + 2);
+				if (readValue(offsets[nameAndTypeIndex]) == fieldNameIndex) return true;
+			}
+		}
+		return false;
+	}
+	
+	/**
+	 * Checks if the constant pool contains a reference to a given method, with any signature (return type and parameter types).
+	 * 
+	 * @param className must be provided JVM-style, such as {@code java/lang/String}
+	 */
+	public boolean usesMethod(String className, String methodName) {
+		int classIndex = findClass(className);
+		if (classIndex == NOT_FOUND) return false;
+		int methodNameIndex = findUtf8(methodName);
+		if (methodNameIndex == NOT_FOUND) return false;
+		
+		for (int i = 1; i < maxPoolSize; i++) {
+			if (isMethod(i) && readValue(offsets[i]) == classIndex) {
+				int nameAndTypeIndex = readValue(offsets[i] + 2);
+				if (readValue(offsets[nameAndTypeIndex]) == methodNameIndex) return true;
+			}
+		}
+		return false;
+	}
+	
+	/**
+	 * Checks if the constant pool contains a reference to a given method.
+	 * 
+	 * @param className must be provided JVM-style, such as {@code java/lang/String}
+	 * @param descriptor must be provided JVM-style, such as {@code (IZ)Ljava/lang/String;}
+	 */
+	public boolean usesMethod(String className, String methodName, String descriptor) {
+		int classIndex = findClass(className);
+		if (classIndex == NOT_FOUND) return false;
+		int nameAndTypeIndex = findNameAndType(methodName, descriptor);
+		if (nameAndTypeIndex == NOT_FOUND) return false;
+		
+		for (int i = 1; i < maxPoolSize; i++) {
+			if (isMethod(i) && 
+					readValue(offsets[i]) == classIndex && 
+					readValue(offsets[i] + 2) == nameAndTypeIndex) return true;
+		}
+		return false;
+	}
+	
+	/**
+	 * Checks if the constant pool contains the provided string constant, which implies the constant is used somewhere in the code.
+	 * 
+	 * NB: String literals get concatenated by the compiler.
+	 */
+	public boolean containsStringConstant(String value) {
+		int index = findUtf8(value);
+		if (index == NOT_FOUND) return false;
+		for (int i = 1; i < maxPoolSize; i++) {
+			if (types[i] == STRING && readValue(offsets[i]) == index) return true; 
+		}
+		return false;
+	}
+	
+	/**
+	 * Checks if the constant pool contains the provided long constant, which implies the constant is used somewhere in the code.
+	 * 
+	 * NB: compile-time constant expressions are evaluated at compile time.
+	 */
+	public boolean containsLong(long value) {
+		for (int i = 1; i < maxPoolSize; i++) {
+			if (types[i] == LONG && readLong(i) == value) return true;
+		}
+		return false;
+	}
+	
+	/**
+	 * Checks if the constant pool contains the provided double constant, which implies the constant is used somewhere in the code.
+	 * 
+	 * NB: compile-time constant expressions are evaluated at compile time.
+	 */
+	public boolean containsDouble(double value) {
+		boolean isNan = Double.isNaN(value);
+		for (int i = 1; i < maxPoolSize; i++) {
+			if (types[i] == DOUBLE) {
+				double d = readDouble(i);
+				if (d == value || (isNan && Double.isNaN(d))) return true;
+			}
+		}
+		return false;
+	}
+	
+	/**
+	 * Checks if the constant pool contains the provided int constant, which implies the constant is used somewhere in the code.
+	 * 
+	 * NB: compile-time constant expressions are evaluated at compile time.
+	 */
+	public boolean containsInteger(int value) {
+		for (int i = 1; i < maxPoolSize; i++) {
+			if (types[i] == INTEGER && readInteger(i) == value) return true;
+		}
+		return false;
+	}
+	
+	/**
+	 * Checks if the constant pool contains the provided float constant, which implies the constant is used somewhere in the code.
+	 * 
+	 * NB: compile-time constant expressions are evaluated at compile time.
+	 */
+	public boolean containsFloat(float value) {
+		boolean isNan = Float.isNaN(value);
+		for (int i = 1; i < maxPoolSize; i++) {
+			if (types[i] == FLOAT) {
+				float f = readFloat(i);
+				if (f == value || (isNan && Float.isNaN(f))) return true;
+			}
+		}
+		return false;
+	}
+	
+	private long readLong(int index) {
+		int pos = offsets[index];
+		return ((long)read32(pos)) << 32 | read32(pos + 4);
+	}
+	
+	private double readDouble(int index) {
+		int pos = offsets[index];
+		long bits = ((long)read32(pos)) << 32 | (read32(pos + 4) & 0x00000000FFFFFFFF);
+		return Double.longBitsToDouble(bits);
+	}
+	
+	private long readInteger(int index) {
+		return read32(offsets[index]);
+	}
+	
+	private float readFloat(int index) {
+		return Float.intBitsToFloat(read32(offsets[index]));
+	}
+	
+	private int read32(int pos) {
+		return (byteCode[pos] & 0xFF) << 24 | (byteCode[pos + 1] & 0xFF) << 16 | (byteCode[pos + 2] & 0xFF) << 8 | (byteCode[pos + 3] &0xFF);
+	}
+	
+	/**
+	 * Returns the name of the class in JVM format, such as {@code java/lang/String}
+	 */
+	public String getClassName() {
+		return getClassName(readValue(endOfPool + 2));
+	}
+	
+	/**
+	 * Returns the name of the superclass in JVM format, such as {@code java/lang/Object}
+	 * 
+	 * NB: If you try this on Object itself, you'll get {@code null}.<br />
+	 * NB2: For interfaces and annotation interfaces, you'll always get {@code java/lang/Object}
+	 */
+	public String getSuperClassName() {
+		return getClassName(readValue(endOfPool + 4));
+	}
+	
+	/**
+	 * Returns the name of all implemented interfaces.
+	 */
+	public List<String> getInterfaces() {
+		int size = readValue(endOfPool + 6);
+		if (size == 0) return Collections.emptyList();
+		
+		List<String> result = new ArrayList<String>();
+		for (int i = 0; i < size; i++) {
+			result.add(getClassName(readValue(endOfPool + 8 + (i * 2))));
+		}
+		return result;
+	}
+	
+	/**
+	 * A {@code toString()} like utility to dump all contents of the constant pool into a string.
+	 * 
+	 * NB: No guarantees are made about the exact layout of this string. It is for informational purposes only, don't try to parse it.<br />
+	 * NB2: After a double or long, there's a JVM spec-mandated gap, which is listed as {@code (cont.)} in the returned string.
+	 */
+	public String poolContent() {
+		StringBuilder result = new StringBuilder();
+		for (int i = 1; i < maxPoolSize; i++) {
+			result.append(String.format("#%02x: ", i));
+			int pos = offsets[i];
+			switch(types[i]) {
+			case UTF8:
+				result.append("Utf8 ").append(utf8s[i]);
+				break;
+			case CLASS:
+				result.append("Class ").append(getClassName(i));
+				break;
+			case STRING:
+				result.append("String \"").append(utf8s[readValue(pos)]).append("\"");
+				break;
+			case INTEGER:
+				result.append("int ").append(readInteger(i));
+				break;
+			case FLOAT:
+				result.append("float ").append(readFloat(i));
+				break;
+			case FIELD:
+				appendAccess(result.append("Field "), i);
+				break;
+			case METHOD:
+			case INTERFACE_METHOD:
+				appendAccess(result.append("Method "), i);
+				break;
+			case NAME_TYPE:
+				appendNameAndType(result.append("Name&Type "), i);
+				break;
+			case LONG:
+				result.append("long ").append(readLong(i));
+				break;
+			case DOUBLE:
+				result.append("double ").append(readDouble(i));
+				break;
+			case METHOD_HANDLE:
+				result.append("MethodHandle...");
+				break;
+			case METHOD_TYPE:
+				result.append("MethodType...");
+				break;
+			case INVOKE_DYNAMIC:
+				result.append("InvokeDynamic...");
+				break;
+			case 0:
+				result.append("(cont.)");
+				break;
+			}
+			result.append("\n");
+		}
+		return result.toString();
+	}
+	
+	private void appendAccess(StringBuilder result, int index) {
+		int pos = offsets[index];
+		result.append(getClassName(readValue(pos))).append(".");
+		appendNameAndType(result, readValue(pos + 2));
+	}
+	
+	private void appendNameAndType(StringBuilder result, int index) {
+		int pos = offsets[index];
+		result.append(utf8s[readValue(pos)]).append(":").append(utf8s[readValue(pos + 2)]);
+	}
+	
+	private String getClassName(int classIndex) {
+		if (classIndex < 1) return null;
+		return utf8s[readValue(offsets[classIndex])];
+	}
+	
+	private boolean isMethod(int i) {
+		byte type = types[i];
+		return type == METHOD || type == INTERFACE_METHOD;
+	}
+	
+	private int findNameAndType(String name, String descriptor) {
+		int nameIndex = findUtf8(name);
+		if (nameIndex == NOT_FOUND) return NOT_FOUND;
+		int descriptorIndex = findUtf8(descriptor);
+		if (descriptorIndex == NOT_FOUND) return NOT_FOUND;
+		for (int i = 1; i < maxPoolSize; i++) {
+			if (types[i] == NAME_TYPE && 
+					readValue(offsets[i]) == nameIndex && 
+					readValue(offsets[i] + 2) == descriptorIndex) return i;
+		}
+		return NOT_FOUND;
+	}
+	
+	private int findUtf8(String value) {
+		for (int i = 1; i < maxPoolSize; i++) {
+			if (value.equals(utf8s[i])) {
+				return i;
+			}
+		}
+		return NOT_FOUND;
+	}
+	
+	private int findClass(String className) {
+		int index = findUtf8(className);
+		if (index == -1) return NOT_FOUND;
+		for (int i = 1; i < maxPoolSize; i++) {
+			if (types[i] == CLASS && readValue(offsets[i]) == index) return i;
+		}
+		return NOT_FOUND;
+	}
+	
+	private int readValue(int position) {
+		return ((byteCode[position] & 0xFF) << 8) | (byteCode[position + 1] & 0xFF);
+	}
+}