Small tool to extract modifier bit info from JDT

constants.md

0
ClassFileConstants#AccDefault

1
ClassFileConstants#AccPublic

2
ClassFileConstants#AccPrivate

4
ClassFileConstants#AccProtected

7
ExtraCompilerModifiers#AccVisibilityMASK

8
ClassFileConstants#AccStatic

16
ClassFileConstants#AccFinal

32
ClassFileConstants#AccSuper
ClassFileConstants#AccSynchronized

64
ClassFileConstants#AccBridge
ClassFileConstants#AccVolatile

128
ClassFileConstants#AccTransient
ClassFileConstants#AccVarargs

256
ClassFileConstants#AccNative

512
ClassFileConstants#AccInterface

1024
ClassFileConstants#AccAbstract

2048
ClassFileConstants#AccStrictfp

4096
ClassFileConstants#AccSynthetic

8192
ClassFileConstants#AccAnnotation

16384
ClassFileConstants#AccEnum

32768
ClassFileConstants#AccMandated
ClassFileConstants#AccModule

65535
ExtraCompilerModifiers#AccJustFlag

65536
ExtraCompilerModifiers#AccDefaultMethod

131072
ClassFileConstants#AccAnnotationDefault

262144
ExtraCompilerModifiers#AccRestrictedAccess

524288
ExtraCompilerModifiers#AccDefaultAbstract
ExtraCompilerModifiers#AccFromClassFile

1048576
ClassFileConstants#AccDeprecated

2097152
ExtraCompilerModifiers#AccDeprecatedImplicitly

4194304
ExtraCompilerModifiers#AccAlternateModifierProblem

8388608
ExtraCompilerModifiers#AccModifierProblem
ExtraCompilerModifiers#AccCompactConstructor

16777216
ExtraCompilerModifiers#AccRecord
ExtraCompilerModifiers#AccSemicolonBody

33554432
ExtraCompilerModifiers#AccUnresolved

67108864
ExtraCompilerModifiers#AccIsDefaultConstructor
ExtraCompilerModifiers#AccBlankFinal
ExtraCompilerModifiers#AccNonSealed

134217728
ExtraCompilerModifiers#AccLocallyUsed

268435456
ExtraCompilerModifiers#AccSealed
ExtraCompilerModifiers#AccPatternVariable
ExtraCompilerModifiers#AccOverriding

536870912
ExtraCompilerModifiers#AccImplementing

1073741824
ExtraCompilerModifiers#AccGenericSignature

ModifierConstantsCollector.java

package spoon.generating.jdt;

import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.lookup.ExtraCompilerModifiers;

import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class ModifierConstantsCollector {

	private final Class<?>[] classes;

	public static void main(String[] args) {
		ModifierConstantsCollector collector = new ModifierConstantsCollector(
				ClassFileConstants.class,
				ExtraCompilerModifiers.class
		);
		Map<Integer, List<Field>> map = collector.processClasses();
		try (PrintStream printStream = new PrintStream("constants.md")) {
			print(map, printStream);
		} catch (FileNotFoundException e) {
			throw new RuntimeException(e);
		}
	}

	public ModifierConstantsCollector(Class<?>... classes) {
		this.classes = classes;
	}

	private static Predicate<Field> isIntField() {
		return field -> field.getType() == int.class;
	}

	private static Function<Field, Integer> extractDefault() {
		return field -> {
			try {
				return field.getInt(null);
			} catch (IllegalAccessException e) {
				throw new RuntimeException(e);
			}
		};
	}

	private static Predicate<Field> hasModifier(int modifier) {
		return field -> (field.getModifiers() & modifier) != 0;
	}

	private static Predicate<Field> nameStartsWith(String s) {
		return field -> field.getName().startsWith(s);
	}

	public Map<Integer, List<Field>> processClasses() {
		return Arrays.stream(classes)
				.map(this::collectConstants)
				.flatMap(Collection::stream)
				.sorted(Comparator.comparing(extractDefault()))
				.collect(Collectors.groupingBy(extractDefault(), LinkedHashMap::new, Collectors.toList()));
	}

	public static void print(Map<Integer, List<Field>> map, PrintStream out) {
		map.forEach((k, v) -> {
			out.println("| " + k + " |");
			out.println("| --------- |");
			v.forEach(f -> {
				Class<?> decl = f.getDeclaringClass();
				String name = f.getName();
				out.println("| " + decl.getSimpleName() + "#" + name + " |");
			});
			out.println();
		});
	}

	private Set<Field> collectConstants(Class<?> clazz) {
		return Arrays.stream(clazz.getFields())
				.filter(isIntField())
				.filter(hasModifier(Modifier.STATIC))
				.filter(hasModifier(Modifier.PUBLIC))
				.filter(nameStartsWith("Acc"))
				.collect(Collectors.toSet());
	}
}