public static class RedirectorConfig {
        @Comment("启用本模块")
        public boolean enable = true;
        @Comment("检测或应用模式\n注意，在初次启动时会自动进行分析")
        public boolean detectionMode = true;
        @Comment("找到的枚举类型定义")
        public Set<String> declaration = new HashSet<>();
        @Comment("找到的枚举类型引用")
        public Map<String, Set<MemberDescriptor>> reference = new HashMap<>();

        public transient Set<String> enumReference = new HashSet<>();

        public void end() {
            enumReference.removeIf(type -> !declaration.contains(type));
            declaration.removeIf(type -> !enumReference.contains(type));
        }
    }
···

配置逻辑
···java
        if (INSTANCE.redirector.enable) {
            if (INSTANCE.redirector.detectionMode) {
                INSTANCE.redirector.declaration.clear();
                INSTANCE.redirector.reference.clear();
                Redirector.Find transformer = new Redirector.Find(INSTANCE.redirector);
                CoremodLoader.喜加一(transformer);
                Runtime.getRuntime().addShutdownHook(new Thread(() -> {
                    System.out.println("summaries: yes="+transformer.totalApply+", no="+transformer.totalSkip+", total="+transformer.noMatch);
                    INSTANCE.redirector.detectionMode = false;
                    INSTANCE.redirector.end();
                    save();
                }));
            } else {
                CoremodLoader.喜加一(new Redirector(INSTANCE.redirector));
            }
        }

class Redirector implements Transformer {
	private final ModuleConfig.RedirectorConfig config;

	public Redirector(ModuleConfig.RedirectorConfig config) {this.config = config;}

	@Override
	public boolean transform(String name, Context ctx) throws TransformException {
		var changed = false;
		if (config.declaration.contains(name)) {
			ClassNode data = ctx.getData();
			for (MethodNode method : data.methods) {
				if (method.name().equals("values") && method.rawDesc().startsWith("()[L")) {
					if (data.getMethodObj("redirector$values") != null) return false;

					var node = method.getAttribute(data.cp, Attribute.Code).instructions.getNodeAt(0);

					var redirector$values = data.newMethod(Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC, "redirector$values", method.rawDesc());
					redirector$values.visitSize(1, 0);
					redirector$values.field(Opcodes.GETFIELD, node.desc());
					redirector$values.insn(Opcodes.ARETURN);
					redirector$values.finish();
					changed = true;
					break;
				}
			}
		}
		if (config.reference.containsKey(name)) {
			var descriptors = config.reference.get(name);
			ClassNode data = ctx.getData();
			for (MethodNode method : data.methods) {
				var methodRef = new MemberDescriptor("", method.name(), method.rawDesc());
				if (descriptors.contains(methodRef)) {
					System.out.println("applying to "+methodRef);
					Code code = method.getAttribute(data.cp, Attribute.Code);
					for (InsnNode node : code.instructions) {
						if (node.opcode() == Opcodes.INVOKESTATIC) {
							MemberDescriptor desc = node.desc();
							if (this.config.declaration.contains(desc.owner) && desc.name.equals("values") && desc.rawDesc.startsWith("()[L")) {
								desc.name = "redirector$values";
								break;
							}
						}
					}
				}
			}
			return true;
		}
		return changed;
	}

	/** 第一遍Transformer */
	public static class Find implements Transformer {
		int totalApply, totalSkip, noMatch;
		private final ModuleConfig.RedirectorConfig config;

		public Find(ModuleConfig.RedirectorConfig config) {
			this.config = config;
		}

