智慧考勤 v1.0.28版本的 MD5 值为：12729d810518c958a6eb8d5a86a946dd

以下内容为反编译后的 JavacAST.java 源代码，内容仅作参考

package lombok.javac;

import com.sun.tools.javac.code.Source;
import com.sun.tools.javac.code.Symtab;
import com.sun.tools.javac.model.JavacElements;
import com.sun.tools.javac.model.JavacTypes;
import com.sun.tools.javac.tree.JCTree;
import com.sun.tools.javac.tree.TreeMaker;
import com.sun.tools.javac.util.Context;
import com.sun.tools.javac.util.JCDiagnostic;
import com.sun.tools.javac.util.Log;
import com.sun.tools.javac.util.Name;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.net.URI;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import javax.annotation.processing.Messager;
import javax.tools.Diagnostic;
import javax.tools.JavaFileObject;
import lombok.core.AST;
import lombok.core.CleanupRegistry;
import lombok.core.CleanupTask;
import lombok.permit.Permit;
public class JavacAST extends AST<JavacAST, JavacNode, JCTree> {
    private final CleanupRegistry cleanup;
    private final JavacElements elements;
    private final JavacTreeMaker treeMaker;
    private final Symtab symtab;
    private final JavacTypes javacTypes;
    private final Log log;
    private final ErrorLog errorLogger;
    private final Context context;
    private URI memoizedAbsoluteFileLocation;
    private static Field JCTRY_RESOURCES_FIELD;
    private static Field JCANNOTATEDTYPE_ANNOTATIONS;
    private static Field JCANNOTATEDTYPE_UNDERLYINGTYPE;
    private static int[] $SWITCH_TABLE$lombok$core$AST$Kind;
    private static int[] $SWITCH_TABLE$javax$tools$Diagnostic$Kind;
    private static final URI NOT_CALCULATED_MARKER = URI.create("https://projectlombok.org/not/calculated");
    private static boolean JCTRY_RESOURCES_FIELD_INITIALIZED = false;
    private static boolean JCANNOTATEDTYPE_FIELDS_INITIALIZED = false;
    private static final ConcurrentMap<Class<?>, Method> getBodyMethods = new ConcurrentHashMap();

    @Override
    protected void setElementInASTCollection(Field field, Object obj, List list, Collection collection, int i, JCTree jCTree) throws IllegalAccessException {
        setElementInASTCollection2(field, obj, (List<Collection<?>>) list, (Collection<?>) collection, i, jCTree);
    }

    static int[] $SWITCH_TABLE$lombok$core$AST$Kind() {
        int[] iArr = $SWITCH_TABLE$lombok$core$AST$Kind;
        if (iArr != null) {
            return iArr;
        }
        int[] iArr2 = new int[AST.Kind.valuesCustom().length];
        try {
            iArr2[AST.Kind.ANNOTATION.ordinal()] = 6;
        } catch (NoSuchFieldError unused) {
        }
        try {
            iArr2[AST.Kind.ARGUMENT.ordinal()] = 7;
        } catch (NoSuchFieldError unused2) {
        }
        try {
            iArr2[AST.Kind.COMPILATION_UNIT.ordinal()] = 1;
        } catch (NoSuchFieldError unused3) {
        }
        try {
            iArr2[AST.Kind.FIELD.ordinal()] = 3;
        } catch (NoSuchFieldError unused4) {
        }
        try {
            iArr2[AST.Kind.INITIALIZER.ordinal()] = 4;
        } catch (NoSuchFieldError unused5) {
        }
        try {
            iArr2[AST.Kind.LOCAL.ordinal()] = 8;
        } catch (NoSuchFieldError unused6) {
        }
        try {
            iArr2[AST.Kind.METHOD.ordinal()] = 5;
        } catch (NoSuchFieldError unused7) {
        }
        try {
            iArr2[AST.Kind.STATEMENT.ordinal()] = 9;
        } catch (NoSuchFieldError unused8) {
        }
        try {
            iArr2[AST.Kind.TYPE.ordinal()] = 2;
        } catch (NoSuchFieldError unused9) {
        }
        try {
            iArr2[AST.Kind.TYPE_USE.ordinal()] = 10;
        } catch (NoSuchFieldError unused10) {
        }
        $SWITCH_TABLE$lombok$core$AST$Kind = iArr2;
        return iArr2;
    }

