ucn 5.5.3 → 5.6.1

package/languages/go.js

@@ -719,6 +719,9 @@ function extractInterfaceMembers(interfaceNode, codeOrLines) {
                         endLine,
                         sourceSpan,
                         memberType: 'method',
+                        // An interface method element is a requirement of
+                        // every type used as the interface.
+                        requiredMember: true,
                         ...(paramsText !== null && { params: paramsText }),
                         ...(paramsNode && { paramsStructured: parseStructuredParams(paramsNode, 'go') }),
                         ...(returnType && { returnType })
@@ -3841,6 +3844,121 @@ function selectorReceiverIsLocal(tree, line, column) {
     return !!scope && typeof scope !== 'string';
 }
 
+
+/**
+ * The tests a Go file declares, as "go test" finds them: in a _test.go
+ * file, a function (never a method) named Test or Fuzz followed by nothing
+ * or by a rune that is not lower case; TestMain is the harness, not a
+ * test; an Example runs only when its body ends in an output comment. A
+ * Benchmark runs only when asked for, so it is not one of the tests.
+ */
+/**
+ * Does a Go test file hold a TestMain that may keep the package's tests
+ * from running. A TestMain decides nothing when the first statement of
+ * its body that can end it or run the tests is a plain statement holding
+ * `m.Run()` (`os.Exit(m.Run())`, `code := m.Run()`): nothing before it
+ * returns or exits. One that exits or returns in a branch first, never
+ * calls Run, or hands `m` to something else, decides.
+ */
+function testGate(fileEntry, helpers) {
+    if (!/_test\.go$/.test(fileEntry.relativePath)) return false;
+    if (!(fileEntry.symbols || []).some(symbol => symbol.name === 'TestMain' && !symbol.className)) return false;
+    const tree = helpers.tree();
+    if (!tree) return true;
+    const main = tree.rootNode.namedChildren.find(node => node.type === 'function_declaration' &&
+        node.childForFieldName('name')?.text === 'TestMain');
+    if (!main) return true;
+    const body = main.childForFieldName('body');
+    const list = main.childForFieldName('parameters');
+    const first = list && list.namedChildren[0];
+    const handle = first && first.childForFieldName('name') ? first.childForFieldName('name').text : null;
+    if (!body || !handle) return true;
+    const calls = (node, test) => (node.type === 'call_expression' && test(node)) || node.namedChildren.some(child => calls(child, test));
+    const runs = node => {
+        const callee = node.childForFieldName('function');
+        return !!callee && callee.type === 'selector_expression' && callee.childForFieldName('operand')?.text === handle &&
+            callee.childForFieldName('field')?.text === 'Run';
+    };
+    const ends = node => {
+        const callee = node.childForFieldName('function');
+        const text = callee ? callee.text : '';
+        const args = node.childForFieldName('arguments');
+        return /^(os\.Exit|panic|runtime\.Goexit|log\.(Fatal|Fatalf|Fatalln|Panic|Panicf|Panicln))$/.test(text) ||
+            (args ? args.namedChildren : []).some(argument => argument.type === 'identifier' && argument.text === handle);
+    };
+    const returns = node => node.type === 'return_statement' || (node.type !== 'func_literal' && node.namedChildren.some(returns));
+    const statements = body.namedChildren.filter(node => node.type !== 'comment');
+    for (const statement of statements.length === 1 && statements[0].type === 'statement_list' ? statements[0].namedChildren : statements) {
+        if (statement.type === 'comment') continue;
+        const running = calls(statement, runs);
+        if (!running && !calls(statement, ends) && !returns(statement)) continue;
+        const plain = ['expression_statement', 'short_var_declaration', 'assignment_statement', 'var_declaration'].includes(statement.type);
+        return !(running && plain && !calls(statement, node => !runs(node) && ends(node) && !/^os\.Exit$/.test(node.childForFieldName('function')?.text || '')));
+    }
+    return true;
+}
+
+/**
+ * Does an Example function end in an output comment? go runs an example
+ * only then. The comment is a comment of the function's body (vet insists
+ * it is the last one): text inside a string is not one.
+ */
+function exampleHasOutput(tree, symbol) {
+    if (!tree) return false;
+    const line = (symbol.nameLine || symbol.startLine) - 1;
+    const declaration = tree.rootNode.namedChildren.find(node => node.type === 'function_declaration' &&
+        node.startPosition.row <= line && node.endPosition.row >= line &&
+        node.childForFieldName('name')?.text === symbol.name);
+    const body = declaration && declaration.childForFieldName('body');
+    if (!body) return false;
+    let found = false;
+    const scan = node => {
+        if (found) return;
+        if (node.type === 'comment') {
+            const text = node.text.replace(/^\/\/|^\/\*/, '');
+            if (/^\s*(unordered )?output:/i.test(text)) found = true;
+            return;
+        }
+        for (const child of node.namedChildren) scan(child);
+    };
+    scan(body);
+    return found;
+}
+
+const GO_PLATFORM_WORDS = new Set(['aix', 'android', 'darwin', 'dragonfly', 'freebsd', 'hurd', 'illumos', 'ios',
+    'js', 'linux', 'nacl', 'netbsd', 'openbsd', 'plan9', 'solaris', 'wasip1', 'windows', 'zos',
+    '386', 'amd64', 'amd64p32', 'arm', 'armbe', 'arm64', 'arm64be', 'loong64', 'mips', 'mipsle', 'mips64',
+    'mips64le', 'mips64p32', 'mips64p32le', 'ppc', 'ppc64', 'ppc64le', 'riscv', 'riscv64', 's390', 's390x',
+    'sparc', 'sparc64', 'wasm']);
+
+function testUnits(fileEntry, helpers) {
+    if (!/_test\.go$/.test(fileEntry.relativePath)) return { units: [], inheriting: false, complete: true };
+    // name_GOOS_test.go, name_GOARCH_test.go, name_GOOS_GOARCH_test.go
+    const words = fileEntry.relativePath.split('/').pop().replace(/_test\.go$/, '').split('_').slice(1);
+    const platform = words.length > 0 && GO_PLATFORM_WORDS.has(words[words.length - 1]);
+    const units = [];
+    for (const symbol of fileEntry.symbols || []) {
+        if (symbol.type !== 'function' || symbol.isMethod || symbol.receiver || symbol.className) continue;
+        const match = /^(Test|Fuzz|Example)([\s\S]*)$/.exec(symbol.name);
+        if (!match) continue;
+        const first = match[2] ? String.fromCodePoint(match[2].codePointAt(0)) : '';
+        if (first && first.toLowerCase() === first && first.toUpperCase() !== first) continue;
+        if (symbol.name === 'TestMain' && /testing\s*\.\s*M\b/.test(String(symbol.params || ''))) continue;
+        if (helpers.enclosing(symbol).length > 0) continue;
+        const form = match[1].toLowerCase();
+        if (form === 'example' && !exampleHasOutput(helpers.tree(), symbol)) continue;
+        units.push({
+            kind: 'test', name: symbol.name, suite: [], form,
+            // A file under a build constraint is compiled only sometimes.
+            ...((fileEntry.buildConstraint || platform) && { conditional: true, notInEveryBuild: true }),
+            line: symbol.nameLine || symbol.startLine, startLine: symbol.startLine,
+            endLine: symbol.endLine ?? symbol.startLine, sourceSpan: symbol.sourceSpan,
+        });
+    }
+    // Go has no test that is not a declaration: no unit, no test.
+    return { units, inheriting: false, complete: true };
+}
+
 /**
  * Classify a Go symbol as a runtime entry point of a specific kind.
  * Returns 'test' | 'main' | null.
@@ -3902,5 +4020,7 @@ module.exports = {
     isPlatformConcreteType,
     isEntryPoint,
     getEntryPointKind,
+    testUnits,
+    testGate,
     parse
 };