Fix some missing transpiled comments for namespaced calls

src/files/BrsFile.spec.ts

@@ -2615,22 +2615,41 @@ describe('BrsFile', () => {
         it('includes comments above namespaced method call', async () => {
             await testTranspile(`
                 sub main()
-                    'delay for a bit
-                    utils.delay(sub()
-                    end sub)
+                    'do nothing
+                    utils.noop()
                 end sub
                 namespace utils
-                    function delay(callback as function)
-                    end function
+                    sub noop()
+                    end sub
                 end namespace
             `, `
                 sub main()
-                    'delay for a bit
-                    utils_delay(sub()
-                    end sub)
+                    'do nothing
+                    utils_noop()
+                end sub
+                sub utils_noop()
+                end sub
+            `, undefined, 'source/main.bs');
+        });
+
+        it('includes comments above inferred namespace function call', async () => {
+            await testTranspile(`
+                namespace utils
+                    sub test()
+                        'do nothing
+                        noop()
+                    end sub
+                    sub noop()
+                    end sub
+                end namespace
+            `, `
+                sub utils_test()
+                    'do nothing
+                    utils_noop()
+                end sub
+
+                sub utils_noop()
                 end sub
-                function utils_delay(callback as function)
-                end function
             `, undefined, 'source/main.bs');
         });
 

src/parser/Expression.ts

@@ -143,11 +143,14 @@ export class CallExpression extends Expression {
 
     transpile(state: BrsTranspileState, nameOverride?: string) {
         let result: TranspileResult = [];
-        throw new Error('crash');
 
         //transpile the name
         if (nameOverride) {
-            result.push(state.sourceNode(this.callee, nameOverride));
+            result.push(
+                //transpile leading comments since we're bypassing callee.transpile (which would normally do this)
+                ...state.transpileLeadingCommentsForAstNode(this),
+                state.sourceNode(this.callee, nameOverride)
+            );
         } else {
             result.push(...this.callee.transpile(state));
         }
@@ -554,6 +557,7 @@ export class DottedGetExpression extends Expression {
         //if the callee starts with a namespace name, transpile the name
         if (state.file.calleeStartsWithNamespace(this)) {
             return [
+                ...state.transpileLeadingCommentsForAstNode(this),
                 state.sourceNode(this, this.getName(ParseMode.BrightScript))
             ];
         } else {
@@ -1185,6 +1189,8 @@ export class VariableExpression extends Expression {
         //if the callee is the name of a known namespace function
         if (namespace && state.file.calleeIsKnownNamespaceFunction(this, namespace.getName(ParseMode.BrighterScript))) {
             result.push(
+                //transpile leading comments since the token isn't being transpiled directly
+                ...state.transpileLeadingCommentsForAstNode(this),
                 state.sourceNode(this, [
                     namespace.getName(ParseMode.BrightScript),
                     '_',

src/parser/Statement.ts

@@ -419,7 +419,10 @@ export class ExpressionStatement extends Statement {
     public readonly location: Location | undefined;
 
     transpile(state: BrsTranspileState) {
-        return this.expression.transpile(state);
+        return [
+            state.transpileAnnotations(this),
+            this.expression.transpile(state)
+        ];
     }
 
     walk(visitor: WalkVisitor, options: WalkOptions) {

src/parser/TranspileState.ts

@@ -2,12 +2,11 @@ import { SourceNode } from 'source-map';
 import type { Location } from 'vscode-languageserver';
 import type { BsConfig } from '../BsConfig';
 import { TokenKind } from '../lexer/TokenKind';
-import type { Token } from '../lexer/Token';
+import { isToken, type Token } from '../lexer/Token';
 import type { RangeLike } from '../util';
 import { util } from '../util';
 import type { TranspileResult } from '../interfaces';
 
-
 interface TranspileToken {
     location?: Location;
     text: string;
@@ -113,6 +112,17 @@ export class TranspileState {
         );
     }
 
+    public transpileLeadingCommentsForAstNode(node: { leadingTrivia?: Token[] }) {
+        const leadingTrivia = node?.leadingTrivia ?? [];
+        const leadingCommentsSourceNodes = this.transpileComments(leadingTrivia);
+        if (leadingCommentsSourceNodes.length > 0) {
+            // indent in preparation for next text
+            leadingCommentsSourceNodes.push(this.indent());
+        }
+
+        return leadingCommentsSourceNodes;
+    }
+
     public transpileLeadingComments(token: TranspileToken) {
         const leadingTrivia = (token?.leadingTrivia ?? []);
         const leadingCommentsSourceNodes = this.transpileComments(leadingTrivia);
@@ -124,7 +134,7 @@ export class TranspileState {
         return leadingCommentsSourceNodes;
     }
 
-    public transpileComments(tokens: TranspileToken[]) {
+    public transpileComments(tokens: TranspileToken[], prepNextLine = false): Array<string | SourceNode> {
         const leadingCommentsSourceNodes = [];
         const justComments = tokens.filter(t => t.kind === TokenKind.Comment || t.kind === TokenKind.Newline);
         let newLinesSinceComment = 0;
@@ -150,6 +160,10 @@ export class TranspileState {
             }
             transpiledCommentAlready = true;
         }
+        //if we should prepare for the next line, add an indent (only if applicable)
+        if (prepNextLine && transpiledCommentAlready) {
+            leadingCommentsSourceNodes.push(this.indent());
+        }
         return leadingCommentsSourceNodes;
     }