    static int[] $SWITCH_TABLE$javax$tools$Diagnostic$Kind() {
        int[] iArr = $SWITCH_TABLE$javax$tools$Diagnostic$Kind;
        if (iArr != null) {
            return iArr;
        }
        int[] iArr2 = new int[Diagnostic.Kind.values().length];
        try {
            iArr2[Diagnostic.Kind.ERROR.ordinal()] = 1;
        } catch (NoSuchFieldError unused) {
        }
        try {
            iArr2[Diagnostic.Kind.MANDATORY_WARNING.ordinal()] = 3;
        } catch (NoSuchFieldError unused2) {
        }
        try {
            iArr2[Diagnostic.Kind.NOTE.ordinal()] = 4;
        } catch (NoSuchFieldError unused3) {
        }
        try {
            iArr2[Diagnostic.Kind.OTHER.ordinal()] = 5;
        } catch (NoSuchFieldError unused4) {
        }
        try {
            iArr2[Diagnostic.Kind.WARNING.ordinal()] = 2;
        } catch (NoSuchFieldError unused5) {
        }
        $SWITCH_TABLE$javax$tools$Diagnostic$Kind = iArr2;
        return iArr2;
    }

    public JavacAST(Messager messager, Context context, JCTree.JCCompilationUnit top, CleanupRegistry cleanup) {
        super(sourceName(top), PackageName.getPackageName(top), new JavacImportList(top), statementTypes());
        this.memoizedAbsoluteFileLocation = NOT_CALCULATED_MARKER;
        setTop(buildCompilationUnit(top));
        this.context = context;
        this.log = Log.instance(context);
        this.errorLogger = ErrorLog.create(messager, this.log);
        this.elements = JavacElements.instance(context);
        this.treeMaker = new JavacTreeMaker(TreeMaker.instance(context));
        this.symtab = Symtab.instance(context);
        this.javacTypes = JavacTypes.instance(context);
        this.cleanup = cleanup;
        clearChanged();
    }

    @Override
    public URI getAbsoluteFileLocation() {
        if (this.memoizedAbsoluteFileLocation == NOT_CALCULATED_MARKER) {
            this.memoizedAbsoluteFileLocation = getAbsoluteFileLocation(top().get());
        }
        return this.memoizedAbsoluteFileLocation;
    }

    public static URI getAbsoluteFileLocation(JCTree.JCCompilationUnit cu) {
        try {
            return cu.sourcefile.toUri();
        } catch (Exception unused) {
            return null;
        }
    }

    private static String sourceName(JCTree.JCCompilationUnit cu) {
        if (cu.sourcefile == null) {
            return null;
        }
        return cu.sourcefile.toString();
    }

    public Context getContext() {
        return this.context;
    }

    public void traverse(JavacASTVisitor visitor) {
        top().traverse(visitor);
    }

    public void traverseChildren(JavacASTVisitor visitor, JavacNode node) {
        Iterator<JavacNode> it = node.down().iterator();
        while (it.hasNext()) {
            JavacNode child = it.next();
            child.traverse(visitor);
        }
    }

    @Override
    public int getSourceVersion() {
        try {
            String nm = Source.instance(this.context).name();
            int underscoreIdx = nm.indexOf(95);
            return underscoreIdx > -1 ? Integer.parseInt(nm.substring(underscoreIdx + 1)) : Integer.parseInt(nm);
        } catch (Exception unused) {
            return 6;
        }
    }

    @Override
    public int getLatestJavaSpecSupported() {
        return Javac.getJavaCompilerVersion();
    }

    public void cleanupTask(String key, JCTree target, CleanupTask task) {
        this.cleanup.registerTask(key, target, task);
    }

    public Name toName(String name) {
        return this.elements.getName(name);
    }

    public JavacTreeMaker getTreeMaker() {
        this.treeMaker.at(-1);
        return this.treeMaker;
    }

    public Symtab getSymbolTable() {
        return this.symtab;
    }

    public JavacTypes getTypesUtil() {
        return this.javacTypes;
    }