		@Override
		public synchronized boolean transform(String name, Context ctx) throws TransformException {
			ClassNode data = ctx.getData();
			if (data.parent().equals("java/lang/Enum")) {
				config.declaration.add(data.name());
			}

			for (MethodNode method : data.methods) {
				Code code = method.getAttribute(data.cp, Attribute.Code);
				/*if (code != null) for (InsnNode node : code.instructions) {
					if (node.opcode() == Opcodes.AASTORE) break;
					if (node.opcode() == Opcodes.INVOKESTATIC) {
						MemberDescriptor desc = node.desc();
						if (desc.name.equals("values") && desc.rawDesc.startsWith("()[L")) {
							List<MemberDescriptor> list = config.reference.computeIfAbsent(data.name(), Helpers.fnArrayList());
							MemberDescriptor md = new MemberDescriptor(method.owner(), method.name(), method.rawDesc());
							if (!list.contains(md)) list.add(md);
							break;
						}
					}
				}*/
				if (code != null) {
					var ok = mayApply(method, code, data);
					if (ok == null) {
						totalApply++;
						System.out.println("apply for "+method.copyDesc());
					} else if (!ok.equals("no match")) {
						totalSkip++;
						System.out.println("skip for"+method+", because of "+ok);
					} else {
						noMatch++;
					}
				}
			}
			return false;
		}

		private static final boolean moreBogus = false;
		private String mayApply(MethodNode method, Code code, ClassNode data) {
			InsnNode node = code.instructions.getNodeAt(0);
			var enumTypes = new HashSet<String>();
			while (node != null) {
				if (node.opcode() == Opcodes.INVOKESTATIC) {
					MemberDescriptor desc = node.desc();
					safe:
					if (desc.name.equals("values") && desc.rawDesc.startsWith("()[L")) {
						enumTypes.add(desc.owner);

						node = node.next();
						String immediateOp = Opcodes.toString(node.opcode());
						if (immediateOp.equals("ArrayLength")) break safe;
						if (immediateOp.startsWith("ILoad") || node.getAsInteger() != null) {
							node = node.next();
							if (Opcodes.toString(node.opcode()).equals("AALoad")) continue;
							else return "ldc+!aaload";
						}
						if (immediateOp.equals("InvokeStatic")) {
							MemberDescriptor desc1 = node.desc();
							if (desc1.owner.equals("java/util/Arrays") && desc1.name.equals("stream")) break safe;
							if (desc1.owner.equals("java/util/stream/Stream") && desc1.name.equals("of")) break safe;
						}
						// allow putstatic, since nearly everyone stores it will not modify them (to cache)
						if (moreBogus && immediateOp.startsWith("PutStatic")) break safe;
						if (!immediateOp.startsWith("AStore")) return "invokestatic+!astore";

						int slot = node.getVarId();
						// after store
						var node1 = node;
						while (true) {
							node1 = node1.next();
							if (node1 == null) break;

							check:
							if (slot == node1.getVarId()) {
								String op = Opcodes.toString(node1.opcode());
								// ok, this part is safe……
								if (op.startsWith("AStore")) break;
								if (!op.startsWith("ALoad")) return "unknown instruction "+node1;

								node1 = node1.next();
								if (node1.opcode() == Opcodes.ARRAYLENGTH) break check;
								if (Opcodes.toString(node1.opcode()).startsWith("ILoad") || node1.getAsInteger() != null) {
									node1 = node1.next();
									if (Opcodes.toString(node1.opcode()).equals("AALoad")) continue;
									return "excepting aaload not ldc+"+node1;
								}
								// allow change variable slot, but since we only track one slot, old might be changed……
								if (true && Opcodes.toString(node1.opcode()).startsWith("AAStore")) {
									slot = node1.getVarId();
									continue;
								}
								return "excepting ldc not "+node1;
							}
						}

						break;
					}
				}

				node = node.next();
			}

			if (!enumTypes.isEmpty()) {
				config.enumReference.addAll(enumTypes);
				var methodRef = new MemberDescriptor("", method.name(), method.rawDesc());
				var whitelist = config.reference.computeIfAbsent(data.name(), Helpers.fnHashSet());
				whitelist.add(methodRef);
				return null;
			}

			return "no match";
		}
	}
}