[Bug]: Under multithreading, using the isOverriding method will lead to incorrect results of the getElements method

[honghao12]

Describe the bug

Under multithreading, using the isOverriding method will lead to incorrect results of the getElements(new TypeFilter<>(CtExecutableReference.class)) method;
This bug is sporadic, executed multiple times and only shows up sometimes

Source code you are trying to analyze/transform

https://github.com/apache/tomcat/blob/main/java/org/apache/jasper/compiler/Node.java

Source code for your Spoon processing

import com.google.common.collect.Lists;
import spoon.Launcher;
import spoon.reflect.CtModel;
import spoon.reflect.declaration.CtMethod;
import spoon.reflect.declaration.CtType;
import spoon.reflect.reference.CtExecutableReference;
import spoon.reflect.reference.CtTypeReference;
import spoon.reflect.visitor.filter.TypeFilter;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.CompletableFuture;

public class Test1 {
    public static void main(String[] args) {
        Launcher launcher = new Launcher();
        launcher.getEnvironment().setComplianceLevel(14);
        launcher.getEnvironment().setAutoImports(true);
        launcher.getEnvironment().setIgnoreDuplicateDeclarations(true);
        launcher.addInputResource("tomcat-main\\java\\org\\apache\\jasper\\compiler\\Node.java");
        CtModel model = launcher.buildModel();

        List<CompletableFuture<Void>> futureList = new ArrayList<>();
        List<CtMethod> ctMethodList = model.getElements(new TypeFilter<>(CtMethod.class));
        List<List<CtMethod>> ctMethodPartLists = Lists.partition(ctMethodList, 10);
        for (List<CtMethod> sublist : ctMethodPartLists) {
            futureList.add(CompletableFuture.runAsync(() -> {
                for (CtMethod ctMethod : sublist) {
                    List<CtExecutableReference<?>> ctExecutableReferenceList = ctMethod.getElements(
                        new TypeFilter<>(CtExecutableReference.class));
                    String name = ctMethod.getPath().toString();
                    if("#subPackage[name=org]#subPackage[name=apache]#subPackage[name=jasper]#subPackage[name=compiler]#containedType[name=Node]#nestedType[name=Visitor]#method[signature=visit(org.apache.jasper.compiler.Node$AttributeDirective)]".equals(name)) {
                         if(1 != ctExecutableReferenceList.size()){
                            System.out.println(name + " expect:" + 1 + " actual:" + ctExecutableReferenceList.size());
                        } else {
                            System.out.println(name + " expect:" + 1 + " actual:" + ctExecutableReferenceList.size());
                        }
                    }

                    CtType<?> srcType = ctMethod.getDeclaringType();
                    CtTypeReference<?> superclassReference = srcType.getSuperclass();
                    if (Objects.nonNull(superclassReference)) {
                        CtType<?> superclass = superclassReference.getTypeDeclaration();
                        if (Objects.nonNull(superclass)) {
                            Set<CtMethod<?>> dstMethods = superclass.getMethods();
                            for (CtMethod<?> dstMethod : dstMethods) {
                                //In multithreading, using the isOverriding method causes ctMethod.getElements(new TypeFilter<>(CtExecutableReference.class)) is not correct
                                if (ctMethod.isOverriding(dstMethod)) {

                                }
                            }
                        }
                    }
                }
            }));
        }

        CompletableFuture<Void> allFutures = CompletableFuture.allOf(futureList.toArray(CompletableFuture[]::new));
        allFutures.join();
    }
}

Actual output

ctExecutableReference size expect:1 actual:0

Expected output

ctExecutableReference size expect:1 actual:1

Spoon Version

10.4.3-beta-2

JVM Version

11

What operating system are you using?

win