    @Override
    public JavacNode buildTree(JCTree node, AST.Kind kind) {
        switch ($SWITCH_TABLE$lombok$core$AST$Kind()[kind.ordinal()]) {
            case 1:
                return buildCompilationUnit((JCTree.JCCompilationUnit) node);
            case 2:
                return buildType((JCTree.JCClassDecl) node);
            case 3:
                return buildField((JCTree.JCVariableDecl) node);
            case 4:
                return buildInitializer((JCTree.JCBlock) node);
            case 5:
                return buildMethod((JCTree.JCMethodDecl) node);
            case 6:
                return buildAnnotation((JCTree.JCAnnotation) node, false);
            case 7:
                return buildLocalVar((JCTree.JCVariableDecl) node, kind);
            case 8:
                return buildLocalVar((JCTree.JCVariableDecl) node, kind);
            case 9:
                return buildStatementOrExpression(node);
            case 10:
                return buildTypeUse(node);
            default:
                throw new AssertionError("Did not expect: " + kind);
        }
    }

    private JavacNode buildCompilationUnit(JCTree.JCCompilationUnit top) {
        List<JavacNode> childNodes = new ArrayList<>();
        Iterator it = top.defs.iterator();
        while (it.hasNext()) {
            JCTree s = (JCTree) it.next();
            if (s instanceof JCTree.JCClassDecl) {
                addIfNotNull(childNodes, buildType((JCTree.JCClassDecl) s));
            }
        }
        return new JavacNode(this, top, childNodes, AST.Kind.COMPILATION_UNIT);
    }

    private JavacNode buildType(JCTree.JCClassDecl type) {
        if (setAndGetAsHandled(type)) {
            return null;
        }
        List<JavacNode> childNodes = new ArrayList<>();
        Iterator it = type.mods.annotations.iterator();
        while (it.hasNext()) {
            JCTree.JCAnnotation annotation = (JCTree.JCAnnotation) it.next();
            addIfNotNull(childNodes, buildAnnotation(annotation, false));
        }
        Iterator it2 = type.defs.iterator();
        while (it2.hasNext()) {
            JCTree def = (JCTree) it2.next();
            if (def instanceof JCTree.JCMethodDecl) {
                addIfNotNull(childNodes, buildMethod((JCTree.JCMethodDecl) def));
            } else if (def instanceof JCTree.JCClassDecl) {
                addIfNotNull(childNodes, buildType((JCTree.JCClassDecl) def));
            } else if (def instanceof JCTree.JCVariableDecl) {
                addIfNotNull(childNodes, buildField((JCTree.JCVariableDecl) def));
            } else if (def instanceof JCTree.JCBlock) {
                addIfNotNull(childNodes, buildInitializer((JCTree.JCBlock) def));
            }
        }
        return putInMap(new JavacNode(this, type, childNodes, AST.Kind.TYPE));
    }

    private JavacNode buildField(JCTree.JCVariableDecl field) {
        if (setAndGetAsHandled(field)) {
            return null;
        }
        List<JavacNode> childNodes = new ArrayList<>();
        Iterator it = field.mods.annotations.iterator();
        while (it.hasNext()) {
            JCTree.JCAnnotation annotation = (JCTree.JCAnnotation) it.next();
            addIfNotNull(childNodes, buildAnnotation(annotation, true));
        }
        addIfNotNull(childNodes, buildTypeUse(field.vartype));
        addIfNotNull(childNodes, buildExpression(field.init));
        return putInMap(new JavacNode(this, field, childNodes, AST.Kind.FIELD));
    }

    private JavacNode buildLocalVar(JCTree.JCVariableDecl local, AST.Kind kind) {
        if (setAndGetAsHandled(local)) {
            return null;
        }
        List<JavacNode> childNodes = new ArrayList<>();
        Iterator it = local.mods.annotations.iterator();
        while (it.hasNext()) {
            JCTree.JCAnnotation annotation = (JCTree.JCAnnotation) it.next();
            addIfNotNull(childNodes, buildAnnotation(annotation, true));
        }
        addIfNotNull(childNodes, buildTypeUse(local.vartype));
        addIfNotNull(childNodes, buildExpression(local.init));
        return putInMap(new JavacNode(this, local, childNodes, kind));
    }

