Remove dependency on JavaParser's solver, no need for it (#15)

* Remove dependency on JavaParser's solver, no need for it

Author: LunNova

.editorconfig

@@ -10,6 +10,7 @@ insert_final_newline = true
 charset = utf-8
 indent_style = tab
 indent_size = 4
+max_line_length = 180
 
 [*.yml]
 indent_size = 2

build.gradle

@@ -17,17 +17,16 @@ group = 'org.minimallycorrect.javatransformer'
 minimallyCorrectDefaults {
 	description = "Applies transformations to .java and .class files"
 	labels = ["java-transformation", "java-source", "java-bytecode", "java"]
-	ignoreSunInternalWarnings = true
 	configureProject(project)
 }
 
 dependencies {
 	testImplementation "junit:junit:4.12"
-	//Can we make these dependencies optional? Reduced jar size if not using source for patching
 	implementation 'org.ow2.asm:asm:7.2'
 	implementation 'org.ow2.asm:asm-util:7.2'
 	implementation 'org.ow2.asm:asm-tree:7.2'
-	implementation 'com.github.javaparser:javaparser-symbol-solver-core:3.6.24'
+	implementation 'com.github.javaparser:javaparser-core:3.6.24'
+	implementation 'com.google.code.findbugs:jsr305:3.0.2'
 }
 
 tasks.withType(JavaCompile) {

src/main/java/org/minimallycorrect/javatransformer/api/ClassInfo.java

@@ -1,15 +1,14 @@
 package org.minimallycorrect.javatransformer.api;
 
 import java.util.List;
-import java.util.function.Function;
 import java.util.stream.Stream;
 
 import org.jetbrains.annotations.Contract;
 import org.jetbrains.annotations.Nullable;
 
 import org.minimallycorrect.javatransformer.internal.util.CollectionUtil;
 
-public interface ClassInfo extends ClassMember {
+public interface ClassInfo extends ClassMember, HasTypeVariable {
 	default void add(ClassMember member) {
 		if (member instanceof MethodInfo)
 			add((MethodInfo) member);
@@ -96,10 +95,6 @@ default Stream<ClassMember> getMembers() {
 		return Stream.concat(getFields(), getMethods());
 	}
 
-	default void accessFlags(Function<AccessFlags, AccessFlags> c) {
-		setAccessFlags(c.apply(getAccessFlags()));
-	}
-
 	@Override
 	default ClassInfo getClassInfo() {
 		return this;

src/main/java/org/minimallycorrect/javatransformer/api/JavaTransformer.java

@@ -31,9 +31,7 @@
 import java.util.zip.ZipInputStream;
 import java.util.zip.ZipOutputStream;
 
-import lombok.Getter;
 import lombok.NonNull;
-import lombok.Setter;
 import lombok.ToString;
 import lombok.val;
 
@@ -42,11 +40,11 @@
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.tree.ClassNode;
 
-import com.github.javaparser.*;
+import com.github.javaparser.JavaParser;
+import com.github.javaparser.ParseProblemException;
+import com.github.javaparser.ParseStart;
 import com.github.javaparser.ast.CompilationUnit;
 import com.github.javaparser.ast.body.TypeDeclaration;
-import com.github.javaparser.symbolsolver.JavaSymbolSolver;
-import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
 
 import org.minimallycorrect.javatransformer.internal.ByteCodeInfo;
 import org.minimallycorrect.javatransformer.internal.SourceInfo;
@@ -58,8 +56,6 @@
 import org.minimallycorrect.javatransformer.internal.util.NodeUtil;
 import org.minimallycorrect.javatransformer.internal.util.StreamUtil;
 
-@Getter
-@Setter
 @ToString
 public class JavaTransformer {
 	private final List<Transformer> transformers = new ArrayList<>();
@@ -251,7 +247,7 @@ public Supplier<byte[]> transformJava(@NonNull Supplier<byte[]> data, @NonNull S
 		CachingSupplier<TypeDeclaration<?>> supplier = CachingSupplier.of(() -> {
 			byte[] bytes = data.get();
 
-			val parser = new JavaParser(new ParserConfiguration().setSymbolResolver(new JavaSymbolSolver((TypeSolver) classPath)));
+			val parser = new JavaParser();
 			val result = parser.parse(ParseStart.COMPILATION_UNIT, provider(new ByteArrayInputStream(bytes), Charset.forName("UTF8")));
 			if (!result.isSuccessful()) {
 				throw new ParseProblemException(result.getProblems());
@@ -346,6 +342,26 @@ public Class<?> defineClass(ClassLoader classLoader, String name) {
 		return DefineClass.defineClass(classLoader, name, result);
 	}
 
+	public List<Transformer> getTransformers() {
+		return this.transformers;
+	}
+
+	public Map<String, byte[]> getTransformedFiles() {
+		return this.transformedFiles;
+	}
+
+	public List<Consumer<JavaTransformer>> getAfterTransform() {
+		return this.afterTransform;
+	}
+
+	public ClassPath getClassPath() {
+		return this.classPath;
+	}
+
+	public void setClassPath(ClassPath classPath) {
+		this.classPath = classPath;
+	}
+
 	private enum PathType {
 		JAR,
 		FOLDER;

src/main/java/org/minimallycorrect/javatransformer/api/Parameter.java

@@ -8,13 +8,11 @@
 import lombok.EqualsAndHashCode;
 import lombok.Getter;
 import lombok.NonNull;
-import lombok.ToString;
 
 import org.jetbrains.annotations.Nullable;
 
 @EqualsAndHashCode(exclude = {"annotationSupplier", "name"})
 @Getter
-@ToString
 public class Parameter implements Annotated {
 	@Nullable
 	public final String name;
@@ -39,4 +37,8 @@ public List<Annotation> getAnnotations() {
 			return Collections.emptyList();
 		return annotationSupplier.get();
 	}
+
+	public String toString() {
+		return "Parameter(name=" + this.getName() + ", type=" + this.getType() + ")";
+	}
 }

src/main/java/org/minimallycorrect/javatransformer/api/Type.java

@@ -48,12 +48,19 @@
 @Data
 public class Type {
 	public static final Type UNKNOWN = new Type("Ljava/lang/Object;", "Tunknown;");
+	public static final Type WILDCARD = new Type("Ljava/lang/Object;", "*");
 	public static final Type OBJECT = Type.of("java.lang.Object");
 	public static final Type BOOLEAN = new Type("Z");
 	public static final Type DOUBLE = new Type("D");
 	public static final Type FLOAT = new Type("F");
 	public static final Type INT = new Type("I");
 	public static final Type LONG = new Type("L");
+	public static final Type CHAR = new Type("C");
+	public static final Type STRING = Type.of("java.lang.String");
+	public static final Type STATIC_META_CLASS = new Type("Ljvm/STATIC;", "Ljvm/STATIC;");
+	public static final Type ANNOTATION = Type.of("java.lang.annotation.Annotation");
+	public static final Type CLAZZ = Type.of("java.lang.Class");
+	public static final Type LAMBDA = Type.of("Ljvm/LAMBDA;");
 
 	/**
 	 * A descriptor represents the real part of a type
@@ -102,6 +109,10 @@ private static void checkSignature(@Nullable String signature) {
 			throw new TransformationException("Invalid signature '" + signature + "'. After generic bracket should either be '>' or ';'");
 	}
 
+	public static Type staticMetaclassOf(Type type) {
+		return STATIC_META_CLASS.withTypeArgument(type);
+	}
+
 	public static Type of(String fullClassName) {
 		// TODO: 23/01/2016 Handle inner classes properly? currently depend on following naming standards
 		// depends on: lower case package names, uppercase first letter of class name
@@ -311,9 +322,13 @@ public Type withClassName(String name) {
 		return new Type(descriptor, signature);
 	}
 
-	public boolean isAssignableFrom(Type type) {
-		return descriptor.equals(type.descriptor) ||
-			(isClassType() && getClassName().equals("java.lang.Object") && (type.isArrayType() || type.isClassType()));
+	public static boolean isAssignableFrom(Type to, Type from) {
+		return to.descriptor.equals(from.descriptor) ||
+			(to.isClassType() && to.getClassName().equals("java.lang.Object") && (from.isArrayType() || from.isClassType()));
+	}
+
+	public boolean isStaticMetaClass() {
+		return descriptor == STATIC_META_CLASS.descriptor;
 	}
 
 	@AllArgsConstructor
@@ -368,6 +383,22 @@ public static DescriptorType of(char c) {
 			throw new UnknownDescriptorTypeException("Unknnown descriptor type '" + c + "'");
 		}
 
+		@Nullable
+		public Integer getByteWidth() {
+			switch (this) {
+				case BYTE:
+					return 1;
+				case CHAR:
+				case SHORT:
+					return 2;
+				case INT:
+					return 4;
+				case LONG:
+					return 8;
+			}
+			return null;
+		}
+
 		private static class UnknownDescriptorTypeException extends RuntimeException {
 			private static final long serialVersionUID = 0;
 

src/main/java/org/minimallycorrect/javatransformer/internal/AsmCodeFragmentGenerator.java

@@ -345,8 +345,9 @@ private void convertTypes(MethodNodeInfoCodeFragment insertFragment, InsertionPo
 					continue;
 				}
 				val input = movedInputTypes.get(index++);
-				if (!iv.type.isAssignableFrom(input.type))
-					throw new UnsupportedOperationException();
+				// TODO this needs context to work properly maybe we should disable the check?
+				//				if (!Type.isAssignableFrom(iv.type, input.type))
+				//					throw new UnsupportedOperationException();
 				switch (iv.location.type) {
 					case STACK:
 						val var = new VarInsnNode(AsmInstructions.getLoadInstructionForType(iv), input.location.index);
@@ -488,6 +489,12 @@ public <T extends CodeFragment> List<T> findFragments(Class<T> fragmentType) {
 
 			val result = new ArrayList<T>();
 			AbstractInsnNode insn = getFirstInstruction();
+
+			// FIXME: null for abstract methods, shouldn't get here
+			if (insn == null) {
+				return result;
+			}
+
 			val last = getLastInstruction();
 			while (true) {
 				if (constructor.getParameterTypes()[1].isAssignableFrom(insn.getClass()))
@@ -564,7 +571,8 @@ public MethodCall(ByteCodeInfo.MethodNodeInfo containingMethodNodeInfo, MethodIn
 		@NonNull
 		@Override
 		public Type getContainingClassType() {
-			return new Type('L' + instruction.owner + ';');
+			val owner = instruction.owner;
+			return new Type(owner.charAt(0) == '[' ? owner : 'L' + owner + ';');
 		}
 
 		@NonNull

src/main/java/org/minimallycorrect/javatransformer/internal/ByteCodeInfo.java

@@ -120,7 +120,11 @@ public void remove(FieldInfo field) {
 
 	@Override
 	public Type getSuperType() {
-		return new Type("L" + node.get().superName + ";");
+		val superName = node.get().superName;
+		if (superName == null) {
+			return null;
+		}
+		return new Type("L" + superName + ";");
 	}
 
 	@Override
@@ -152,6 +156,20 @@ MethodNodeInfo wrap(MethodNode node) {
 		return new MethodNodeInfo(node);
 	}
 
+	@Override
+	public List<TypeVariable> getTypeVariables() {
+		/*
+		Test<T, D> gets signature:
+		<T:Ljava/lang/Object;D:Ljava/lang/Object;>
+		 */
+		return Signature.getTypeVariables(node.get().signature);
+	}
+
+	@Override
+	public void setTypeVariables(List<TypeVariable> typeVariables) {
+		throw new UnsupportedOperationException(); // TODO
+	}
+
 	public class FieldNodeInfo implements FieldInfo {
 		final FieldNode node;
 		private Type type;