ucn 5.5.2 → 5.6.0

package/languages/csharp.js

@@ -560,6 +560,19 @@ function conversionKind(node) {
     return null;
 }
 
+/**
+ * A member a concrete type must supply: declared `abstract`, or an
+ * interface member written without an implementation (a block or an
+ * expression body anywhere in it is a default implementation).
+ */
+function isRequiredMemberNode(node, modifiers) {
+    if (modifiers.includes('abstract')) return true;
+    let owner = node.parent;
+    while (owner && !TYPE_DECLARATIONS.has(owner.type)) owner = owner.parent;
+    if (!owner || owner.type !== 'interface_declaration') return false;
+    return node.descendantsOfType(['block', 'arrow_expression_clause']).length === 0;
+}
+
 function memberFromNode(node, className, lines) {
     if (!METHOD_LIKE_NODES.has(node.type)) return null;
     const nameNode = node.childForFieldName('name');
@@ -625,6 +638,9 @@ function memberFromNode(node, className, lines) {
         isMethod: true,
         isConstructor,
         className,
+        ...(node.type === 'method_declaration' && isRequiredMemberNode(node, modifiers) && {
+            requiredMember: true,
+        }),
         ...(explicitInterface && { explicitInterface }),
         isAsync: modifiers.includes('async'),
         ...(isCSharpIterator(node) && { isGenerator: true }),
@@ -720,6 +736,7 @@ function propertyMember(node, lines) {
         modifiers: modifiersOf(node),
         memberType: 'property',
         fieldType: typeNode?.text || null,
+        ...(isRequiredMemberNode(node, modifiersOf(node)) && { requiredMember: true }),
         ...(explicitInterface && { explicitInterface }),
     };
 }
@@ -2960,6 +2977,621 @@ function usagesInTree(code, name, parser, tree) {
     return usages;
 }
 
+
+const CSHARP_TEST_ATTRIBUTES = new Set(['Fact', 'Theory', 'Test', 'TestCase', 'TestCaseSource',
+    'TestMethod', 'DataTestMethod', 'SkippableFact', 'SkippableTheory']);
+// Attributes whose own arguments can leave a test, or one of its rows, out.
+const CSHARP_ROW_ATTRIBUTES = new Set(['InlineData', 'DataRow', 'TestCase', 'TestCaseSource']);
+// One row of a test's table, written out in the attribute; and what gives
+// rows that are computed when the tests are discovered.
+const CSHARP_WRITTEN_ROWS = new Set(['InlineData', 'DataRow', 'TestCase']);
+const CSHARP_COMPUTED_ROWS = new Set(['MemberData', 'ClassData', 'TestCaseSource', 'DynamicData']);
+// Named arguments of a row that leave it as it is. Any other may leave it out.
+const CSHARP_INERT_ROW_ARGUMENTS = /^(TestName|Description|Category|Author|ExpectedResult|Reason|TypeArgs|TestOf|DisplayName|ArgDisplayNames)$/;
+// Attributes of the test frameworks and of the language that leave what
+// runs alone. Any other attribute on a test or its class may not.
+const CSHARP_INERT_ATTRIBUTES = new Set([...CSHARP_TEST_ATTRIBUTES, ...CSHARP_ROW_ATTRIBUTES,
+    'MemberData', 'ClassData', 'Trait', 'Collection', 'CollectionDefinition', 'Category', 'Description', 'Order',
+    'Timeout', 'MaxTime', 'Repeat', 'Retry', 'Property', 'Author', 'TestOf', 'Values', 'Range', 'ValueSource',
+    'Combinatorial', 'Pairwise', 'Sequential', 'TestFixture', 'SetUp', 'TearDown', 'OneTimeSetUp',
+    'OneTimeTearDown', 'NonParallelizable', 'Parallelizable', 'TestClass', 'TestInitialize', 'TestCleanup',
+    'ClassInitialize', 'ClassCleanup', 'DynamicData', 'TestCategory', 'Priority', 'Owner', 'TestProperty',
+    'DeploymentItem', 'WorkItem', 'DoNotParallelize', 'Obsolete', 'SuppressMessage', 'DebuggerStepThrough',
+    'ExcludeFromCodeCoverage', 'Ignore']);
+
+// The namespaces the test frameworks' own attributes are written under.
+const CSHARP_TEST_NAMESPACES = /^(global::)?(Xunit|NUnit\.Framework|Microsoft\.VisualStudio\.TestTools\.UnitTesting)(\.|$)/;
+// Methods a framework calls before a test, and the names by which one
+// ends the test there without running it.
+const CSHARP_SETUP_ATTRIBUTES = new Set(['SetUp', 'OneTimeSetUp', 'TestInitialize', 'ClassInitialize', 'AssemblyInitialize']);
+const CSHARP_STOPPING_NAMES = /^(Ignore|Inconclusive|Assume|Pass|Skip\w*|IgnoreException|InconclusiveException)$/;
+
+// The predefined types by the types they are keywords for, and whether
+// each is a value type (C# spec, simple types).
+const CSHARP_PREDEFINED_TYPES = {
+    bool: ['System.Boolean', true], byte: ['System.Byte', true], sbyte: ['System.SByte', true],
+    char: ['System.Char', true], decimal: ['System.Decimal', true], double: ['System.Double', true],
+    float: ['System.Single', true], int: ['System.Int32', true], uint: ['System.UInt32', true],
+    nint: ['System.IntPtr', true], nuint: ['System.UIntPtr', true], long: ['System.Int64', true],
+    ulong: ['System.UInt64', true], short: ['System.Int16', true], ushort: ['System.UInt16', true],
+    object: ['System.Object', false], string: ['System.String', false],
+};
+
+/**
+ * A type as it is written, for comparing two methods' parameters: a
+ * predefined type by the type it is a keyword for (`id`), a name with its
+ * qualifier and each part's type arguments (`path`), an array with its
+ * rank, `T?`, a pointer, a tuple by its element types (their names are
+ * no part of it). `dynamic` is object where signatures are compared.
+ */
+function csharpTypeTerm(node, declaresDynamic) {
+    if (!node) return { unread: '' };
+    const inner = each => csharpTypeTerm(each, declaresDynamic);
+    switch (node.type) {
+        case 'predefined_type': {
+            const known = CSHARP_PREDEFINED_TYPES[node.text];
+            return known ? { id: known[0], value: known[1] } : { unread: node.text };
+        }
+        case 'identifier':
+            if (node.text === 'dynamic' && !declaresDynamic) return { id: 'System.Object', value: false };
+            return { path: [{ name: node.text }] };
+        case 'generic_name': {
+            const name = node.namedChildren.find(child => child.type === 'identifier');
+            const list = node.namedChildren.find(child => child.type === 'type_argument_list');
+            return { path: [{ name: name ? name.text : '', args: (list ? list.namedChildren : []).map(inner) }] };
+        }
+        case 'qualified_name': {
+            const left = inner(node.childForFieldName('qualifier'));
+            const right = inner(node.childForFieldName('name'));
+            if (!left.path || !right.path) return { unread: node.text };
+            return { path: [...left.path, ...right.path], ...(left.global && { global: true }) };
+        }
+        case 'alias_qualified_name': {
+            // `global::N.T` is read from the root; another alias is not read.
+            const alias = node.childForFieldName('alias');
+            const name = inner(node.childForFieldName('name'));
+            if (!alias || alias.text !== 'global' || !name.path) return { unread: node.text };
+            return { path: name.path, global: true };
+        }
+        case 'array_type': {
+            const rank = node.childForFieldName('rank');
+            return {
+                array: inner(node.childForFieldName('type')),
+                rank: rank ? rank.children.filter(child => child.type === ',').length + 1 : 1,
+            };
+        }
+        case 'nullable_type':
+            return { nullable: inner(node.childForFieldName('type') || node.namedChildren[0]) };
+        case 'pointer_type':
+            return { pointer: inner(node.childForFieldName('type') || node.namedChildren[0]) };
+        case 'tuple_type':
+            return {
+                tuple: node.namedChildren.filter(child => child.type === 'tuple_element')
+                    .map(element => inner(element.childForFieldName('type') || element.namedChildren[0])),
+            };
+        default:
+            return { unread: node.text };
+    }
+}
+
+/** The names of a declaration's type parameters, in order. */
+function csharpTypeParameters(node) {
+    const list = node.childForFieldName('type_parameters') ||
+        node.namedChildren.find(child => child.type === 'type_parameter_list');
+    return (list ? list.namedChildren : []).filter(child => child.type === 'type_parameter')
+        .map(child => ({ name: (child.childForFieldName('name') || child.namedChildren[child.namedChildCount - 1] || {}).text || '' }));
+}
+
+/**
+ * A method's parameter types as written, each with how it is passed
+ * (`by`: 'ref' for ref and out, 'in' for in and ref readonly: part of the
+ * signature), and the method's type parameters.
+ */
+function csharpSignature(node, declaresDynamic) {
+    const params = [];
+    const list = node.childForFieldName('parameters');
+    for (let i = 0; list && i < list.childCount; i++) {
+        const child = list.child(i);
+        if (child.type === 'parameter') {
+            const modifiers = child.namedChildren.filter(each => each.type === 'modifier').map(each => each.text);
+            const term = csharpTypeTerm(child.childForFieldName('type'), declaresDynamic);
+            const by = modifiers.includes('out') || (modifiers.includes('ref') && !modifiers.includes('readonly')) ? 'ref'
+                : modifiers.includes('in') || modifiers.includes('ref') ? 'in' : null;
+            params.push(by ? { ...term, by } : term);
+        } else if (list.fieldNameForChild(i) === 'type') {
+            // `params T[] rest` stands in the list itself.
+            params.push(csharpTypeTerm(child, declaresDynamic));
+        }
+    }
+    return { params, typeParams: csharpTypeParameters(node) };
+}
+
+/** The types a type declaration derives from, as written. */
+function csharpBases(node, declaresDynamic) {
+    const list = node.namedChildren.find(child => child.type === 'base_list');
+    return (list ? list.namedChildren : []).filter(child => !/comment$/.test(child.type)).map(child => {
+        // `class A(int x) : Base(x)`: the base with the arguments it is built from.
+        const type = child.type === 'primary_constructor_base_type' ? (child.childForFieldName('type') || child.namedChildren[0]) : child;
+        return { written: type.text.replace(/\s+/g, ' ').trim(), term: csharpTypeTerm(type, declaresDynamic) };
+    });
+}
+
+/**
+ * The tests a C# file declares: a method carrying a test attribute of
+ * xUnit, NUnit or MSTest, named by its namespace and the classes around
+ * it. A test of an abstract or generic class is not one by itself: it
+ * runs through the closed types that derive from 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.
+ *
+ * What leaves a test out is read from the attribute's arguments as
+ * syntax: xUnit's Skip is a value, and only a string that is neither null
+ * nor empty skips (null, default, a cast null, an empty string and a
+ * constant of the file holding one of those do not; a constant declared
+ * elsewhere is not read: the test is conditional). [Ignore] skips; with
+ * Until it does so for a time. An attribute that is none of the
+ * frameworks' own may do anything: the test is conditional.
+ *
+ * A test that takes rows runs once for each: where every row written out
+ * is left out by its own arguments the body never executes, and rows that
+ * are computed (MemberData, TestCaseSource, DynamicData), or none at all,
+ * may be none. NUnit also takes rows from attributes on the parameters,
+ * repeats a test ([Repeat]) and builds a fixture once for each
+ * [TestFixture(...)] with arguments, under names that carry the arguments.
+ *
+ * What a class adds holds for the tests it runs, not for a class deriving
+ * from it ([Ignore] on a base class does not reach the derived one:
+ * measured with NUnit and MSTest): a row says what the method's own
+ * attributes say. xUnit takes a test from the nearest declaration that
+ * carries the attribute, so a class that overrides the method without it
+ * runs the test with its own body (`byDeclaration`, `memberRows`); NUnit
+ * and MSTest do not run the override.
+ */
+function testUnits(fileEntry, helpers) {
+    const symbols = fileEntry.symbols || [];
+    const tree = helpers.tree();
+    if (!tree) return null;
+    const units = [];
+    const testsIn = new Map();
+    const declared = new Map();
+    const attributeNames = symbol => (symbol.decorators || [])
+        .map(name => String(name).split('.').pop().replace(/Attribute$/, ''));
+
+    // Attributes as written, by the rows a declaration starts and is named
+    // on; constants of the file, by name and by `Type.Name`.
+    const written = new Map();
+    const parameters = new Map(); // row of a method's name -> its parameters, each with its attributes' names and arguments
+    const constants = new Map();
+    const noteConstant = (key, node) => constants.set(key, constants.has(key) ? null : node);
+    const readAttribute = attribute => {
+        const head = attribute.namedChildren[0];
+        const list = attribute.namedChildren.find(child => child.type === 'attribute_argument_list');
+        return {
+            name: head ? head.text.replace(/<.*$/, '').split('.').pop().replace(/Attribute$/, '') : '',
+            args: (list ? list.namedChildren : []).filter(child => child.type === 'attribute_argument').map(argument => {
+                const inner = argument.namedChildren[argument.namedChildCount - 1];
+                if (inner && inner.type === 'assignment_expression') {
+                    return { name: inner.childForFieldName('left')?.text || null, value: inner.childForFieldName('right') };
+                }
+                return { name: null, value: inner || null };
+            }),
+        };
+    };
+    const visit = (node, owner) => {
+        let inner = owner;
+        if (/_declaration$/.test(node.type)) {
+            const name = node.childForFieldName('name');
+            const lists = node.namedChildren.filter(child => child.type === 'attribute_list');
+            if (name && lists.length > 0) {
+                const attributes = lists.flatMap(list => list.namedChildren.filter(child => child.type === 'attribute'))
+                    .map(readAttribute);
+                written.set(name.startPosition.row, attributes);
+                if (!written.has(node.startPosition.row)) written.set(node.startPosition.row, attributes);
+            }
+            if (name && node.type === 'method_declaration') {
+                const list = node.childForFieldName('parameters');
+                parameters.set(name.startPosition.row, (list ? list.namedChildren : [])
+                    .filter(child => child.type === 'parameter')
+                    .map(parameter => parameter.namedChildren.filter(child => child.type === 'attribute_list')
+                        .flatMap(each => each.namedChildren.filter(child => child.type === 'attribute')).map(readAttribute)));
+            }
+            if (name && /^(class|struct|record|interface)_declaration$/.test(node.type)) inner = name.text;
+            if (node.type === 'field_declaration' &&
+                node.namedChildren.some(child => child.type === 'modifier' && child.text === 'const')) {
+                const declaration = node.namedChildren.find(child => child.type === 'variable_declaration');
+                for (const declarator of declaration ? declaration.namedChildren : []) {
+                    if (declarator.type !== 'variable_declarator' || declarator.namedChildCount < 2) continue;
+                    const value = declarator.namedChildren[declarator.namedChildCount - 1];
+                    noteConstant(declarator.namedChildren[0].text, value);
+                    if (owner) noteConstant(`${owner}.${declarator.namedChildren[0].text}`, value);
+                }
+            }
+        }
+        for (const child of node.namedChildren) visit(child, inner);
+    };
+    visit(tree.rootNode, null);
+    // 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();
+    // `using N = T;`: the alias with what it is written to stand for, by
+    // the line of the directive.
+    const aliasNodes = [];
+    const noteDeclarations = node => {
+        const name = /_declaration$/.test(node.type) ? node.childForFieldName('name') : null;
+        if (node.type === 'using_directive' && node.childForFieldName('name')) aliasNodes.push(node);
+        const into = !name ? null : node.type === 'method_declaration' ? methodNodes
+            : /^(class|struct|record|record_struct|interface)_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);
+    };
+    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;
+    };
+    // A type the project declares under the name `dynamic` is that type.
+    const declaresDynamic = !!helpers.declaresType && helpers.declaresType('dynamic');
+    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 ? csharpSignature(node, declaresDynamic)
+                : { params: (symbol.paramsStructured || []).length === 0 ? [] : null, typeParams: [] };
+            signatureMemo.set(symbol, {
+                params: read.params,
+                ...(read.typeParams.length > 0 && { typeParams: read.typeParams }),
+                ...((symbol.modifiers || []).includes('override') && { overrides: true }),
+            });
+        }
+        return signatureMemo.get(symbol);
+    };
+    // What a string-typed constant expression holds: 'null', 'empty',
+    // 'text', or null when it is not read here.
+    const textOf = (node, owner, depth = 0) => {
+        if (!node || depth > 6) return null;
+        switch (node.type) {
+            case 'null_literal': case 'default_expression': return 'null';
+            case 'string_literal': return node.text === '""' ? 'empty' : 'text';
+            case 'verbatim_string_literal': return node.text === '@""' ? 'empty' : 'text';
+            case 'raw_string_literal': return 'text';
+            case 'parenthesized_expression': return textOf(node.namedChildren[0], owner, depth + 1);
+            case 'cast_expression': return textOf(node.namedChildren[node.namedChildCount - 1], owner, depth + 1);
+            case 'invocation_expression':
+                // nameof(...) is the name: a string that is not empty.
+                return node.namedChildren[0] && node.namedChildren[0].text === 'nameof' ? 'text' : null;
+            case 'binary_expression': {
+                if (!node.children.some(child => child.type === '+')) return null;
+                const left = textOf(node.namedChildren[0], owner, depth + 1);
+                const right = textOf(node.namedChildren[node.namedChildCount - 1], owner, depth + 1);
+                if (left === 'text' || right === 'text') return 'text';
+                return left && right ? 'empty' : null;
+            }
+            case 'identifier': {
+                const held = constants.get(`${owner}.${node.text}`) || (owner ? null : constants.get(node.text));
+                return held ? textOf(held, owner, depth + 1) : null;
+            }
+            case 'member_access_expression': {
+                const held = constants.get(node.text.replace(/\s+/g, '').split('.').slice(-2).join('.'));
+                return held ? textOf(held, owner, depth + 1) : null;
+            }
+            default: return null;
+        }
+    };
+    const attributesOf = symbol => written.get((symbol.nameLine || symbol.startLine) - 1) ||
+        written.get(symbol.startLine - 1) || [];
+    /** 'skip', 'sometimes' or null: what a declaration's attributes do to its tests. */
+    const stateOf = (symbol, owner) => {
+        let answer = null;
+        const weaker = () => {
+            if (answer !== 'skip') answer = 'sometimes';
+        };
+        const attributes = attributesOf(symbol);
+        const makers = attributes.filter(attribute => CSHARP_TEST_ATTRIBUTES.has(attribute.name)).length;
+        for (const attribute of attributes) {
+            if (attribute.name === 'Ignore') {
+                // [Ignore("...", Until = "...")] ignores for a time.
+                if (attribute.args.some(argument => argument.name === 'Until')) weaker();
+                else answer = 'skip';
+                continue;
+            }
+            if (!CSHARP_INERT_ATTRIBUTES.has(attribute.name)) {
+                weaker();
+                continue;
+            }
+            // A row's own arguments are read with the table it is part of.
+            if (CSHARP_WRITTEN_ROWS.has(attribute.name)) continue;
+            for (const argument of attribute.args) {
+                if (!argument.name) continue;
+                if (/^(Skip|Ignore|IgnoreReason|IgnoreMessage)$/.test(argument.name)) {
+                    const held = textOf(argument.value, owner);
+                    if (held === 'text' && makers <= 1 && !CSHARP_ROW_ATTRIBUTES.has(attribute.name)) answer = 'skip';
+                    // Only xUnit's Skip takes null or an empty string and runs.
+                    else if (held === 'text' || held == null || argument.name !== 'Skip') weaker();
+                } else if (/^(Explicit|SkipUnless|SkipWhen|SkipType|SkipExceptions)$/.test(argument.name)) {
+                    weaker();
+                }
+            }
+        }
+        return answer;
+    };
+    /**
+     * What the rows of a test leave of it: `skip` ('skip': no row runs the
+     * body; 'sometimes': one may run it), and whether the declaration
+     * stands for several of the runner's tests.
+     */
+    const tableOf = (symbol, owner, kinds) => {
+        const attributes = attributesOf(symbol);
+        const rows = attributes.filter(attribute => CSHARP_WRITTEN_ROWS.has(attribute.name));
+        const computed = attributes.some(attribute => CSHARP_COMPUTED_ROWS.has(attribute.name));
+        const taken = parameters.get((symbol.nameLine || symbol.startLine) - 1) || [];
+        const repeated = attributes.some(attribute => attribute.name === 'Repeat');
+        if (rows.length > 0) {
+            const states = rows.map(row => {
+                let state = 'run';
+                for (const argument of row.args) {
+                    if (!argument.name || CSHARP_INERT_ROW_ARGUMENTS.test(argument.name)) continue;
+                    if (/^(Skip|Ignore|IgnoreReason|IgnoreMessage)$/.test(argument.name)) {
+                        const held = textOf(argument.value, owner);
+                        if (held === 'text') state = 'skip';
+                        // Only xUnit's Skip takes null or an empty string and runs.
+                        else if (held == null || argument.name !== 'Skip') state = state === 'skip' ? 'skip' : 'sometimes';
+                    } else if (state !== 'skip') {
+                        // Explicit, a platform, anything this does not read.
+                        state = 'sometimes';
+                    }
+                }
+                return state;
+            });
+            const skip = states.includes('run') ? null
+                : states.every(state => state === 'skip') && !computed ? 'skip' : 'sometimes';
+            return { skip, several: true };
+        }
+        if (computed) return { skip: 'sometimes', several: true };
+        if (kinds.some(name => /Theory$/.test(name) || name === 'DataTestMethod') || taken.length > 0) {
+            // NUnit takes rows from its parameters' own attributes: a
+            // list written out, a range.
+            const given = taken.length > 0 && taken.every(each => each.some(attribute =>
+                (attribute.name === 'Values' && attribute.args.length > 0) || attribute.name === 'Range'));
+            return { skip: given ? null : 'sometimes', several: true };
+        }
+        return { skip: null, several: repeated };
+    };
+    // NUnit builds a fixture once for each [TestFixture(...)] that has
+    // arguments and for each row of a [TestFixtureSource]: its tests run
+    // under names that carry the arguments.
+    const fixtureRows = cls => attributesOf(cls).some(attribute => attribute.name === 'TestFixtureSource' ||
+        (attribute.name === 'TestFixture' && attribute.args.some(argument => !argument.name)));
+    const concrete = cls => cls.type !== 'interface' && !(cls.modifiers || []).includes('abstract') &&
+        !(Array.isArray(cls.generics) ? cls.generics.length > 0 : !!cls.generics) &&
+        !(cls.typeParameters && cls.typeParameters.length > 0);
+    // An attribute class of the project that derives from a framework's
+    // test attribute declares a test too ([RetryFact] : FactAttribute).
+    const derivedMemo = new Map();
+    const derivedTest = name => {
+        if (!derivedMemo.has(name)) {
+            const above = [...helpers.ancestors(`${name}Attribute`), ...helpers.ancestors(name)]
+                .map(base => String(base).split('.').pop().replace(/Attribute$/, ''));
+            derivedMemo.set(name, above.find(base => CSHARP_TEST_ATTRIBUTES.has(base)) || null);
+        }
+        return derivedMemo.get(name);
+    };
+    // Is an attribute written with one of the frameworks' names a class
+    // of the project instead: one written under another namespace, or
+    // declared in the namespace the test stands in or one around it
+    // (which comes before what a using brings), or brought by a using
+    // where no framework's namespace is used.
+    const ofTheProject = (written, symbol) => {
+        const parts = String(written).split('.');
+        const simple = parts.pop().replace(/Attribute$/, '');
+        const declared = helpers.typesNamed ? [...helpers.typesNamed(`${simple}Attribute`), ...helpers.typesNamed(simple)] : [];
+        if (declared.length === 0) return false;
+        if (parts.length > 0) return !CSHARP_TEST_NAMESPACES.test(parts.join('.'));
+        const here = symbol.namespace || '';
+        if (declared.some(type => type.namespace === here || type.namespace === '' || here.startsWith(`${type.namespace}.`))) return true;
+        const usings = (fileEntry.imports || []).map(String);
+        return declared.some(type => usings.includes(type.namespace)) && !usings.some(name => CSHARP_TEST_NAMESPACES.test(name));
+    };
+    // A setup method of a class (or, for xUnit, its constructor) whose
+    // body can end the test before it runs.
+    // Read over the lines of the method, whatever shape the tree gives
+    // them (a declaration split by #if is no single node): a stopping
+    // name or a throw anywhere on them.
+    const stopsOn = (first, last) => {
+        // A throw inside a lambda or a local function 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) && CSHARP_STOPPING_NAMES.test(node.text)) ||
+                ((node.type === 'throw_statement' || node.type === 'throw_expression') && !nested))) return true;
+            const deeper = nested || (inside && (node.type === 'lambda_expression' ||
+                node.type === 'anonymous_method_expression' || node.type === 'local_function_statement'));
+            return node.namedChildren.some(child => visit(child, deeper));
+        };
+        return visit(tree.rootNode, false);
+    };
+    const guardMemo = new Map();
+    const guarded = cls => {
+        if (!guardMemo.has(cls)) {
+            guardMemo.set(cls, symbols.some(symbol => symbol.className === cls.name &&
+                symbol.startLine >= cls.startLine && (symbol.endLine ?? symbol.startLine) <= (cls.endLine ?? cls.startLine) &&
+                (symbol.type === 'constructor' || symbol.name === 'InitializeAsync' ||
+                    attributeNames(symbol).some(name => CSHARP_SETUP_ATTRIBUTES.has(name))) &&
+                stopsOn(symbol.startLine - 1, (symbol.endLine ?? symbol.startLine) - 1)));
+        }
+        return guardMemo.get(cls);
+    };
+    for (const symbol of symbols) {
+        if (!symbol.isMethod || symbol.type === 'constructor') continue;
+        const attributes = (symbol.decorators || []).flatMap(written => {
+            const name = String(written).split('.').pop().replace(/Attribute$/, '');
+            if (CSHARP_TEST_ATTRIBUTES.has(name) && ofTheProject(written, symbol)) {
+                // A class of the project under a framework's name: a test
+                // attribute only where it derives from one.
+                const base = derivedTest(name);
+                return base ? [`${name} (of the project)`, base] : [`${name} (of the project)`];
+            }
+            return CSHARP_TEST_ATTRIBUTES.has(name) || !derivedTest(name) ? [name] : [name, derivedTest(name)];
+        });
+        if (!attributes.some(name => CSHARP_TEST_ATTRIBUTES.has(name))) continue;
+        const chain = helpers.enclosing(symbol).filter(outer => outer.type !== 'namespace');
+        if (chain.length === 0 || chain.some(outer => !helpers.isContainer(outer))) continue;
+        // xUnit runs a test method of any visibility; NUnit and MSTest
+        // discover public ones only, and MSTest also wants the class marked.
+        const xunit = attributes.some(name => /^(Fact|SkippableFact|SkippableTheory)$/.test(name)) ||
+            (fileEntry.imports || []).some(name => /^Xunit(\.|$)/.test(String(name)));
+        if (!xunit && !(symbol.modifiers || []).includes('public')) continue;
+        // A static method (measured with each): xUnit runs it, in its
+        // class and in every class deriving from it; NUnit runs it in its
+        // own class only; MSTest does not run it.
+        const isStatic = (symbol.modifiers || []).includes('static');
+        // MSTest wants the class that runs a test marked [TestClass]: the
+        // class the method stands in for a test of its own, the deriving
+        // class for one it inherits (measured: the mark is not inherited,
+        // and the base needs none).
+        const mstest = attributes.some(name => name === 'TestMethod' || name === 'DataTestMethod');
+        if (mstest && isStatic) continue;
+        const owner = chain[chain.length - 1];
+        const unmarked = mstest && !attributeNames(owner).includes('TestClass');
+        // What the method's own attributes and rows say, and what the
+        // classes it stands in add for a test of theirs.
+        const table = tableOf(symbol, owner.name, attributes);
+        const own = [stateOf(symbol, owner.name), table.skip];
+        const around = chain.map((cls, i) => stateOf(cls, i > 0 ? chain[i - 1].name : null));
+        const states = [...own, ...around];
+        const sometimes = states.includes('sometimes') || chain.some(guarded);
+        const generated = chain.some(fixtureRows);
+        const row = {
+            name: symbol.name, line: symbol.nameLine || symbol.startLine,
+            startLine: symbol.startLine, endLine: symbol.endLine ?? symbol.startLine,
+            ...(states.includes('skip') && { skipped: true }),
+            ...(!states.includes('skip') && sometimes && { conditional: true }),
+            // One declaration the runner reports as several tests: a
+            // theory, a method given rows of data, a repeated one.
+            ...((table.several || attributes.some(name => /Theory$/.test(name) || name === 'DataTestMethod' ||
+                CSHARP_ROW_ATTRIBUTES.has(name))) && { several: true }),
+            ...(generated && { dynamic: 'generated-cases' }),
+        };
+        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, and what then hides the inherited test (measured with
+            // each): MSTest takes one method of each name; NUnit leaves
+            // the test only to a declared override of its signature. The
+            // parameter types are carried as written (`params`): what
+            // their names denote is resolved where two methods are compared.
+            ...signatureOf(symbol), hiddenBy: mstest ? 'name' : xunit ? 'signature' : 'override',
+            ...row, skipped: own.includes('skip') || undefined,
+            conditional: (!own.includes('skip') && sometimes) || undefined, dynamic: undefined,
+            // xUnit takes the test from the nearest declaration that
+            // carries the attribute, whatever a class nearer overrides.
+            ...(xunit && { byDeclaration: true }),
+            ...(mstest && { needsClassMark: true }),
+            // MSTest reports an inherited test again under a test of its
+            // name that hides it by `new` (measured), with that test's body.
+            ...(mstest && { againUnderHiding: true }),
+            ...(!xunit && isStatic && { ownOnly: true }),
+        });
+        if (unmarked || chain.some(cls => !concrete(cls))) continue;
+        for (const cls of chain) testsIn.set(cls, (testsIn.get(cls) || 0) + 1);
+        units.push({
+            kind: 'test', suite: chain.map(cls => cls.name), ...row,
+            ...(symbol.namespace && { namespace: symbol.namespace }),
+        });
+    }
+    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) || cls.type === 'namespace') continue;
+        const chain = helpers.enclosing(cls).filter(outer => outer.type !== 'namespace');
+        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 ? csharpBases(header, declaresDynamic) : 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 ? csharpTypeParameters(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 }),
+            // Only the first base written can be a class: the others are
+            // interfaces, whose members are no test of the class.
+            plainBases: bases.slice(1),
+            runnable: [...chain, cls].every(concrete),
+            ...([...chain, cls].some(each => stateOf(each, null) === 'skip') && { skipped: true }),
+            ...([...chain, cls].some(each => stateOf(each, null) === 'sometimes') && { sometimes: true }),
+            ...([...chain, cls].some(guarded) && { guard: true }),
+            ...(cls.namespace && { namespace: cls.namespace }),
+            line: cls.nameLine || cls.startLine, startLine: cls.startLine, endLine: cls.endLine ?? cls.startLine,
+            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,
+            })),
+            ...([...chain, cls].some(fixtureRows) && { several: true, dynamic: 'generated-cases' }),
+            ...(attributeNames(cls).includes('TestClass') && { marked: 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,
+            });
+        }
+    }
+    const aliases = aliasNodes.map(node => {
+        const name = node.childForFieldName('name');
+        const target = node.namedChildren.filter(child => !sameNode(child, name)).pop();
+        return { name: name.text, line: node.startPosition.row + 1, term: csharpTypeTerm(target, declaresDynamic) };
+    });
+    return { units, classes, ...(aliases.length > 0 && { aliases }) };
+}
+
+/**
+ * Can this file hold test code, from what the index keeps of it, with no
+ * tree read? `marked`: one of its declarations carries an attribute that
+ * can make a test (one of the frameworks', or one whose class the project
+ * declares, which may derive from one). `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 written of symbol.decorators || []) {
+            const name = String(written).replace(/<.*$/, '').split('.').pop().replace(/Attribute$/, '');
+            if (CSHARP_TEST_ATTRIBUTES.has(name) || projectDeclaresType(name) || projectDeclaresType(`${name}Attribute`)) 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) bases.add(name);
+        }
+    }
+    return { marked, bases: [...bases] };
+}
+
 function getEntryPointKind(symbol) {
     const decorators = new Set(symbol.decorators || []);
     if (symbol.name === 'Main' && symbol.modifiers?.includes('static')) return 'main';
@@ -3164,5 +3796,7 @@ module.exports = {
     isPlatformConcreteCall,
     isEntryPoint,
     getEntryPointKind,
+    testUnits,
+    testCodeGate,
     parse,
 };