Fix hover for global functions by adding global scope fallback

src/Program.ts

@@ -1027,11 +1027,17 @@ export class Program {
         let file = this.getFile(srcPath);
         let result: Hover[];
         if (file) {
+            //find the scopes for this file
+            let scopes = this.getScopesForFile(file);
+
+            //if there are no scopes, include the global scope so we at least get the built-in functions
+            scopes = scopes.length > 0 ? scopes : [this.globalScope];
+
             const event = {
                 program: this,
                 file: file,
                 position: position,
-                scopes: this.getScopesForFile(file),
+                scopes: scopes,
                 hovers: []
             } as ProvideHoverEvent;
             this.plugins.emit('beforeProvideHover', event);

src/bscPlugin/hover/HoverProcessor.spec.ts

@@ -219,5 +219,62 @@ describe('HoverProcessor', () => {
             expect(hover?.range).to.eql(util.createRange(2, 40, 2, 50));
             expect(hover?.contents).to.eql(fence('const name.sp.a.c.e.SOME_VALUE = true'));
         });
+
+        it('finds hover for global function', () => {
+            const file = program.setFile('source/main.brs', `
+                sub main()
+                    result = Abs(-5)
+                end sub
+            `);
+            program.validate();
+
+            // hover over the `Abs` function call
+            let hover = program.getHover(file.pathAbsolute, util.createPosition(2, 29))[0];
+            expect(hover).to.exist;
+            expect(hover.range).to.eql(util.createRange(2, 29, 2, 32));
+            expect(hover.contents).to.contain('function Abs(x as float) as float');
+            expect(hover.contents).to.contain('Returns the absolute value of the argument.');
+        });
+
+        it('finds hover for global function when file has no scopes', () => {
+            // Create a program with no manifest and no scopes to ensure global scope fallback
+            const testProgram = new Program({ rootDir: rootDir });
+
+            const file = testProgram.setFile('standalone/main.brs', `
+                sub main()
+                    result = Abs(-5)
+                end sub
+            `);
+
+            // Don't validate - this simulates a file that might not be in any scopes
+
+            // hover over the `Abs` function call
+            let hover = testProgram.getHover(file.pathAbsolute, util.createPosition(2, 29))[0];
+
+            testProgram.dispose();
+
+            // After the fix, this should now work even when file has no scopes
+            expect(hover).to.exist;
+            expect(hover.range).to.eql(util.createRange(2, 29, 2, 32));
+            expect(hover.contents).to.contain('function Abs(x as float) as float');
+            expect(hover.contents).to.contain('Returns the absolute value of the argument.');
+        });
+
+        it('finds hover for global function with both shortDescription and documentation', () => {
+            const file = program.setFile('source/main.brs', `
+                sub main()
+                    result = Atn(-5)
+                end sub
+            `);
+            program.validate();
+
+            // hover over the `Atn` function call
+            let hover = program.getHover(file.pathAbsolute, util.createPosition(2, 29))[0];
+            expect(hover).to.exist;
+            expect(hover.range).to.eql(util.createRange(2, 29, 2, 32));
+            expect(hover.contents).to.contain('function Atn(x as float) as float');
+            expect(hover.contents).to.contain('Returns the arctangent (in radians) of the argument.');
+            expect(hover.contents).to.contain('ATN(X)` returns "the angle whose tangent is X"');
+        });
     });
 });

src/bscPlugin/hover/HoverProcessor.ts

@@ -1,7 +1,7 @@
 import { isBrsFile, isFunctionType, isXmlFile } from '../../astUtils/reflection';
 import type { BrsFile } from '../../files/BrsFile';
 import type { XmlFile } from '../../files/XmlFile';
-import type { Hover, ProvideHoverEvent } from '../../interfaces';
+import type { Hover, ProvideHoverEvent, Callable } from '../../interfaces';
 import type { Token } from '../../lexer/Token';
 import { TokenKind } from '../../lexer/TokenKind';
 import { BrsTranspileState } from '../../parser/BrsTranspileState';
@@ -39,6 +39,32 @@
         return parts.join('\n');
     }
 
+    private buildCallableContents(callable: Callable, fence: (code: string) => string) {
+        const parts = [fence(callable.type.toString())];
+
+        // For global callables, use shortDescription and documentation properties
+        if (callable.shortDescription || callable.documentation) {
+            const docs = [];
+            if (callable.shortDescription) {
+                docs.push(callable.shortDescription);
+            }
+            if (callable.documentation) {
+                docs.push(callable.documentation);
+            }
+            if (docs.length > 0) {
+                parts.push('***', docs.join('\n\n'));
+            }
+        } else {
+            // For regular callables, use token-based documentation
+            const tokenDocs = this.getTokenDocumentation((this.event.file as BrsFile).parser.tokens, callable.functionStatement?.func?.functionType);
+            if (tokenDocs) {
+                parts.push('***', tokenDocs);
+            }
+        }
+
+        return parts.join('\n');
+    }
+
     private getBrsFileHover(file: BrsFile): Hover | undefined {
         const scope = this.event.scopes[0];
         const fence = (code: string) => util.mdFence(code, 'brightscript');
@@ -115,7 +141,7 @@
             if (callable) {
                 return {
                     range: token.range,
-                    contents: this.buildContentsWithDocs(fence(callable.type.toString()), callable.functionStatement?.func?.functionType)
+                    contents: this.buildCallableContents(callable, fence)
                 };
             }
         }