    private JavacNode buildTypeUse(JCTree typeUse) {
        if (setAndGetAsHandled(typeUse) || typeUse == null) {
            return null;
        }
        if (typeUse.getClass().getName().equals("com.sun.tools.javac.tree.JCTree$JCAnnotatedType")) {
            initJcAnnotatedType(typeUse.getClass());
            Collection<?> anns = (Collection) Permit.permissiveReadField(Collection.class, JCANNOTATEDTYPE_ANNOTATIONS, typeUse);
            JCTree.JCExpression underlying = (JCTree.JCExpression) Permit.permissiveReadField(JCTree.JCExpression.class, JCANNOTATEDTYPE_UNDERLYINGTYPE, typeUse);
            List<JavacNode> childNodes = new ArrayList<>();
            if (anns != null) {
                for (Object annotation : anns) {
                    if (annotation instanceof JCTree.JCAnnotation) {
                        addIfNotNull(childNodes, buildAnnotation((JCTree.JCAnnotation) annotation, true));
                    }
                }
            }
            addIfNotNull(childNodes, buildTypeUse(underlying));
            return putInMap(new JavacNode(this, typeUse, childNodes, AST.Kind.TYPE_USE));
        } else if (typeUse instanceof JCTree.JCWildcard) {
            JCTree inner = ((JCTree.JCWildcard) typeUse).inner;
            List<JavacNode> childNodes2 = inner == null ? Collections.emptyList() : new ArrayList<>();
            if (inner != null) {
                addIfNotNull(childNodes2, buildTypeUse(inner));
            }
            return putInMap(new JavacNode(this, typeUse, childNodes2, AST.Kind.TYPE_USE));
        } else if (typeUse instanceof JCTree.JCArrayTypeTree) {
            JCTree.JCExpression jCExpression = ((JCTree.JCArrayTypeTree) typeUse).elemtype;
            List<JavacNode> childNodes3 = jCExpression == null ? Collections.emptyList() : new ArrayList<>();
            if (jCExpression != null) {
                addIfNotNull(childNodes3, buildTypeUse(jCExpression));
            }
            return putInMap(new JavacNode(this, typeUse, childNodes3, AST.Kind.TYPE_USE));
        } else if (typeUse instanceof JCTree.JCFieldAccess) {
            JCTree.JCExpression jCExpression2 = ((JCTree.JCFieldAccess) typeUse).selected;
            List<JavacNode> childNodes4 = jCExpression2 == null ? Collections.emptyList() : new ArrayList<>();
            if (jCExpression2 != null) {
                addIfNotNull(childNodes4, buildTypeUse(jCExpression2));
            }
            return putInMap(new JavacNode(this, typeUse, childNodes4, AST.Kind.TYPE_USE));
        } else if (typeUse instanceof JCTree.JCIdent) {
            return putInMap(new JavacNode(this, typeUse, Collections.emptyList(), AST.Kind.TYPE_USE));
        } else {
            return null;
        }
    }

    private static List<JCTree> getResourcesForTryNode(JCTree.JCTry tryNode) {
        if (!JCTRY_RESOURCES_FIELD_INITIALIZED) {
            JCTRY_RESOURCES_FIELD = Permit.permissiveGetField(JCTree.JCTry.class, "resources");
            JCTRY_RESOURCES_FIELD_INITIALIZED = true;
        }
        if (JCTRY_RESOURCES_FIELD == null) {
            return Collections.emptyList();
        }
        Object rv = null;
        try {
            rv = JCTRY_RESOURCES_FIELD.get(tryNode);
        } catch (Exception unused) {
        }
        return rv instanceof List ? (List) rv : Collections.emptyList();
    }

    private static void initJcAnnotatedType(Class<?> context) {
        if (JCANNOTATEDTYPE_FIELDS_INITIALIZED) {
            return;
        }
        JCANNOTATEDTYPE_ANNOTATIONS = Permit.permissiveGetField(context, "annotations");
        JCANNOTATEDTYPE_UNDERLYINGTYPE = Permit.permissiveGetField(context, "underlyingType");
        JCANNOTATEDTYPE_FIELDS_INITIALIZED = true;
    }

