brighterscript 1.0.0-alpha.51 → 1.0.0-alpha.53

package/dist/util.d.ts

@@ -15,7 +15,7 @@ import { ObjectType } from './types/ObjectType';
 import { StringType } from './types/StringType';
 import { VoidType } from './types/VoidType';
 import { ParseMode } from './parser/Parser';
-import type { CallExpression, CallfuncExpression, DottedGetExpression, VariableExpression } from './parser/Expression';
+import type { CallExpression, CallfuncExpression, VariableExpression } from './parser/Expression';
 import { type Identifier, type Token } from './lexer/Token';
 import { SourceNode } from 'source-map';
 import type { RawSourceMap, SourceMapGenerator } from 'source-map';
@@ -132,7 +132,7 @@ export declare class Util {
     /**
      * Walks left in a DottedGetExpression and returns a VariableExpression if found, or undefined if not found
      */
-    findBeginningVariableExpression(dottedGet: DottedGetExpression): VariableExpression | undefined;
+    findBeginningVariableExpression(expression: Expression): VariableExpression | undefined;
     /**
      * Do `a` and `b` overlap by at least one character. This returns false if they are at the edges. Here's some examples:
      * ```
@@ -160,6 +160,22 @@ export declare class Util {
     rangeContains(range: Range | undefined, position: Position | undefined): boolean;
     comparePositionToRange(position: Position | undefined, range: Range | undefined): 1 | -1 | 0;
     comparePosition(a: Position | undefined, b: Position): 1 | -1 | 0;
+    /**
+     * Convert a file path into a `file://` URL string (e.g. `file:///C:/projects/file.brs`).
+     * Mirrors the `file-url` package: resolves the path, normalizes slashes, prefixes a leading slash
+     * (required for Windows drive letters), and escapes per RFC 3986.
+     */
+    fileUrl(filePath: string): string;
+    /**
+     * `JSON.stringify` that is safe against circular references and throwing getters. Replaces the
+     * `safe-json-stringify` package.
+     */
+    safeJsonStringify(data: any, replacer?: (key: string, value: any) => any, space?: string | number): string;
+    /**
+     * Serialize an error (or any thrown value) into a plain object suitable for `JSON.stringify`,
+     * handling circular references. Replaces the `serialize-error` package.
+     */
+    serializeError(value: any): any;
     /**
      * Is the inner range completely enclosed in the outer range
      */
@@ -380,6 +396,13 @@ export declare class Util {
      * Mostly used to convert namespaced item full names to a strings
      */
     getAllDottedGetPartsAsString(node: Expression | Statement, parseMode?: ParseMode, lastSep?: string): string;
+    /**
+     * Reconstruct the written name of a "complex" type expression - one that isn't a plain
+     * dotted-get chain, so `getAllDottedGetPartsAsString` can't represent it. Handles
+     * unions/intersections, inline interfaces, typed arrays, typed function types, and groupings.
+     * Returns `undefined` for anything it can't render.
+     */
+    getTypeExpressionName(node: Expression, parseMode?: ParseMode): string;
     /**
      * Break an expression into each part.
      */
@@ -412,6 +435,17 @@ export declare class Util {
      * Wraps SourceNode's constructor to be compatible with the TranspileResult type
      */
     sourceNodeFromTranspileResult(line: number | null, column: number | null, source: string | null, chunks?: string | SourceNode | TranspileResult, name?: string): SourceNode;
+    /**
+     * Strip a trailing `sourceMappingURL` comment (and the newline preceding it) from the end of a
+     * transpile result, so that appending a freshly-generated one doesn't produce a duplicate. A file
+     * can already carry a comment from a previous build, which is either preserved verbatim (for
+     * files that don't need transpiling) or re-emitted as a comment by the AST transpile.
+     *
+     * Handles both BrightScript-style (`'//# sourceMappingURL=...`) and XML-style
+     * (`<!--//# sourceMappingURL=... -->`) comments. Leaves the node untouched when no trailing
+     * sourceMappingURL comment is present.
+     */
+    stripTrailingSourceMappingURLComment(node: SourceNode): SourceNode;
     /**
      * Find the index of the last item in the array that matches.
      */
@@ -444,7 +478,7 @@ export declare class Util {
         srcPath: string;
     }): Promise<string>;
     isBuiltInType(typeName: string): boolean;
-    isGenericNodeType(type: BscType): boolean;
+    isGenericNodeType(type: BscType, mustBeCallfuncAble: boolean): boolean;
     hasAnyRequiredSymbolChanged(requiredSymbols: UnresolvedSymbol[], changedSymbols: Map<SymbolTypeFlag, Set<string>>): boolean;
     setContainsUnresolvedSymbol(symbolLowerNameSet: Set<string>, symbol: UnresolvedSymbol): boolean;
     getCustomTypesInSymbolTree(setToFill: Set<BscType>, type: BscType, filter?: (t: BscType) => boolean): void;
@@ -494,7 +528,7 @@ export declare class Util {
  * A tagged template literal function for standardizing the path. This has to be defined as standalone function since it's a tagged template literal function,
  * we can't use `object.tag` syntax.
  */
-export declare function standardizePath(stringParts: any, ...expressions: any[]): string;
+export declare function standardizePath(stringParts: TemplateStringsArray | string, ...expressions: any[]): string;
 /**
  * An item that can be coerced into a `Range`
  */

package/dist/util.js

@@ -8,6 +8,7 @@ const path = require("path");
 const roku_deploy_1 = require("roku-deploy");
 const vscode_languageserver_1 = require("vscode-languageserver");
 const vscode_uri_1 = require("vscode-uri");
+const BsConfig_1 = require("./BsConfig");
 const DiagnosticMessages_1 = require("./DiagnosticMessages");
 const interfaces_1 = require("./interfaces");
 const BooleanType_1 = require("./types/BooleanType");
@@ -172,7 +173,7 @@ class Util {
      * @param parentProjectPaths a list of parent config files. This is used by this method to recursively build the config list
      */
     loadConfigFile(configFilePath, parentProjectPaths, cwd = process.cwd()) {
-        var _a;
+        var _a, _b, _c, _d, _e, _f, _g;
         if (configFilePath) {
             //if the config file path starts with question mark, then it's optional. return undefined if it doesn't exist
             if (configFilePath.startsWith('?')) {
@@ -212,11 +213,18 @@ class Util {
             //`require` paths should be relative to cwd
             exports.util.resolvePathsRelativeTo(projectConfig, 'require', projectFileCwd);
             let result;
+            let baseProjectConfigDeprecationDiagnostics;
             //if the project has a base file, load it
             if (projectConfig && typeof projectConfig.extends === 'string') {
                 let baseProjectConfig = this.loadConfigFile(projectConfig.extends, [...parentProjectPaths, configFilePath], projectFileCwd);
                 //extend the base config with the current project settings
                 result = Object.assign(Object.assign({}, baseProjectConfig), projectConfig);
+                //`compilerOptions` is deep-merged (like TypeScript does), so a child config only
+                //overriding one option doesn't wipe out the rest of the options set by its parent(s)
+                if ((baseProjectConfig === null || baseProjectConfig === void 0 ? void 0 : baseProjectConfig.compilerOptions) || projectConfig.compilerOptions) {
+                    result.compilerOptions = Object.assign(Object.assign({}, baseProjectConfig === null || baseProjectConfig === void 0 ? void 0 : baseProjectConfig.compilerOptions), projectConfig.compilerOptions);
+                }
+                baseProjectConfigDeprecationDiagnostics = baseProjectConfig === null || baseProjectConfig === void 0 ? void 0 : baseProjectConfig._deprecationDiagnostics;
             }
             else {
                 result = projectConfig;
@@ -231,11 +239,44 @@ class Util {
             if (result.outDir) {
                 result.outDir = path.resolve(projectFileCwd, result.outDir);
             }
+            //map the deprecated staging options to `outDir` (relative to THIS config file).
+            //the deprecated options themselves are left as-is so consumers that still read them keep working
+            if (!('outDir' in projectConfig)) {
+                if (projectConfig.stagingFolderPath) {
+                    result.outDir = path.resolve(projectFileCwd, projectConfig.stagingFolderPath);
+                }
+                else if (projectConfig.stagingDir) {
+                    result.outDir = path.resolve(projectFileCwd, projectConfig.stagingDir);
+                }
+            }
             if (result.cwd) {
                 result.cwd = path.resolve(projectFileCwd, result.cwd);
             }
-            if (result.sourceRoot && result.resolveSourceRoot) {
-                result.sourceRoot = path.resolve(projectFileCwd, result.sourceRoot);
+            //flag any deprecated top-level `compilerOptions` options used directly in THIS config file
+            //(this is deliberately scoped to options loaded from an actual bsconfig.json file; options
+            //passed programmatically to `Program`/`ProgramBuilder` are not flagged)
+            const deprecationDiagnostics = [...((_b = (baseProjectConfigDeprecationDiagnostics)) !== null && _b !== void 0 ? _b : [])];
+            for (const key of BsConfig_1.deprecatedCompilerOptionKeys) {
+                if (key in projectConfig) {
+                    deprecationDiagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.deprecatedBsConfigOption(key)), { location: {
+                            uri: this.pathToUri(configFilePath),
+                            range: this.createRange(0, 0, 0, 0)
+                        } }));
+                }
+            }
+            result._deprecationDiagnostics = deprecationDiagnostics;
+            //`sourceRoot`/`resolveSourceRoot` may live at the top level (deprecated) or in `compilerOptions`.
+            //resolve whichever location actually holds the value, relative to THIS config file
+            const sourceRootValue = (_d = (_c = result.compilerOptions) === null || _c === void 0 ? void 0 : _c.sourceRoot) !== null && _d !== void 0 ? _d : result.sourceRoot;
+            const resolveSourceRootValue = (_f = (_e = result.compilerOptions) === null || _e === void 0 ? void 0 : _e.resolveSourceRoot) !== null && _f !== void 0 ? _f : result.resolveSourceRoot;
+            if (sourceRootValue && resolveSourceRootValue) {
+                const resolvedSourceRoot = path.resolve(projectFileCwd, sourceRootValue);
+                if (((_g = result.compilerOptions) === null || _g === void 0 ? void 0 : _g.sourceRoot) !== undefined) {
+                    result.compilerOptions.sourceRoot = resolvedSourceRoot;
+                }
+                else {
+                    result.sourceRoot = resolvedSourceRoot;
+                }
             }
             return result;
         }
@@ -265,24 +306,28 @@ class Util {
      * @param config a bsconfig object to use as the baseline for the resulting config
      */
     normalizeAndResolveConfig(config) {
-        let result = this.normalizeConfig(Object.assign({}, config));
         if (config === null || config === void 0 ? void 0 : config.noProject) {
-            return result;
+            return this.normalizeConfig(Object.assign({}, config));
         }
+        let project;
         //if no options were provided, try to find a bsconfig.json file
         if (!config || !config.project) {
-            result.project = this.getConfigFilePath(config === null || config === void 0 ? void 0 : config.cwd);
+            project = this.getConfigFilePath(config === null || config === void 0 ? void 0 : config.cwd);
         }
         else {
             //use the config's project link
-            result.project = config.project;
-        }
-        if (result.project) {
-            let configFile = this.loadConfigFile(result.project, undefined, config === null || config === void 0 ? void 0 : config.cwd);
-            result = Object.assign(result, configFile);
-        }
-        //override the defaults with the specified options
-        result = Object.assign(result, config);
+            project = config.project;
+        }
+        let mergedConfig = Object.assign({}, config);
+        if (project) {
+            let configFile = this.loadConfigFile(project, undefined, config === null || config === void 0 ? void 0 : config.cwd);
+            //the project file values are the defaults; the provided options override them
+            mergedConfig = Object.assign(Object.assign({}, configFile), config);
+        }
+        //set defaults and map deprecated options AFTER merging the project file, so that
+        //deprecated options (i.e. `stagingFolderPath`, `copyToStaging`) from the project file are properly honored
+        let result = this.normalizeConfig(mergedConfig);
+        result.project = project;
         return result;
     }
     /**
@@ -290,14 +335,31 @@ class Util {
      * @param config a bsconfig object to use as the baseline for the resulting config
      */
     normalizeConfig(config) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
         config = config !== null && config !== void 0 ? config : {};
         const cwd = (_a = config.cwd) !== null && _a !== void 0 ? _a : process.cwd();
+        //Resolve `compilerOptions`: values set there win over their deprecated top-level counterparts.
+        //(deprecation diagnostics for options loaded directly from a bsconfig.json file are collected
+        //separately, in `loadConfigFile`, and simply carried through on `config._deprecationDiagnostics`)
+        const compilerOptions = Object.assign({}, ((_b = config.compilerOptions) !== null && _b !== void 0 ? _b : {}));
+        for (const key of BsConfig_1.deprecatedCompilerOptionKeys) {
+            if (!(key in compilerOptions) && key in config) {
+                compilerOptions[key] = config[key];
+            }
+            //push the resolved (winning) value back onto the flat config so the rest of this function
+            //(and any code that still reads the deprecated flat option) sees the correct, resolved value
+            if (key in compilerOptions) {
+                config[key] = compilerOptions[key];
+            }
+        }
         let logLevel = logging_1.LogLevel.log;
         if (typeof config.logLevel === 'string') {
-            logLevel = (_b = logging_1.LogLevel[config.logLevel.toLowerCase()]) !== null && _b !== void 0 ? _b : logging_1.LogLevel.log;
+            logLevel = (_c = logging_1.LogLevel[config.logLevel.toLowerCase()]) !== null && _c !== void 0 ? _c : logging_1.LogLevel.log;
         }
-        let bslibDestinationDir = (_c = config.bslibDestinationDir) !== null && _c !== void 0 ? _c : 'source';
+        else if (typeof config.logLevel === 'number') {
+            logLevel = config.logLevel;
+        }
+        let bslibDestinationDir = (_d = config.bslibDestinationDir) !== null && _d !== void 0 ? _d : 'source';
         if (bslibDestinationDir !== 'source') {
             // strip leading and trailing slashes
             bslibDestinationDir = bslibDestinationDir.replace(/^(\/*)(.*?)(\/*)$/, '$2');
@@ -314,7 +376,7 @@ class Util {
         }
         let outDir;
         if ('outDir' in config) {
-            outDir = (_d = config.outDir) !== null && _d !== void 0 ? _d : './out';
+            outDir = (_e = config.outDir) !== null && _e !== void 0 ? _e : './out';
         }
         else if ('stagingFolderPath' in config) {
             outDir = config.stagingFolderPath;
@@ -325,21 +387,22 @@ class Util {
         else {
             outDir = './out'; //default case
         }
+        const strictValue = !!config.strict;
         const configWithDefaults = {
             cwd: cwd,
             //use default files array from rokuDeploy
-            files: (_e = config.files) !== null && _e !== void 0 ? _e : [...roku_deploy_1.DefaultFiles],
+            files: (_f = config.files) !== null && _f !== void 0 ? _f : [...roku_deploy_1.DefaultFiles],
             outDir: outDir,
             sourceMap: config.sourceMap === true,
             relativeSourceMaps: config.relativeSourceMaps === true,
             watch: config.watch === true ? true : false,
             emitFullPaths: config.emitFullPaths === true ? true : false,
             noEmit: noEmit,
-            ignoreErrorCodes: (_f = config.ignoreErrorCodes) !== null && _f !== void 0 ? _f : [],
-            diagnosticSeverityOverrides: (_g = config.diagnosticSeverityOverrides) !== null && _g !== void 0 ? _g : {},
-            diagnosticFilters: (_h = config.diagnosticFilters) !== null && _h !== void 0 ? _h : [],
+            ignoreErrorCodes: (_g = config.ignoreErrorCodes) !== null && _g !== void 0 ? _g : [],
+            diagnosticSeverityOverrides: (_h = config.diagnosticSeverityOverrides) !== null && _h !== void 0 ? _h : {},
+            diagnosticFilters: (_j = config.diagnosticFilters) !== null && _j !== void 0 ? _j : [],
             diagnosticFiltersV0Compatibility: config.diagnosticFiltersV0Compatibility === true ? true : false,
-            plugins: (_j = config.plugins) !== null && _j !== void 0 ? _j : [],
+            plugins: (_k = config.plugins) !== null && _k !== void 0 ? _k : [],
             pruneEmptyCodeFiles: config.pruneEmptyCodeFiles === true ? true : false,
             autoImportComponentScript: config.autoImportComponentScript === true ? true : false,
             showDiagnosticsInConsole: config.showDiagnosticsInConsole === false ? false : true,
@@ -351,7 +414,11 @@ class Util {
             logLevel: logLevel,
             bslibDestinationDir: bslibDestinationDir,
             legacyCallfuncHandling: config.legacyCallfuncHandling === true ? true : false,
-            validate: config.validate === false ? false : true
+            validate: config.validate === false ? false : true,
+            strict: strictValue,
+            strictCallFunc: (typeof config.strictCallFunc === 'boolean' ? config.strictCallFunc : strictValue),
+            strictNodeMembers: (typeof config.strictNodeMembers === 'boolean' ? config.strictNodeMembers : strictValue),
+            compilerOptions: compilerOptions
         };
         //mutate `config` in case anyone is holding a reference to the incomplete one
         const merged = Object.assign(config, configWithDefaults);
@@ -504,8 +571,8 @@ class Util {
     /**
      * Walks left in a DottedGetExpression and returns a VariableExpression if found, or undefined if not found
      */
-    findBeginningVariableExpression(dottedGet) {
-        let left = dottedGet;
+    findBeginningVariableExpression(expression) {
+        let left = expression;
         while (left) {
             if ((0, reflection_1.isVariableExpression)(left)) {
                 return left;
@@ -601,6 +668,106 @@ class Util {
         }
         return 0;
     }
+    /**
+     * Convert a file path into a `file://` URL string (e.g. `file:///C:/projects/file.brs`).
+     * Mirrors the `file-url` package: resolves the path, normalizes slashes, prefixes a leading slash
+     * (required for Windows drive letters), and escapes per RFC 3986.
+     */
+    fileUrl(filePath) {
+        let pathName = path.resolve(filePath).replace(/\\/g, '/');
+        //Windows drive letter must be prefixed with a slash
+        if (!pathName.startsWith('/')) {
+            pathName = `/${pathName}`;
+        }
+        //escape required characters for path components
+        return encodeURI(`file://${pathName}`).replace(/[?#]/g, encodeURIComponent);
+    }
+    /**
+     * `JSON.stringify` that is safe against circular references and throwing getters. Replaces the
+     * `safe-json-stringify` package.
+     */
+    safeJsonStringify(data, replacer, space) {
+        const seen = [];
+        const throwsMessage = (err) => '[Throws: ' + (err ? err.message : '?') + ']';
+        const safeGetValue = (obj, property) => {
+            try {
+                return obj[property];
+            }
+            catch (err) {
+                return throwsMessage(err);
+            }
+        };
+        const visit = (obj) => {
+            if (obj === null || typeof obj !== 'object') {
+                return obj;
+            }
+            if (seen.includes(obj)) {
+                return '[Circular]';
+            }
+            seen.push(obj);
+            try {
+                if (typeof obj.toJSON === 'function') {
+                    try {
+                        return visit(obj.toJSON());
+                    }
+                    catch (err) {
+                        return throwsMessage(err);
+                    }
+                }
+                if (Array.isArray(obj)) {
+                    return obj.map(visit);
+                }
+                return Object.keys(obj).reduce((result, prop) => {
+                    result[prop] = visit(safeGetValue(obj, prop));
+                    return result;
+                }, {});
+            }
+            finally {
+                seen.pop();
+            }
+        };
+        return JSON.stringify(visit(data), replacer, space);
+    }
+    /**
+     * Serialize an error (or any thrown value) into a plain object suitable for `JSON.stringify`,
+     * handling circular references. Replaces the `serialize-error` package.
+     */
+    serializeError(value) {
+        const commonProperties = ['name', 'message', 'stack', 'code'];
+        const destroyCircular = (from, seen) => {
+            const to = Array.isArray(from) ? [] : {};
+            seen.push(from);
+            for (const [key, val] of Object.entries(from)) {
+                if (typeof val === 'function') {
+                    continue;
+                }
+                if (!val || typeof val !== 'object') {
+                    to[key] = val;
+                    continue;
+                }
+                if (!seen.includes(from[key])) {
+                    to[key] = destroyCircular(from[key], seen.slice());
+                    continue;
+                }
+                to[key] = '[Circular]';
+            }
+            for (const property of commonProperties) {
+                if (typeof from[property] === 'string') {
+                    to[property] = from[property];
+                }
+            }
+            return to;
+        };
+        if (typeof value === 'object' && value !== null) {
+            return destroyCircular(value, []);
+        }
+        //people sometimes throw things besides Error objects…
+        if (typeof value === 'function') {
+            //`JSON.stringify()` discards functions. We do too, unless a function is thrown directly.
+            return `[Function: ${(value.name || 'anonymous')}]`;
+        }
+        return value;
+    }
     /**
      * Is the inner range completely enclosed in the outer range
      */
@@ -1006,11 +1173,13 @@ class Util {
      */
     cloneToken(token) {
         if (token) {
+            //keep this field order identical to `Lexer.addToken` so cloned tokens
+            //share the same V8 hidden class as lexer-produced tokens
             const result = {
                 kind: token.kind,
-                location: this.cloneLocation(token.location),
                 text: token.text,
                 isReserved: token.isReserved,
+                location: this.cloneLocation(token.location),
                 leadingWhitespace: token.leadingWhitespace,
                 leadingTrivia: token.leadingTrivia ? token.leadingTrivia.map(x => this.cloneToken(x)) : undefined
             };
@@ -1376,7 +1545,15 @@ class Util {
         if ((0, reflection_1.isUnionType)(rightType)) {
             rightType = this.getHighestPriorityType(rightType.types);
         }
-        if ((0, reflection_1.isVoidType)(leftType) || (0, reflection_1.isVoidType)(rightType) || (0, reflection_1.isUninitializedType)(leftType) || (0, reflection_1.isUninitializedType)(rightType)) {
+        if ((0, reflection_1.isUninitializedType)(leftType) || (0, reflection_1.isUninitializedType)(rightType)) {
+            return undefined;
+        }
+        if ((0, reflection_1.isVoidType)(leftType) || (0, reflection_1.isVoidType)(rightType)) {
+            // = and <> can still be used to check a possibly-void value against invalid/dynamic
+            if ((operator.kind === TokenKind_1.TokenKind.Equal || operator.kind === TokenKind_1.TokenKind.LessGreater) &&
+                ((0, reflection_1.isInvalidTypeLike)(leftType) || (0, reflection_1.isInvalidTypeLike)(rightType) || (0, reflection_1.isDynamicType)(leftType) || (0, reflection_1.isDynamicType)(rightType))) {
+                return BooleanType_1.BooleanType.instance;
+            }
             return undefined;
         }
         if ((0, reflection_1.isEnumMemberType)(leftType)) {
@@ -1987,6 +2164,71 @@ class Util {
         return result;
         /* eslint-enable no-var */
     }
+    /**
+     * Reconstruct the written name of a "complex" type expression - one that isn't a plain
+     * dotted-get chain, so `getAllDottedGetPartsAsString` can't represent it. Handles
+     * unions/intersections, inline interfaces, typed arrays, typed function types, and groupings.
+     * Returns `undefined` for anything it can't render.
+     */
+    getTypeExpressionName(node, parseMode = Parser_1.ParseMode.BrighterScript) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        if ((0, reflection_1.isTypeExpression)(node)) {
+            return this.getTypeExpressionName(node.expression, parseMode);
+        }
+        if ((0, reflection_1.isBinaryExpression)(node)) {
+            //union (`or`) / intersection (`and`) types
+            const left = this.getTypeExpressionName(node.left, parseMode);
+            const right = this.getTypeExpressionName(node.right, parseMode);
+            if (left === undefined || right === undefined) {
+                return undefined;
+            }
+            return `${left} ${(_b = (_a = node.tokens.operator) === null || _a === void 0 ? void 0 : _a.text) !== null && _b !== void 0 ? _b : 'or'} ${right}`;
+        }
+        if ((0, reflection_1.isGroupingExpression)(node)) {
+            const inner = this.getTypeExpressionName(node.expression, parseMode);
+            return inner === undefined ? undefined : `(${inner})`;
+        }
+        if ((0, reflection_1.isTypedArrayExpression)(node)) {
+            const inner = this.getTypeExpressionName(node.innerType, parseMode);
+            return inner === undefined ? undefined : `${inner}[]`;
+        }
+        if ((0, reflection_1.isInlineInterfaceExpression)(node)) {
+            const members = [];
+            for (const member of (_c = node.members) !== null && _c !== void 0 ? _c : []) {
+                const memberType = member.typeExpression
+                    ? this.getTypeExpressionName(member.typeExpression, parseMode)
+                    : undefined;
+                members.push([
+                    member.isOptional ? 'optional ' : '',
+                    (_e = (_d = member.tokens.name) === null || _d === void 0 ? void 0 : _d.text) !== null && _e !== void 0 ? _e : '',
+                    memberType === undefined ? '' : ` as ${memberType}`
+                ].join(''));
+            }
+            return `{ ${members.join(', ')} }`;
+        }
+        if ((0, reflection_1.isTypedFunctionTypeExpression)(node)) {
+            const params = [];
+            for (const param of (_f = node.params) !== null && _f !== void 0 ? _f : []) {
+                const paramType = param.typeExpression
+                    ? this.getTypeExpressionName(param.typeExpression, parseMode)
+                    : undefined;
+                params.push([
+                    (_h = (_g = param.tokens.name) === null || _g === void 0 ? void 0 : _g.text) !== null && _h !== void 0 ? _h : '',
+                    paramType === undefined ? '' : ` as ${paramType}`
+                ].join(''));
+            }
+            const returnType = node.returnType
+                ? this.getTypeExpressionName(node.returnType, parseMode)
+                : undefined;
+            return [
+                (_k = (_j = node.tokens.functionType) === null || _j === void 0 ? void 0 : _j.text) !== null && _k !== void 0 ? _k : 'function',
+                `(${params.join(', ')})`,
+                returnType === undefined ? '' : ` as ${returnType}`
+            ].join('');
+        }
+        //fall back to the dotted-get chain (variable/dotted-get leaves of the type expression)
+        return this.getAllDottedGetPartsAsString(node, parseMode);
+    }
     /**
      * Break an expression into each part.
      */
@@ -2115,6 +2357,28 @@ class Util {
         // accepts a more permissive type than its typedef states
         return new source_map_1.SourceNode(line, column, source, chunks, name);
     }
+    /**
+     * Strip a trailing `sourceMappingURL` comment (and the newline preceding it) from the end of a
+     * transpile result, so that appending a freshly-generated one doesn't produce a duplicate. A file
+     * can already carry a comment from a previous build, which is either preserved verbatim (for
+     * files that don't need transpiling) or re-emitted as a comment by the AST transpile.
+     *
+     * Handles both BrightScript-style (`'//# sourceMappingURL=...`) and XML-style
+     * (`<!--//# sourceMappingURL=... -->`) comments. Leaves the node untouched when no trailing
+     * sourceMappingURL comment is present.
+     */
+    stripTrailingSourceMappingURLComment(node) {
+        //`\S+` cannot backtrack across whitespace, so this stays linear-time on adversarial input
+        const pattern = /(?:\r?\n)?[ \t]*(?:'\/\/# sourceMappingURL=\S+|<!--[ \t]*\/\/# sourceMappingURL=\S+[ \t]*-->)\s*$/;
+        if (pattern.test(node.toString())) {
+            //`replaceRight` operates on the right-most leaf string, which is where a trailing comment
+            //lands in both the verbatim and AST-transpiled cases. The `source-map` typings declare the
+            //pattern as a string, but it is handed straight to `String.prototype.replace`, which
+            //accepts a RegExp
+            node.replaceRight(pattern, '');
+        }
+        return node;
+    }
     /**
      * Find the index of the last item in the array that matches.
      */
@@ -2311,12 +2575,15 @@ class Util {
         }
         return false;
     }
-    isGenericNodeType(type) {
+    isGenericNodeType(type, mustBeCallfuncAble) {
         if ((0, reflection_1.isComponentType)(type)) {
             const lowerName = type.toString().toLowerCase();
             if (lowerName === 'rosgnode' || lowerName === 'rosgnodenode') {
                 return true;
             }
+            if (!mustBeCallfuncAble && (lowerName === 'rosgnodecontentnode')) {
+                return true;
+            }
         }
         return false;
     }