ucn 5.5.3 → 5.6.1

package/languages/java.js

@@ -972,6 +972,9 @@ function extractClassMembers(classNode, codeOrLines) {
                     memberType,
                     modifiers,
                     isMethod: true,  // Mark as method for context() lookups
+                    // Abstract by keyword or by being a bodiless interface
+                    // method: a concrete subtype must supply it.
+                    ...(modifiers.includes('abstract') && { requiredMember: true }),
                     ...(returnType && { returnType }),
                     ...(docstring && { docstring }),
                     ...(annotationsWithArgs.length > 0 && { annotationsWithArgs }),
@@ -2874,6 +2877,713 @@ function findUsagesInCode(code, name, parser, tree) {
     return usages;
 }
 
+
+const JAVA_TEST_ANNOTATIONS = new Set(['Test', 'ParameterizedTest', 'RepeatedTest', 'TestFactory', 'TestTemplate']);
+// The packages the test frameworks' own annotations are written under.
+const JAVA_TEST_PACKAGES = /^(org\.junit|junit|org\.testng)(\.|$)/;
+// Methods a framework calls before a test, and the names by which one
+// stops the test there (an assumption that fails aborts it).
+const JAVA_SETUP_ANNOTATIONS = new Set(['BeforeEach', 'BeforeAll', 'Before', 'BeforeClass', 'BeforeMethod', 'BeforeSuite']);
+const JAVA_STOPPING_NAMES = /^(assum\w*|Assum\w*|abort|TestAbortedException|AssumptionViolatedException|SkipException)$/;
+// Annotations of JUnit and of the language that leave what runs alone.
+// Any other on a test or its class may disable it (a condition of
+// JUnit's, an extension, an annotation of the project that carries one).
+// What gives a @ParameterizedTest its rows: written out in the annotation,
+// or computed when the test runs.
+const JAVA_WRITTEN_SOURCES = new Set(['ValueSource', 'CsvSource', 'EnumSource', 'NullSource', 'EmptySource', 'NullAndEmptySource']);
+const JAVA_COMPUTED_SOURCES = new Set(['MethodSource', 'FieldSource', 'ArgumentsSource', 'ArgumentsSources', 'CsvFileSource']);
+// Members of TestNG's @Test that leave what runs alone. `enabled`,
+// `invocationCount` and the data provider are read; any other may not.
+const TESTNG_INERT_MEMBERS = new Set(['description', 'priority', 'timeOut', 'invocationTimeOut', 'expectedExceptions',
+    'expectedExceptionsMessageRegExp', 'groups', 'alwaysRun', 'singleThreaded', 'threadPoolSize', 'successPercentage',
+    'testName', 'suiteName', 'retryAnalyzer', 'skipFailedInvocations', 'ignoreMissingDependencies', 'attributes']);
+// Annotations under which TestNG calls a method that is no test.
+const TESTNG_CONFIGURATION = /^(Before|After)(Suite|Test|Groups|Class|Method)$|^(DataProvider|Factory|Parameters|Listeners)$/;
+const JAVA_INERT_ANNOTATIONS = new Set([...JAVA_TEST_ANNOTATIONS, 'DisplayName', 'DisplayNameGeneration', 'Tag',
+    'Tags', 'Order', 'Timeout', 'TestMethodOrder', 'TestClassOrder', 'TestInstance', 'Nested', 'BeforeEach',
+    'AfterEach', 'BeforeAll', 'AfterAll', 'Before', 'After', 'BeforeClass', 'AfterClass', 'ValueSource',
+    'CsvSource', 'CsvFileSource', 'MethodSource', 'EnumSource', 'NullSource', 'EmptySource', 'NullAndEmptySource',
+    'ArgumentsSource', 'FieldSource', 'Override', 'SuppressWarnings', 'Deprecated', 'SafeVarargs',
+    'FunctionalInterface', 'Execution', 'ResourceLock', 'Isolated', 'FixMethodOrder', 'Disabled', 'Ignore',
+    'Retention', 'Target', 'Documented', 'Inherited', 'Repeatable']);
+
+const javaDimensions = node => (node ? node.children.filter(child => child.type === '[').length : 0);
+
+/**
+ * A type as it is written, for comparing two methods' parameters: a
+ * primitive (`id`), a name with its qualifier (`path`), an array. Type
+ * arguments are left out: two methods are the same member when their
+ * signatures are the same after erasure (JLS 8.4.2).
+ */
+function javaTypeTerm(node) {
+    if (!node) return { unread: '' };
+    switch (node.type) {
+        case 'integral_type': case 'floating_point_type': case 'boolean_type': case 'void_type':
+            return { id: node.text };
+        case 'type_identifier':
+            return { path: [{ name: node.text }] };
+        case 'scoped_type_identifier': {
+            const path = [];
+            for (const child of node.namedChildren) {
+                if (/annotation$/.test(child.type)) continue;
+                const inner = javaTypeTerm(child);
+                if (!inner.path) return { unread: node.text };
+                path.push(...inner.path);
+            }
+            return { path };
+        }
+        case 'generic_type':
+            return {
+                ...javaTypeTerm(node.namedChildren.find(child => child.type !== 'type_arguments' && !/annotation$/.test(child.type))),
+                parameterized: true,
+            };
+        case 'annotated_type':
+            return javaTypeTerm(node.namedChildren.filter(child => !/annotation$/.test(child.type)).pop());
+        case 'array_type': {
+            let term = javaTypeTerm(node.childForFieldName('element'));
+            for (let i = javaDimensions(node.childForFieldName('dimensions')); i > 0; i--) term = { array: term, rank: 1 };
+            return term;
+        }
+        default:
+            return { unread: node.text };
+    }
+}
+
+/** A method's parameter types and its own type parameters (each with its first bound), as written. */
+function javaSignature(node) {
+    const params = [];
+    const list = node.childForFieldName('parameters');
+    for (const child of list ? list.namedChildren : []) {
+        if (child.type === 'formal_parameter') {
+            let term = javaTypeTerm(child.childForFieldName('type'));
+            // `int a[]`: the brackets after the name are part of the type.
+            for (let i = javaDimensions(child.childForFieldName('dimensions')); i > 0; i--) term = { array: term, rank: 1 };
+            params.push(term);
+        } else if (child.type === 'spread_parameter') {
+            // `T... rest` is `T[] rest` where signatures are compared.
+            const type = child.namedChildren.find(each => each.type !== 'modifiers' && each.type !== 'variable_declarator');
+            params.push({ array: javaTypeTerm(type), rank: 1 });
+        } else if (child.type !== 'receiver_parameter' && !/comment$/.test(child.type)) {
+            params.push({ unread: child.text });
+        }
+    }
+    return { params, typeParams: javaTypeParameters(node), returns: javaTypeTerm(node.childForFieldName('type')) };
+}
+
+function javaTypeParameters(node) {
+    const out = [];
+    const list = node.childForFieldName('type_parameters');
+    for (const child of list ? list.namedChildren : []) {
+        if (child.type !== 'type_parameter') continue;
+        const name = child.namedChildren.find(each => each.type === 'type_identifier' || each.type === 'identifier');
+        const bound = child.namedChildren.find(each => each.type === 'type_bound');
+        const first = bound && bound.namedChildren.find(each => !/annotation$/.test(each.type));
+        out.push({ name: name ? name.text : '', ...(first && { bound: javaTypeTerm(first) }) });
+    }
+    return out;
+}
+
+/** The types a type declaration derives from, as written: the superclass, then the interfaces. */
+function javaBases(node) {
+    const out = [];
+    const take = each => {
+        if (each.type === 'type_list' || each.type === 'superclass' || each.type === 'super_interfaces' ||
+            each.type === 'extends_interfaces') {
+            for (const child of each.namedChildren) take(child);
+        } else if (!/comment$/.test(each.type)) {
+            out.push({ written: each.text.replace(/\s+/g, ' ').trim(), term: javaTypeTerm(each) });
+        }
+    };
+    for (const child of node.namedChildren) {
+        if (child.type === 'superclass' || child.type === 'super_interfaces' || child.type === 'extends_interfaces') take(child);
+    }
+    return out;
+}
+
+/**
+ * The tests a Java file declares: a method annotated as a test (JUnit 4
+ * and 5, TestNG), or a public "test"-prefixed method of a class deriving
+ * from TestCase (JUnit 3), named by its package and the classes around it.
+ * A test of an abstract class or an interface is not one by itself: it
+ * runs through the types that inherit it. `classes` says, for every type,
+ * what it derives from and which tests it declares, so the tests a
+ * concrete class inherits can be found.
+ *
+ * Which framework an annotation is of is read from where it is imported
+ * from, because the three differ (measured with each):
+ * - A class that overrides a method without the annotation: JUnit 5 no
+ *   longer runs it as a test; JUnit 4 and TestNG run the test the nearest
+ *   annotated declaration makes, with the body the class has
+ *   (`byDeclaration`, `memberRows`). An override is a method of the same
+ *   signature: one of the same name with other parameters is another
+ *   method, and the inherited test runs as it stands. Each row carries
+ *   its parameters' types as they are written (`params`); what the names
+ *   in them denote is resolved where two methods are compared.
+ * - A method's modifiers: TestNG runs a marked method of any visibility
+ *   and a static one, and lets a deriving class replace a test only
+ *   where the language lets it override the method (`sealed`,
+ *   `sealedOutside`); JUnit 5 runs neither a private nor a static one;
+ *   JUnit 4 refuses the whole class for one marked method that is not
+ *   public or is static (`refused`).
+ * - @Disabled and @Ignore on a class hold for that class and the classes
+ *   inside it, not for a class that derives from it: a row says what the
+ *   method's own annotations say, a class what its own do.
+ * - A @ParameterizedTest runs once for each row its sources give: none
+ *   written (no source, an empty array) and the body never executes; rows
+ *   that are computed may be none. TestNG's @Test says the same by
+ *   `enabled`, `invocationCount` and a data provider, and on a class makes
+ *   every public method a test.
+ */
+function testUnits(fileEntry, helpers) {
+    const symbols = fileEntry.symbols || [];
+    const units = [];
+    const testsIn = new Map();
+    const declared = new Map();
+    const concrete = cls => cls.type !== 'interface' && !(cls.modifiers || []).includes('abstract');
+    // The annotations on a declaration, an annotation the project declares
+    // standing for the ones it carries itself (JUnit's composed
+    // annotations): @Flaky declared with @Disabled disables.
+    // Is an annotation written with one of the frameworks' names a type
+    // of the project instead: one written under another package, imported
+    // by name from one, or declared in the package of the file (which
+    // comes before anything an import of a whole package brings).
+    const ofTheProject = (written, symbol) => {
+        const parts = String(written).split('.');
+        const simple = parts.pop();
+        const declared = helpers.typesNamed ? helpers.typesNamed(simple) : [];
+        if (declared.length === 0) return false;
+        if (parts.length > 0) return !JAVA_TEST_PACKAGES.test(parts.join('.'));
+        const byName = (fileEntry.imports || []).map(String).find(name => name.endsWith(`.${simple}`));
+        if (byName) return !JAVA_TEST_PACKAGES.test(byName);
+        return declared.some(type => type.namespace === (symbol.namespace || ''));
+    };
+    const annotationMemo = new Map();
+    const annotationsOf = symbol => {
+        if (annotationMemo.has(symbol)) return annotationMemo.get(symbol);
+        const out = new Set();
+        const seen = new Set();
+        const add = (name, depth) => {
+            const meta = depth < 4 && !seen.has(name) && helpers.metaAnnotations ? helpers.metaAnnotations(name) : null;
+            if (!meta) {
+                out.add(name);
+                return;
+            }
+            seen.add(name);
+            for (const inner of meta) add(inner, depth + 1);
+        };
+        for (const annotation of symbol.annotationsWithArgs || []) {
+            const name = String(annotation.name).split('.').pop();
+            // @RunWith(JUnit4.class) names the runner JUnit uses anyway.
+            if (name === 'RunWith' && /^(org\.junit\.runners\.)?(JUnit4|BlockJUnit4ClassRunner)\.class$/.test(String(annotation.args || '').trim())) continue;
+            if (JAVA_INERT_ANNOTATIONS.has(name) || JAVA_SETUP_ANNOTATIONS.has(name)) {
+                // One of the frameworks' names: theirs by where it comes
+                // from, never by the spelling.
+                if (!ofTheProject(annotation.name, symbol)) {
+                    out.add(name);
+                    continue;
+                }
+                const meta = helpers.metaAnnotations ? helpers.metaAnnotations(name) : null;
+                if (meta) for (const inner of meta) add(inner, 1);
+                else out.add(`${name} (of the project)`);
+                continue;
+            }
+            add(name, 0);
+        }
+        annotationMemo.set(symbol, out);
+        return out;
+    };
+    // A setup method of a class whose body can stop the test (it names an
+    // assumption, an abort): the class's tests run only sometimes.
+    const tree = helpers.tree();
+    // The annotations of a declaration as they are written, by the row its
+    // name stands on: each with its members' values as syntax.
+    const writtenAt = new Map();
+    const noteAnnotations = node => {
+        if (/_declaration$/.test(node.type)) {
+            const name = node.childForFieldName('name');
+            const modifiers = node.namedChildren.find(child => child.type === 'modifiers');
+            if (name && modifiers) {
+                const rows = [name.startPosition.row, node.startPosition.row].filter(row => !writtenAt.has(row));
+                const read = modifiers.namedChildren
+                    .filter(child => child.type === 'annotation' || child.type === 'marker_annotation')
+                    .map(annotation => {
+                        const members = new Map();
+                        const list = annotation.childForFieldName('arguments');
+                        for (const argument of list ? list.namedChildren : []) {
+                            if (argument.type === 'element_value_pair') {
+                                members.set(argument.childForFieldName('key')?.text, argument.childForFieldName('value'));
+                            } else if (argument.type !== 'line_comment' && argument.type !== 'block_comment') {
+                                members.set('value', argument);
+                            }
+                        }
+                        return { name: String(annotation.childForFieldName('name')?.text || '').split('.').pop(), members };
+                    });
+                for (const row of rows) writtenAt.set(row, read);
+            }
+        }
+        for (const child of node.namedChildren) noteAnnotations(child);
+    };
+    if (tree) noteAnnotations(tree.rootNode);
+    // Each method's and each type's declaration, by the rows it starts
+    // and is named on: its parameter types and its bases are read as
+    // they are written.
+    const methodNodes = new Map();
+    const typeNodes = new Map();
+    const noteDeclarations = node => {
+        const name = /_declaration$/.test(node.type) ? node.childForFieldName('name') : null;
+        const into = !name ? null : node.type === 'method_declaration' ? methodNodes
+            : /^(class|interface|enum|record|annotation_type)_declaration$/.test(node.type) ? typeNodes : null;
+        if (into) {
+            for (const row of new Set([name.startPosition.row, node.startPosition.row])) {
+                const key = `${row}:${name.text}`;
+                if (!into.has(key)) into.set(key, []);
+                into.get(key).push(node);
+            }
+        }
+        for (const child of node.namedChildren) noteDeclarations(child);
+    };
+    if (tree) noteDeclarations(tree.rootNode);
+    const nodeOf = (nodes, symbol) => {
+        const found = nodes.get(`${(symbol.nameLine || symbol.startLine) - 1}:${symbol.name}`) ||
+            nodes.get(`${symbol.startLine - 1}:${symbol.name}`) || [];
+        // Several of one name on one row: the one that starts where the symbol does.
+        return (symbol.sourceSpan && found.find(node => node.startIndex === symbol.sourceSpan.start)) || found[0] || null;
+    };
+    const signatureMemo = new Map();
+    /** What a deriving class's method is compared by: the parameter types as written, the method's type parameters, a declared override. */
+    const signatureOf = symbol => {
+        if (!signatureMemo.has(symbol)) {
+            const node = nodeOf(methodNodes, symbol);
+            const read = node ? javaSignature(node)
+                : { params: (symbol.paramsStructured || []).length === 0 ? [] : null, typeParams: [] };
+            const overrides = (symbol.annotationsWithArgs || []).some(annotation =>
+                String(annotation.name).split('.').pop() === 'Override' && !ofTheProject(annotation.name, symbol));
+            // A type parameter in scope: the method's own, or one of a
+            // class the method stands in.
+            const variables = new Set(read.typeParams.map(each => each.name));
+            for (const cls of helpers.enclosing(symbol)) {
+                const header = nodeOf(typeNodes, cls);
+                for (const each of header ? javaTypeParameters(header) : []) variables.add(each.name);
+            }
+            const variable = term => !!term && !!term.path && term.path.length === 1 && variables.has(term.path[0].name);
+            // What reflection calls a generic type of a parameter: a type
+            // variable, or an array of one or of a type with arguments.
+            const generic = term => variable(term) ||
+                (!!term && !!term.array && (generic(term.array) || !!term.array.parameterized));
+            signatureMemo.set(symbol, {
+                params: read.params,
+                ...(read.typeParams.length > 0 && { typeParams: read.typeParams }),
+                ...(overrides && { overrides: true }),
+                ...((!read.params || read.params.some(generic) || variable(read.returns)) && { generic: true }),
+            });
+        }
+        return signatureMemo.get(symbol);
+    };
+    const written = symbol => writtenAt.get((symbol.nameLine || symbol.startLine) - 1) ||
+        writtenAt.get(symbol.startLine - 1) || [];
+    /** The annotation of a declaration written under one of the names, or null. */
+    const writtenAs = (symbol, names) => written(symbol).find(annotation => names.has(annotation.name)) || null;
+    const literalInt = node => node && /^(decimal|hex|octal|binary)_integer_literal$/.test(node.type)
+        ? Number(node.text.replace(/_/g, '').replace(/[lL]$/, '')) : null;
+    const emptyArray = node => !!node && node.type === 'element_value_array_initializer' &&
+        node.namedChildren.filter(child => !/comment$/.test(child.type)).length === 0;
+    // Which framework an annotation written with one of the shared names
+    // is of: by its own qualifier, the import that names it, or the one
+    // package imported whole.
+    const imports = (fileEntry.imports || []).map(String);
+    const packageKind = name => /^org\.junit\.jupiter(\.|$)/.test(name) ? 'junit5'
+        : /^org\.testng(\.|$)/.test(name) ? 'testng' : /^(org\.junit|junit)(\.|$)/.test(name) ? 'junit4' : null;
+    const frameworkOf = writtenName => {
+        const text = String(writtenName);
+        const simple = text.split('.').pop();
+        const named = text.includes('.') ? text : imports.find(name => name.endsWith(`.${simple}`));
+        if (named) return packageKind(named);
+        const whole = new Set(imports.filter(name => name.endsWith('.*')).map(name => packageKind(name.slice(0, -2))).filter(Boolean));
+        return whole.size === 1 ? [...whole][0] : null;
+    };
+    const frameworkMemo = new Map();
+    /** The framework of the declaration's own test annotation ('junit4', 'junit5', 'testng'), or null. */
+    const testFramework = symbol => {
+        if (!frameworkMemo.has(symbol)) {
+            const own = (symbol.annotationsWithArgs || []).find(annotation => String(annotation.name).split('.').pop() === 'Test');
+            frameworkMemo.set(symbol, own ? frameworkOf(own.name) : null);
+        }
+        return frameworkMemo.get(symbol);
+    };
+    /**
+     * What TestNG's @Test on a declaration says: 'skip' (enabled = false,
+     * no invocation), 'sometimes' (a member that is not read, a data
+     * provider, a dependency), `several` (more than one invocation).
+     */
+    const testngState = symbol => {
+        const answer = { skip: null, several: false };
+        const test = testFramework(symbol) === 'testng' ? writtenAs(symbol, new Set(['Test'])) : null;
+        if (!test) return answer;
+        const weaker = () => {
+            if (answer.skip !== 'skip') answer.skip = 'sometimes';
+        };
+        for (const [member, value] of test.members) {
+            if (member === 'enabled') {
+                if (value.type === 'false') answer.skip = 'skip';
+                else if (value.type !== 'true') weaker();
+            } else if (member === 'invocationCount') {
+                const count = literalInt(value);
+                if (count === 0) answer.skip = 'skip';
+                else if (count == null) weaker();
+                if (count !== 1) answer.several = true;
+            } else if (member === 'dataProvider' || member === 'dataProviderClass') {
+                // Rows computed when the test runs: there may be none.
+                weaker();
+                answer.several = true;
+            } else if (!TESTNG_INERT_MEMBERS.has(member)) {
+                weaker();
+            }
+        }
+        return answer;
+    };
+    /**
+     * What the sources of a JUnit 5 test with parameters leave of it:
+     * 'skip' (none gives a row: the runner reports an error and the body
+     * never executes), 'sometimes' (rows computed at run time), or null.
+     */
+    const sourcesState = symbol => {
+        const names = annotationsOf(symbol);
+        if (names.has('RepeatedTest')) {
+            const repeated = writtenAs(symbol, new Set(['RepeatedTest']));
+            const count = repeated ? literalInt(repeated.members.get('value')) : null;
+            return count == null ? 'sometimes' : count <= 0 ? 'skip' : null;
+        }
+        if (!names.has('ParameterizedTest')) return null;
+        let computed = false;
+        for (const annotation of written(symbol)) {
+            if (JAVA_COMPUTED_SOURCES.has(annotation.name)) computed = true;
+            if (!JAVA_WRITTEN_SOURCES.has(annotation.name)) continue;
+            if (annotation.name === 'EnumSource') {
+                // Every constant of the type, unless names or a mode choose among them.
+                if ([...annotation.members.keys()].every(member => member === 'value')) return null;
+                computed = true;
+            } else if (annotation.name === 'ValueSource' || annotation.name === 'CsvSource') {
+                const values = [...annotation.members.entries()].filter(([member]) =>
+                    annotation.name === 'ValueSource' || member === 'value' || member === 'textBlock');
+                if (values.some(([, value]) => !emptyArray(value))) return null;
+            } else {
+                return null;
+            }
+        }
+        // A source this does not see written on the method: one carried
+        // by an annotation of the project, or an annotation that is none
+        // of JUnit's and may be a source. Read as computed.
+        if (!computed && [...names].some(name => !JAVA_INERT_ANNOTATIONS.has(name) ||
+            ((JAVA_WRITTEN_SOURCES.has(name) || JAVA_COMPUTED_SOURCES.has(name)) &&
+                !written(symbol).some(annotation => annotation.name === name)))) computed = true;
+        return computed ? 'sometimes' : 'skip';
+    };
+    // @Disabled (JUnit 5) and @Ignore (JUnit 4, TestNG): declared, not executed.
+    const disabled = symbol => annotationsOf(symbol).has('Disabled') || annotationsOf(symbol).has('Ignore');
+    // An annotation that is not one of those: the test may not run.
+    const unsettled = symbol => [...annotationsOf(symbol)].some(name => !JAVA_INERT_ANNOTATIONS.has(name));
+    // A method's own: what its test annotation's members and its sources add.
+    const methodOff = symbol => disabled(symbol) || testngState(symbol).skip === 'skip' || sourcesState(symbol) === 'skip';
+    const methodUnsettled = symbol => unsettled(symbol) || testngState(symbol).skip === 'sometimes' ||
+        sourcesState(symbol) === 'sometimes';
+    // A runner named on the class that is not JUnit 4's own decides how
+    // often a test runs (one with a table runs it once for each row).
+    const otherRunner = cls => annotationsOf(cls).has('RunWith');
+    // Read over the lines of the method, whatever shape the tree gives
+    // them: a stopping name or a throw anywhere on them.
+    const stopsOn = (first, last) => {
+        // A throw inside a lambda or a class written in the method is not
+        // the method's own.
+        const visit = (node, nested) => {
+            if (node.endPosition.row < first || node.startPosition.row > last) return false;
+            const inside = node.startPosition.row >= first && node.endPosition.row <= last;
+            if (inside && ((/identifier$/.test(node.type) && JAVA_STOPPING_NAMES.test(node.text)) ||
+                (node.type === 'throw_statement' && !nested))) return true;
+            const deeper = nested || (inside && (node.type === 'lambda_expression' || node.type === 'class_body'));
+            return node.namedChildren.some(child => visit(child, deeper));
+        };
+        return !tree || visit(tree.rootNode, false);
+    };
+    const guardMemo = new Map();
+    const guarded = cls => {
+        if (!guardMemo.has(cls)) {
+            guardMemo.set(cls, symbols.some(symbol => symbol.isMethod && symbol.className === cls.name &&
+                symbol.startLine >= cls.startLine && (symbol.endLine ?? symbol.startLine) <= (cls.endLine ?? cls.startLine) &&
+                [...annotationsOf(symbol)].some(name => JAVA_SETUP_ANNOTATIONS.has(name)) &&
+                stopsOn(symbol.startLine - 1, (symbol.endLine ?? symbol.startLine) - 1)));
+        }
+        return guardMemo.get(cls);
+    };
+    const legacyMemo = new Map();
+    const legacy = cls => {
+        if (!legacyMemo.has(cls)) {
+            // JUnit's own TestCase: a class of that name the project
+            // declares itself is not it.
+            const names = [...String(cls.extends || '').split(','), ...helpers.ancestors(cls.name)];
+            legacyMemo.set(cls, names.some(name => /(^|\.)TestCase$/.test(String(name).trim().replace(/<.*$/, '')) &&
+                !helpers.declaresType(name)));
+        }
+        return legacyMemo.get(cls);
+    };
+    // TestNG's @Test on a class: every public method of it is a test,
+    // unless the annotation switches the class's tests off.
+    const classTestMemo = new Map();
+    const classTest = cls => {
+        if (!classTestMemo.has(cls)) {
+            const own = annotationsOf(cls).has('Test') && testFramework(cls) === 'testng';
+            classTestMemo.set(cls, own ? (testngState(cls).skip === 'skip' ? 'off' : 'on') : null);
+        }
+        return classTestMemo.get(cls);
+    };
+    const testngIgnored = cls => (cls.annotationsWithArgs || []).some(annotation =>
+        String(annotation.name).split('.').pop() === 'Ignore' && frameworkOf(annotation.name) === 'testng');
+    // A method TestNG takes as a test under a @Test on its class or on a
+    // class that one derives from: public (a static one too: measured),
+    // and none of TestNG's own setup.
+    const classCandidate = symbol => (symbol.modifiers || []).includes('public') &&
+        ![...annotationsOf(symbol)].some(name => TESTNG_CONFIGURATION.test(name) || JAVA_TEST_ANNOTATIONS.has(name));
+    // Classes JUnit 4 refuses whole (see below), and classes it may.
+    const refused = new Set();
+    const maybeRefused = new Set();
+    const ownerOf = new Map();
+    // Is the runner that takes a class JUnit 4's own? 'own': no @RunWith
+    // on the class, the classes around it, or a class it derives from
+    // (the annotation is inherited). 'other': one of them names a runner,
+    // which has rules of its own. 'unknown': a type it derives from is
+    // not read.
+    const runnerMemo = new Map();
+    const junit4Runner = (cls, chain) => {
+        if (!runnerMemo.has(cls)) {
+            let answer = [...chain, cls].some(otherRunner) ? 'other' : 'own';
+            for (const name of answer === 'own' ? helpers.ancestors(cls.name) : []) {
+                const carried = helpers.metaAnnotations ? helpers.metaAnnotations(name) : null;
+                if (!carried) answer = 'unknown';
+                else if (carried.includes('RunWith')) {
+                    answer = 'other';
+                    break;
+                }
+            }
+            runnerMemo.set(cls, answer);
+        }
+        return runnerMemo.get(cls);
+    };
+    for (const symbol of symbols) {
+        if (!symbol.isMethod || symbol.type === 'constructor') continue;
+        const chain = helpers.enclosing(symbol);
+        if (chain.length === 0 || chain.some(outer => !helpers.isContainer(outer))) continue;
+        const owner = chain[chain.length - 1];
+        const annotated = [...annotationsOf(symbol)].some(name => JAVA_TEST_ANNOTATIONS.has(name));
+        const byClass = !annotated && classTest(owner) === 'on' && classCandidate(symbol);
+        if (!annotated && !byClass && !(legacy(owner) && /^test/.test(symbol.name) &&
+            (symbol.modifiers || []).includes('public'))) continue;
+        const framework = byClass ? 'testng' : testFramework(symbol);
+        // What a method's modifiers do to its mark is each framework's
+        // rule (measured with each):
+        // - TestNG runs a method that carries its mark whatever its
+        //   visibility, and a static one.
+        // - JUnit 5 runs neither a private nor a static method, and runs
+        //   the other tests of the class.
+        // - JUnit 4 wants every method marked @Test public and not
+        //   static: one that is not makes its runner refuse the class,
+        //   and no test of the class runs, its own or inherited, in the
+        //   class and in every class deriving from it. Another runner
+        //   (named on the class or on one it derives from) has rules of
+        //   its own, which are not read: the method is listed as it
+        //   always was, a test that runs only sometimes.
+        const modifiers = symbol.modifiers || [];
+        const fixed = modifiers.includes('private') || modifiers.includes('static');
+        // What the method takes and gives back decides too (measured):
+        // - JUnit 4 wants a marked method without parameters and without
+        //   a result, and refuses the class for one that has either;
+        //   JUnit 3 takes neither as a test.
+        // - JUnit 5 does not run a method that gives a result back (a
+        //   @TestFactory has to); a parameter of a plain @Test needs
+        //   something that supplies it, which is not read.
+        // - TestNG runs a method with parameters through a data provider
+        //   or its suite's parameters, and one with a result only where
+        //   its suite allows it: neither is read.
+        const takes = (signatureOf(symbol).params || symbol.paramsStructured || []).length > 0;
+        const gives = !!symbol.returnType && String(symbol.returnType).trim() !== 'void';
+        const names = annotationsOf(symbol);
+        const plain = names.has('Test') && ![...names].some(name => JAVA_TEST_ANNOTATIONS.has(name) && name !== 'Test');
+        // A shape JUnit 4's own runner does not accept.
+        const odd = framework === 'junit4' && annotated && (fixed || !modifiers.includes('public') || takes || gives);
+        const runner = odd ? junit4Runner(owner, chain.slice(0, -1)) : null;
+        if (runner === 'own') {
+            refused.add(owner);
+            continue;
+        }
+        if (runner === 'unknown') maybeRefused.add(owner);
+        if (!annotated && !byClass && (takes || gives)) continue;
+        if (fixed && framework !== 'testng') continue;
+        // A mark only JUnit 5 has, or its @Test.
+        const jupiter = framework === 'junit5' || (annotated && !plain);
+        if (gives && jupiter && !names.has('TestFactory')) continue;
+        const unsupplied = framework === 'testng'
+            ? gives || (takes && !written(symbol).some(annotation => annotation.name === 'Test' &&
+                (annotation.members.has('dataProvider') || annotation.members.has('dataProviderClass'))))
+            : odd || (plain && (takes || gives));
+        // What the method's own annotations say, and what the classes it
+        // stands in add for a test of theirs.
+        const ownOff = methodOff(symbol);
+        const off = ownOff || chain.some(disabled);
+        const sometimes = methodUnsettled(symbol) || unsupplied || chain.some(unsettled) || chain.some(guarded) ||
+            (byClass && testngState(owner).skip === 'sometimes');
+        const several = [...annotationsOf(symbol)].some(name => JAVA_TEST_ANNOTATIONS.has(name) && name !== 'Test') ||
+            testngState(symbol).several || (byClass && testngState(owner).several) || chain.some(otherRunner);
+        const row = {
+            name: symbol.name, line: symbol.nameLine || symbol.startLine,
+            startLine: symbol.startLine, endLine: symbol.endLine ?? symbol.startLine, sourceSpan: symbol.sourceSpan,
+            ...(off && { skipped: true }),
+            ...(!off && sometimes && { conditional: true }),
+            // One declaration the runner reports as several tests.
+            ...(several && { several: true }),
+        };
+        if (!declared.has(owner)) declared.set(owner, []);
+        // For a class that inherits the test: the classes around this one
+        // are not around that one.
+        declared.get(owner).push({
+            // The method a deriving class has to redeclare to be the same one.
+            ...signatureOf(symbol), hiddenBy: 'signature',
+            // JUnit 5 decides by reflection, which does not say what a type
+            // parameter stands for: a method whose parameter or result is
+            // one is taken as replaced by any method of its name a nearer
+            // class declares whose parameters could be passed to it
+            // (measured: an overload removes the inherited test).
+            ...(framework !== 'junit4' && framework !== 'testng' && signatureOf(symbol).generic && { replacedByAssignable: true }),
+            // TestNG's @Ignore on a class reaches the classes deriving from it (measured).
+            ...row, skipped: ownOff || (framework === 'testng' && chain.some(testngIgnored)) || undefined,
+            conditional: (!ownOff && sometimes) || undefined,
+            // JUnit 4 and TestNG take the test from the nearest annotated
+            // declaration, whatever a class nearer redeclares without one.
+            ...((framework === 'junit4' || framework === 'testng') && annotated && { byDeclaration: true }),
+            // Maven's filter does not find a TestNG test by the name of a
+            // class that inherits it (measured): no command names it there.
+            ...(framework === 'testng' && { inheritedDynamic: 'declared-in-a-base-class' }),
+            // TestNG follows the language: a method a deriving class
+            // cannot override keeps its own body whatever that class
+            // declares under its signature (measured): a private or a
+            // static one always, one without a visibility for a class of
+            // another package.
+            ...(framework === 'testng' && fixed && { sealed: true }),
+            ...(framework === 'testng' && !fixed && !modifiers.includes('public') && !modifiers.includes('protected') &&
+                { sealedOutside: symbol.namespace || '' }),
+        });
+        if (chain.some(cls => !concrete(cls))) continue;
+        // A class inside another runs with it only when marked @Nested. A
+        // static one is a test class of its own that a build's default
+        // class-name filter leaves out; an inner one is no test class.
+        const unmarked = chain.slice(1).filter(cls => !(cls.annotationsWithArgs || [])
+            .some(annotation => String(annotation.name).split('.').pop() === 'Nested'));
+        if (unmarked.some(cls => !(cls.modifiers || []).includes('static'))) continue;
+        for (const cls of chain) testsIn.set(cls, (testsIn.get(cls) || 0) + 1);
+        const unit = {
+            kind: 'test', suite: chain.map(cls => cls.name), ...row,
+            ...(symbol.namespace && { namespace: symbol.namespace }),
+            ...(unmarked.length > 0 && { conditional: true, notInEveryBuild: true }),
+        };
+        units.push(unit);
+        ownerOf.set(unit, owner);
+    }
+    // A class JUnit 4 may refuse (a marked method its own runner does not
+    // accept, under a runner that is not read): every test of the class
+    // runs only sometimes, the ones declared before that method too.
+    for (const [unit, owner] of ownerOf) {
+        if (maybeRefused.has(owner) && !unit.skipped) unit.conditional = true;
+    }
+    for (const owner of maybeRefused) {
+        for (const test of declared.get(owner) || []) {
+            if (!test.skipped) test.conditional = true;
+        }
+    }
+    const classes = [];
+    const methodsOf = cls => symbols.filter(symbol => symbol.isMethod && symbol.className === cls.name &&
+        symbol.startLine >= cls.startLine && (symbol.endLine ?? symbol.startLine) <= (cls.endLine ?? cls.startLine));
+    for (const cls of symbols) {
+        if (!helpers.isContainer(cls)) continue;
+        const chain = helpers.enclosing(cls);
+        if (chain.some(outer => !helpers.isContainer(outer))) continue;
+        // The bases as the declaration writes them; without its node, as
+        // the symbol records them.
+        const header = nodeOf(typeNodes, cls);
+        const derived = header ? javaBases(header) : null;
+        const bases = derived ? derived.map(each => each.written)
+            : [cls.extends, cls.implements].flat().filter(Boolean)
+                .flatMap(value => String(value).split(',')).map(name => name.trim()).filter(Boolean);
+        const typeParams = header ? javaTypeParameters(header).map(each => each.name) : [];
+        classes.push({
+            name: cls.name, suite: chain.map(outer => outer.name), bases,
+            // What each base denotes is resolved by the language's lookup.
+            ...(derived && { baseTerms: derived.map(each => each.term) }),
+            ...(typeParams.length > 0 && { typeParams }),
+            // JUnit's TestCase brings no test of its own.
+            plainBases: bases.filter(name => /(^|\.)TestCase$/.test(name.replace(/<.*$/, '')) && !helpers.declaresType(name)),
+            runnable: [...chain, cls].every(concrete),
+            ...([...chain, cls].some(disabled) && { skipped: true }),
+            ...(([...chain, cls].some(unsettled) || maybeRefused.has(cls)) && { sometimes: true }),
+            ...([...chain, cls].some(guarded) && { guard: true }),
+            // A class its runner refuses runs none of its tests, and
+            // neither does a class deriving from it; one that names a
+            // runner of its own is taken by that runner's rules.
+            ...(refused.has(cls) && { refused: true }),
+            ...(maybeRefused.has(cls) && { mayRefuse: true }),
+            ...([...chain, cls].some(otherRunner) && { runner: true }),
+            ...(cls.namespace && { namespace: cls.namespace }),
+            line: cls.nameLine || cls.startLine, startLine: cls.startLine, endLine: cls.endLine ?? cls.startLine, sourceSpan: cls.sourceSpan,
+            members: methodsOf(cls).map(symbol => symbol.name),
+            // Where each method's body stands, for a test it gives the body to.
+            memberRows: methodsOf(cls).map(symbol => ({
+                name: symbol.name, ...signatureOf(symbol), line: symbol.nameLine || symbol.startLine,
+                startLine: symbol.startLine, endLine: symbol.endLine ?? symbol.startLine, sourceSpan: symbol.sourceSpan,
+                ...(symbol.type !== 'constructor' && classCandidate(symbol) && { candidate: true }),
+            })),
+            // TestNG's @Test on the class makes its public methods tests,
+            // and those of the classes deriving from it (measured); the
+            // public methods it inherits itself are tests this does not list.
+            ...(classTest(cls) === 'on' && { classMark: true }),
+            ...(classTest(cls) === 'on' && bases.length > 0 && { open: true }),
+            tests: declared.get(cls) || [],
+        });
+        if (testsIn.get(cls) > 0) {
+            units.push({
+                kind: 'suite', name: cls.name, suite: chain.map(outer => outer.name),
+                line: cls.nameLine || cls.startLine, startLine: cls.startLine,
+                endLine: cls.endLine ?? cls.startLine, sourceSpan: cls.sourceSpan,
+            });
+        }
+    }
+    return { units, classes, ...(classes.some(cls => cls.open && cls.runnable) && { inheriting: true }) };
+}
+
+/**
+ * Can this file hold test code, from what the index keeps of it, with no
+ * tree read? `marked`: one of its declarations carries a mark that can
+ * make a test (one of the frameworks' annotations, or an annotation the
+ * project declares itself, which may stand for one), or one of its classes
+ * derives from a type named TestCase (JUnit 3). `bases`: the names of the
+ * types its classes derive from: a class of the project among them may
+ * bring tests, and that is asked of its own file. A file that is neither
+ * marked nor derives from one that is declares no test and holds the
+ * body of none.
+ */
+function testCodeGate(fileEntry, projectDeclaresType) {
+    let marked = false;
+    const bases = new Set();
+    for (const symbol of fileEntry.symbols || []) {
+        for (const annotation of symbol.annotationsWithArgs || []) {
+            const name = String(annotation.name).split('.').pop();
+            if (JAVA_TEST_ANNOTATIONS.has(name) || projectDeclaresType(name)) marked = true;
+        }
+        for (const written of [symbol.extends, symbol.implements].flat().filter(Boolean).flatMap(value => String(value).split(','))) {
+            const name = written.replace(/<.*$/, '').trim().split('.').pop().trim();
+            if (!name) continue;
+            if (/TestCase$/.test(name)) marked = true;
+            bases.add(name);
+        }
+    }
+    return { marked, bases: [...bases] };
+}
+
 /**
  * Classify a Java symbol as a runtime entry point of a specific kind.
  * Returns 'test' | 'main' | 'framework' | null.
@@ -2927,5 +3637,7 @@ module.exports = {
     findUsagesInCode,
     isEntryPoint,
     getEntryPointKind,
+    testUnits,
+    testCodeGate,
     parse
 };