    private JavacNode buildTry(JCTree.JCTry tryNode) {
        if (setAndGetAsHandled(tryNode)) {
            return null;
        }
        List<JavacNode> childNodes = new ArrayList<>();
        for (JCTree varDecl : getResourcesForTryNode(tryNode)) {
            if (varDecl instanceof JCTree.JCVariableDecl) {
                addIfNotNull(childNodes, buildLocalVar((JCTree.JCVariableDecl) varDecl, AST.Kind.LOCAL));
            }
        }
        addIfNotNull(childNodes, buildStatement(tryNode.body));
        Iterator it = tryNode.catchers.iterator();
        while (it.hasNext()) {
            JCTree.JCCatch jcc = (JCTree.JCCatch) it.next();
            addIfNotNull(childNodes, buildTree((JCTree) jcc, AST.Kind.STATEMENT));
        }
        addIfNotNull(childNodes, buildStatement(tryNode.finalizer));
        return putInMap(new JavacNode(this, tryNode, childNodes, AST.Kind.STATEMENT));
    }

    private JavacNode buildInitializer(JCTree.JCBlock initializer) {
        if (setAndGetAsHandled(initializer)) {
            return null;
        }
        List<JavacNode> childNodes = new ArrayList<>();
        Iterator it = initializer.stats.iterator();
        while (it.hasNext()) {
            JCTree.JCStatement statement = (JCTree.JCStatement) it.next();
            addIfNotNull(childNodes, buildStatement(statement));
        }
        return putInMap(new JavacNode(this, initializer, childNodes, AST.Kind.INITIALIZER));
    }

    private JavacNode buildMethod(JCTree.JCMethodDecl method) {
        if (setAndGetAsHandled(method)) {
            return null;
        }
        List<JavacNode> childNodes = new ArrayList<>();
        Iterator it = method.mods.annotations.iterator();
        while (it.hasNext()) {
            JCTree.JCAnnotation annotation = (JCTree.JCAnnotation) it.next();
            addIfNotNull(childNodes, buildAnnotation(annotation, false));
        }
        Iterator it2 = method.params.iterator();
        while (it2.hasNext()) {
            JCTree.JCVariableDecl param = (JCTree.JCVariableDecl) it2.next();
            addIfNotNull(childNodes, buildLocalVar(param, AST.Kind.ARGUMENT));
        }
        if (method.body != null && method.body.stats != null) {
            Iterator it3 = method.body.stats.iterator();
            while (it3.hasNext()) {
                JCTree.JCStatement statement = (JCTree.JCStatement) it3.next();
                addIfNotNull(childNodes, buildStatement(statement));
            }
        }
        return putInMap(new JavacNode(this, method, childNodes, AST.Kind.METHOD));
    }

    private JavacNode buildAnnotation(JCTree.JCAnnotation annotation, boolean varDecl) {
        boolean handled = setAndGetAsHandled(annotation);
        if (!varDecl && handled) {
            return null;
        }
        return putInMap(new JavacNode(this, annotation, null, AST.Kind.ANNOTATION));
    }

    private JavacNode buildExpression(JCTree.JCExpression expression) {
        return buildStatementOrExpression(expression);
    }

    private JavacNode buildStatement(JCTree.JCStatement statement) {
        return buildStatementOrExpression(statement);
    }

    private JavacNode buildStatementOrExpression(JCTree statement) {
        if (statement == null || (statement instanceof JCTree.JCAnnotation)) {
            return null;
        }
        if (statement instanceof JCTree.JCClassDecl) {
            return buildType((JCTree.JCClassDecl) statement);
        }
        if (statement instanceof JCTree.JCVariableDecl) {
            return buildLocalVar((JCTree.JCVariableDecl) statement, AST.Kind.LOCAL);
        }
        if (statement instanceof JCTree.JCTry) {
            return buildTry((JCTree.JCTry) statement);
        }
        if (statement.getClass().getName().equals("com.sun.tools.javac.tree.JCTree$JCLambda")) {
            return buildLambda(statement);
        }
        if (setAndGetAsHandled(statement)) {
            return null;
        }
        return drill(statement);
    }

    private JavacNode buildLambda(JCTree jcTree) {
        return buildStatementOrExpression(getBody(jcTree));
    }

    private JCTree getBody(JCTree jcTree) {
        try {
            return (JCTree) getBodyMethod(jcTree.getClass()).invoke(jcTree, new Object[0]);
        } catch (Exception e) {
            throw Javac.sneakyThrow(e);
        }
    }

    private Method getBodyMethod(Class<?> c) {
        Method m = getBodyMethods.get(c);
        if (m != null) {
            return m;
        }
        try {
            getBodyMethods.putIfAbsent(c, Permit.getMethod(c, "getBody", new Class[0]));
            return getBodyMethods.get(c);
        } catch (NoSuchMethodException e) {
            throw Javac.sneakyThrow(e);
        }
    }

    private JavacNode drill(JCTree statement) {
        AST.FieldAccess[] fieldsOf;
        try {
            List<JavacNode> childNodes = new ArrayList<>();
            for (AST.FieldAccess fa : fieldsOf(statement.getClass())) {
                childNodes.addAll(buildWithField(JavacNode.class, statement, fa));
            }
            return putInMap(new JavacNode(this, statement, childNodes, AST.Kind.STATEMENT));
        } catch (OutOfMemoryError oome) {
            String msg = oome.getMessage();
            if (msg == null) {
                msg = "(no original message)";
            }
            OutOfMemoryError newError = new OutOfMemoryError(String.valueOf(getFileName()) + "@pos" + statement.getPreferredPosition() + ": " + msg);
            throw newError;
        }
    }

    private static Collection<Class<? extends JCTree>> statementTypes() {
        Collection<Class<? extends JCTree>> collection = new ArrayList<>(3);
        collection.add(JCTree.JCStatement.class);
        collection.add(JCTree.JCExpression.class);
        collection.add(JCTree.JCCatch.class);
        return collection;
    }

    private static void addIfNotNull(Collection<JavacNode> nodes, JavacNode node) {
        if (node != null) {
            nodes.add(node);
        }
    }

    public void removeDeferredErrors(JavacNode node) {
        JCDiagnostic.DiagnosticPosition pos = node.get().pos();
        JCTree.JCCompilationUnit top = top().get();
        removeFromDeferredDiagnostics(pos.getStartPosition(), Javac.getEndPosition(pos, top));
    }

    public void printMessage(Diagnostic.Kind kind, String message, JavacNode node, JCDiagnostic.DiagnosticPosition pos, boolean attemptToRemoveErrorsInRange) {
        JavaFileObject oldSource = null;
        JCTree astObject = node == null ? null : node.get();
        JCTree.JCCompilationUnit top = top().get();
        JavaFileObject newSource = top.sourcefile;
        if (newSource != null) {
            oldSource = this.log.useSource(newSource);
            if (pos == null) {
                pos = astObject.pos();
            }
        }
        if (pos != null && node != null && attemptToRemoveErrorsInRange) {
            removeFromDeferredDiagnostics(pos.getStartPosition(), node.getEndPosition(pos));
        }
        try {
            switch ($SWITCH_TABLE$javax$tools$Diagnostic$Kind()[kind.ordinal()]) {
                case 1:
                    this.errorLogger.error(pos, message);
                    break;
                case 2:
                    this.errorLogger.warning(pos, message);
                    break;
                case 3:
                    this.errorLogger.mandatoryWarning(pos, message);
                    break;
                case 4:
                default:
                    this.errorLogger.note(pos, message);
                    break;
            }
        } finally {
            if (newSource != null) {
                this.log.useSource(oldSource);
            }
        }
    }

    public void removeFromDeferredDiagnostics(int startPos, int endPos) {
        JCTree.JCCompilationUnit self = top().get();
        new CompilerMessageSuppressor(getContext()).removeAllBetween(self.sourcefile, startPos, endPos);
    }

    protected void setElementInASTCollection2(Field field, Object refField, List<Collection<?>> chain, Collection<?> collection, int idx, JCTree newN) throws IllegalAccessException {
        com.sun.tools.javac.util.List<?> list = setElementInConsList(chain, collection, ((List) collection).get(idx), newN);
        field.set(refField, list);
    }

    private com.sun.tools.javac.util.List<?> setElementInConsList(List<Collection<?>> chain, Collection<?> current, Object oldO, Object newO) {
        com.sun.tools.javac.util.List<?> oldL = (com.sun.tools.javac.util.List) current;
        com.sun.tools.javac.util.List<?> newL = replaceInConsList(oldL, oldO, newO);
        if (chain.isEmpty()) {
            return newL;
        }
        List<Collection<?>> reducedChain = new ArrayList<>(chain);
        Collection<?> newCurrent = reducedChain.remove(reducedChain.size() - 1);
        return setElementInConsList(reducedChain, newCurrent, oldL, newL);
    }

    private com.sun.tools.javac.util.List<?> replaceInConsList(com.sun.tools.javac.util.List<?> oldL, Object oldO, Object newO) {
        boolean repl = false;
        Object[] a = oldL.toArray();
        for (int i = 0; i < a.length; i++) {
            if (a[i] == oldO) {
                a[i] = newO;
                repl = true;
            }
        }
        return repl ? com.sun.tools.javac.util.List.from(a) : oldL;
    }

    public static abstract class ErrorLog {
        final Log log;
        private final Messager messager;
        private final Field errorCount;
        private final Field warningCount;

        abstract void error1(JCDiagnostic.DiagnosticPosition diagnosticPosition, String str);

        abstract void warning1(JCDiagnostic.DiagnosticPosition diagnosticPosition, String str);

        abstract void mandatoryWarning1(JCDiagnostic.DiagnosticPosition diagnosticPosition, String str);

        abstract void note(JCDiagnostic.DiagnosticPosition diagnosticPosition, String str);

        private ErrorLog(Log log, Messager messager, Field errorCount, Field warningCount) {
            this.log = log;
            this.messager = messager;
            this.errorCount = errorCount;
            this.warningCount = warningCount;
        }

        ErrorLog(Log log, Messager messager, Field field, Field field2, ErrorLog errorLog) {
            this(log, messager, field, field2);
        }

        final void error(JCDiagnostic.DiagnosticPosition pos, String message) {
            increment(this.errorCount);
            error1(pos, message);
        }

        final void warning(JCDiagnostic.DiagnosticPosition pos, String message) {
            increment(this.warningCount);
            warning1(pos, message);
        }

        final void mandatoryWarning(JCDiagnostic.DiagnosticPosition pos, String message) {
            increment(this.warningCount);
            mandatoryWarning1(pos, message);
        }

        private void increment(Field field) {
            if (field == null) {
                return;
            }
            try {
                int val = ((Number) field.get(this.messager)).intValue();
                field.set(this.messager, Integer.valueOf(val + 1));
            } catch (Throwable unused) {
            }
        }

        static ErrorLog create(Messager messager, Log log) {
            Field errorCount;
            Field warningCount;
            try {
                errorCount = Permit.getField(messager.getClass(), "errorCount");
            } catch (Throwable unused) {
                errorCount = null;
            }
            boolean hasMultipleErrors = false;
            Field[] fields = log.getClass().getFields();
            int length = fields.length;
            int i = 0;
            while (true) {
                if (i >= length) {
                    break;
                }
                Field field = fields[i];
                if (!field.getName().equals("multipleErrors")) {
                    i++;
                } else {
                    hasMultipleErrors = true;
                    break;
                }
            }
            if (hasMultipleErrors) {
                return new JdkBefore9(log, messager, errorCount, null);
            }
            try {
                warningCount = Permit.getField(messager.getClass(), "warningCount");
            } catch (Throwable unused2) {
                warningCount = null;
            }
            return new Jdk9Plus(log, messager, errorCount, warningCount, null);
        }
    }

    public static class JdkBefore9 extends ErrorLog {
        JdkBefore9(Log log, Messager messager, Field field, JdkBefore9 jdkBefore9) {
            this(log, messager, field);
        }

        private JdkBefore9(Log log, Messager messager, Field errorCount) {
            super(log, messager, errorCount, null, null);
        }

        @Override
        void error1(JCDiagnostic.DiagnosticPosition pos, String message) {
            boolean prev = this.log.multipleErrors;
            this.log.multipleErrors = true;
            try {
                this.log.error(pos, "proc.messager", new Object[]{message});
            } finally {
                this.log.multipleErrors = prev;
            }
        }

        @Override
        void warning1(JCDiagnostic.DiagnosticPosition pos, String message) {
            this.log.warning(pos, "proc.messager", new Object[]{message});
        }

        @Override
        void mandatoryWarning1(JCDiagnostic.DiagnosticPosition pos, String message) {
            this.log.mandatoryWarning(pos, "proc.messager", new Object[]{message});
        }

        @Override
        void note(JCDiagnostic.DiagnosticPosition pos, String message) {
            this.log.note(pos, "proc.messager", new Object[]{message});
        }
    }

    public static class Jdk9Plus extends ErrorLog {
        private static final String PROC_MESSAGER = "proc.messager";
        private Object multiple;
        private Method errorMethod;
        private Method warningMethod;
        private Method mandatoryWarningMethod;
        private Method noteMethod;
        private Method errorKey;
        private Method warningKey;
        private Method noteKey;
        private JCDiagnostic.Factory diags;

        Jdk9Plus(Log log, Messager messager, Field field, Field field2, Jdk9Plus jdk9Plus) {
            this(log, messager, field, field2);
        }

        private Jdk9Plus(Log log, Messager messager, Field errorCount, Field warningCount) {
            super(log, messager, errorCount, warningCount, null);
            Object[] enumConstants;
            try {
                Class<?> df = Class.forName("com.sun.tools.javac.util.JCDiagnostic$DiagnosticFlag");
                for (Object constant : df.getEnumConstants()) {
                    if (constant.toString().equals("MULTIPLE")) {
                        this.multiple = constant;
                    }
                }
                Class<?> errorCls = Class.forName("com.sun.tools.javac.util.JCDiagnostic$Error");
                Class<?> warningCls = Class.forName("com.sun.tools.javac.util.JCDiagnostic$Warning");
                Class<?> noteCls = Class.forName("com.sun.tools.javac.util.JCDiagnostic$Note");
                Class<?> lc = log.getClass();
                this.errorMethod = Permit.getMethod(lc, "error", df, JCDiagnostic.DiagnosticPosition.class, errorCls);
                this.warningMethod = Permit.getMethod(lc, "warning", JCDiagnostic.DiagnosticPosition.class, warningCls);
                this.mandatoryWarningMethod = Permit.getMethod(lc, "mandatoryWarning", JCDiagnostic.DiagnosticPosition.class, warningCls);
                this.noteMethod = Permit.getMethod(lc, "note", JCDiagnostic.DiagnosticPosition.class, noteCls);
                Field diagsField = Permit.getField(lc.getSuperclass(), "diags");
                this.diags = (JCDiagnostic.Factory) diagsField.get(log);
                Class<?> dc = this.diags.getClass();
                this.errorKey = Permit.getMethod(dc, "errorKey", String.class, Object[].class);
                this.warningKey = Permit.getMethod(dc, "warningKey", String.class, Object[].class);
                this.noteKey = Permit.getMethod(dc, "noteKey", String.class, Object[].class);
            } catch (Throwable unused) {
            }
        }

        @Override
        void error1(JCDiagnostic.DiagnosticPosition pos, String message) {
            try {
                Object error = this.errorKey.invoke(this.diags, PROC_MESSAGER, new Object[]{message});
                this.errorMethod.invoke(this.log, this.multiple, pos, error);
            } catch (Throwable unused) {
            }
        }

        @Override
        void warning1(JCDiagnostic.DiagnosticPosition pos, String message) {
            try {
                Object warning = this.warningKey.invoke(this.diags, PROC_MESSAGER, new Object[]{message});
                this.warningMethod.invoke(this.log, pos, warning);
            } catch (Throwable unused) {
            }
        }

        @Override
        void mandatoryWarning1(JCDiagnostic.DiagnosticPosition pos, String message) {
            try {
                Object warning = this.warningKey.invoke(this.diags, PROC_MESSAGER, new Object[]{message});
                this.mandatoryWarningMethod.invoke(this.log, pos, warning);
            } catch (Throwable unused) {
            }
        }

        @Override
        void note(JCDiagnostic.DiagnosticPosition pos, String message) {
            try {
                Object note = this.noteKey.invoke(this.diags, PROC_MESSAGER, new Object[]{message});
                this.noteMethod.invoke(this.log, pos, note);
            } catch (Throwable unused) {
            }
        }
    }
}