brighterscript 1.0.0-alpha.5 → 1.0.0-alpha.51

package/dist/ProgramBuilder.js

@@ -3,32 +3,32 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProgramBuilder = void 0;
 const debounce = require("debounce-promise");
 const path = require("path");
-const rokuDeploy = require("roku-deploy");
+const roku_deploy_1 = require("roku-deploy");
 const Program_1 = require("./Program");
 const util_1 = require("./util");
 const Watcher_1 = require("./Watcher");
 const vscode_languageserver_1 = require("vscode-languageserver");
-const Logger_1 = require("./Logger");
+const logging_1 = require("./logging");
 const PluginInterface_1 = require("./PluginInterface");
 const diagnosticUtils = require("./diagnosticUtils");
 const fsExtra = require("fs-extra");
+const requireRelative = require("require-relative");
+const Throttler_1 = require("./Throttler");
+const DiagnosticManager_1 = require("./DiagnosticManager");
 /**
  * A runner class that handles
  */
 class ProgramBuilder {
-    constructor() {
+    constructor(options) {
+        var _a;
         /**
          * Determines whether the console should be cleared after a run (true for cli, false for languageserver)
          */
         this.allowConsoleClearing = true;
+        this.options = util_1.util.normalizeConfig({});
         this.isRunning = false;
-        this.logger = new Logger_1.Logger();
-        this.plugins = new PluginInterface_1.default([], this.logger);
         this.fileResolvers = [];
-        /**
-         * A list of diagnostics that are always added to the `getDiagnostics()` call.
-         */
-        this.staticDiagnostics = [];
+        this.diagnostics = new DiagnosticManager_1.DiagnosticManager();
         /**
          * A method that is used to cancel a previous run task.
          * Does nothing if previous run has completed or was already canceled
@@ -36,110 +36,154 @@ class ProgramBuilder {
         this.cancelLastRun = () => {
             return Promise.resolve();
         };
+        this.buildThrottler = new Throttler_1.Throttler(0);
+        this.logger = (_a = options === null || options === void 0 ? void 0 : options.logger) !== null && _a !== void 0 ? _a : (0, logging_1.createLogger)();
+        this.plugins = new PluginInterface_1.default([], { logger: this.logger });
         //add the default file resolver (used to load source file contents).
         this.addFileResolver((filePath) => {
-            return fsExtra.readFile(filePath).then((value) => {
-                return value.toString();
-            });
+            return fsExtra.readFile(filePath);
         });
     }
-    addFileResolver(fileResolver) {
-        this.fileResolvers.push(fileResolver);
+    /**
+     * Add file resolvers that will be able to provide file contents before loading from the file system
+     * @param fileResolvers a list of file resolvers
+     */
+    addFileResolver(...fileResolvers) {
+        this.fileResolvers.push(...fileResolvers);
     }
     /**
      * Get the contents of the specified file as a string.
      * This walks backwards through the file resolvers until we get a value.
      * This allow the language server to provide file contents directly from memory.
-     * @param srcPath The absolute path to the source file on disk
-     * @param normalizePath should this function repair and standardize the path? Passing false should have a performance boost if you can guarantee your path is already sanitized
      */
-    async getFileContents(srcPath, normalizePath = true) {
-        if (normalizePath) {
-            srcPath = util_1.util.standardizePath(srcPath);
-        }
+    async getFileContents(srcPath) {
+        srcPath = (0, util_1.standardizePath) `${srcPath}`;
         let reversedResolvers = [...this.fileResolvers].reverse();
         for (let fileResolver of reversedResolvers) {
             let result = await fileResolver(srcPath);
-            if (typeof result === 'string') {
+            if (typeof result === 'string' || Buffer.isBuffer(result)) {
                 return result;
             }
         }
         throw new Error(`Could not load file "${srcPath}"`);
     }
-    /**
-     * @param srcPath The absolute path to the source file on disk
-     */
     addDiagnostic(srcPath, diagnostic) {
-        var _a;
-        diagnostic.file = (_a = this.program.getFile(srcPath)) !== null && _a !== void 0 ? _a : {
-            srcPath: srcPath
-        };
-        this.staticDiagnostics.push(diagnostic);
+        if (!this.program) {
+            throw new Error('Cannot call `ProgramBuilder.addDiagnostic` before `ProgramBuilder.run()`');
+        }
+        if (!diagnostic.location) {
+            diagnostic.location = {
+                uri: util_1.util.pathToUri(srcPath),
+                range: util_1.util.createRange(0, 0, 0, 0)
+            };
+        }
+        else {
+            diagnostic.location.uri = util_1.util.pathToUri(srcPath);
+        }
+        this.diagnostics.register(diagnostic, { tags: ['ProgramBuilder'] });
     }
     getDiagnostics() {
-        var _a, _b;
-        return [
-            ...this.staticDiagnostics,
-            ...((_b = (_a = this.program) === null || _a === void 0 ? void 0 : _a.getDiagnostics()) !== null && _b !== void 0 ? _b : [])
-        ];
+        return this.diagnostics.getDiagnostics();
     }
-    async run(options) {
-        this.logger.logLevel = options.logLevel;
-        if (this.isRunning) {
-            throw new Error('Server is already running');
-        }
-        this.isRunning = true;
+    /**
+     * Load the project and all the files, but don't run the validation, transpile, or watch cycles
+     */
+    async load(options) {
+        var _a, _b;
         try {
             this.options = util_1.util.normalizeAndResolveConfig(options);
+            if (((_a = this.options) === null || _a === void 0 ? void 0 : _a.logLevel) !== undefined) {
+                this.logger.logLevel = (_b = this.options) === null || _b === void 0 ? void 0 : _b.logLevel;
+            }
+            if (this.options.noProject) {
+                this.logger.log(`'noProject' flag is set so bsconfig.json loading is disabled'`);
+            }
+            else if (this.options.project) {
+                this.logger.log(`Using config file: "${this.options.project}"`);
+            }
+            else {
+                this.logger.log(`No bsconfig.json file found, using default options`);
+            }
+            this.loadRequires();
             this.loadPlugins();
         }
         catch (e) {
-            if ((e === null || e === void 0 ? void 0 : e.file) && e.message && e.code) {
+            //For now, just use a default options object so we have a functioning program
+            this.options = util_1.util.normalizeConfig({
+                showDiagnosticsInConsole: options === null || options === void 0 ? void 0 : options.showDiagnosticsInConsole
+            });
+            if ((e === null || e === void 0 ? void 0 : e.location) && e.message && e.code) {
                 let err = e;
-                this.staticDiagnostics.push(err);
+                this.diagnostics.register(err);
             }
             else {
                 //if this is not a diagnostic, something else is wrong...
                 throw e;
             }
             this.printDiagnostics();
-            //we added diagnostics, so hopefully that draws attention to the underlying issues.
-            //For now, just use a default options object so we have a functioning program
-            this.options = util_1.util.normalizeConfig({});
         }
         this.logger.logLevel = this.options.logLevel;
-        this.program = this.createProgram();
+        this.createProgram();
         //parse every file in the entire project
-        await this.loadAllFilesAST();
+        await this.loadFiles();
+    }
+    async run(options) {
+        if (options === null || options === void 0 ? void 0 : options.logLevel) {
+            this.logger.logLevel = options.logLevel;
+        }
+        if (this.isRunning) {
+            throw new Error('Server is already running');
+        }
+        this.isRunning = true;
+        await this.load(options);
         if (this.options.watch) {
             this.logger.log('Starting compilation in watch mode...');
-            await this.runOnce();
+            await this.runOnce({
+                validate: options === null || options === void 0 ? void 0 : options.validate,
+                noEmit: options === null || options === void 0 ? void 0 : options.noEmit
+            });
             this.enableWatchMode();
         }
         else {
-            await this.runOnce();
+            await this.runOnce({
+                validate: options === null || options === void 0 ? void 0 : options.validate,
+                noEmit: options === null || options === void 0 ? void 0 : options.noEmit
+            });
         }
     }
     createProgram() {
-        const program = new Program_1.Program(this.options, undefined, this.plugins);
-        this.plugins.emit('afterProgramCreate', {
+        this.program = new Program_1.Program(this.options, this.logger, this.plugins, this.diagnostics);
+        this.plugins.emit('provideProgram', {
+            builder: this,
+            program: this.program
+        });
+        this.plugins.emit('afterProvideProgram', {
             builder: this,
-            program: program
+            program: this.program
         });
-        return program;
+        return this.program;
     }
     loadPlugins() {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         const cwd = (_a = this.options.cwd) !== null && _a !== void 0 ? _a : process.cwd();
-        const plugins = util_1.util.loadPlugins(cwd, this.options.plugins, (pathOrModule, err) => this.logger.error(`Error when loading plugin '${pathOrModule}':`, err));
-        this.logger.log(`Loading ${(_c = (_b = this.options.plugins) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0} plugins for cwd "${cwd}"`);
+        const plugins = util_1.util.loadPlugins(cwd, (_b = this.options.plugins) !== null && _b !== void 0 ? _b : [], (pathOrModule, err) => this.logger.error(`Error when loading plugin '${pathOrModule}':`, err));
+        this.logger.log(`Loading ${(_d = (_c = this.options.plugins) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0} plugins for cwd "${cwd}"`, this.options.plugins);
         for (let plugin of plugins) {
             this.plugins.add(plugin);
         }
-        this.plugins.emit('beforeProgramCreate', {
+        this.plugins.emit('beforeProvideProgram', {
             builder: this
         });
     }
+    /**
+     * `require()` every options.require path
+     */
+    loadRequires() {
+        var _a;
+        for (const dep of (_a = this.options.require) !== null && _a !== void 0 ? _a : []) {
+            requireRelative(dep, this.options.cwd);
+        }
+    }
     clearConsole() {
         if (this.allowConsoleClearing) {
             util_1.util.clearConsole();
@@ -154,7 +198,7 @@ class ProgramBuilder {
         this.watchInterval = setInterval(() => { }, 1073741824);
         //clear the console
         this.clearConsole();
-        let fileObjects = rokuDeploy.normalizeFilesArray(this.options.files ? this.options.files : []);
+        let fileObjects = roku_deploy_1.rokuDeploy.normalizeFilesArray(this.options.files ? this.options.files : []);
         //add each set of files to the file watcher
         for (let fileObject of fileObjects) {
             let src = typeof fileObject === 'string' ? fileObject : fileObject.src;
@@ -168,15 +212,18 @@ class ProgramBuilder {
         }, 50);
         //on any file watcher event
         this.watcher.on('all', async (event, thePath) => {
-            thePath = util_1.standardizePath `${path.resolve(this.rootDir, thePath)}`;
+            if (!this.program) {
+                throw new Error('Internal invariant exception: somehow file watcher ran before `ProgramBuilder.run()`');
+            }
+            thePath = (0, util_1.standardizePath) `${path.resolve(this.rootDir, thePath)}`;
             if (event === 'add' || event === 'change') {
                 const fileObj = {
                     src: thePath,
-                    dest: rokuDeploy.getDestPath(thePath, this.program.options.files, 
+                    dest: roku_deploy_1.rokuDeploy.getDestPath(thePath, this.program.options.files, 
                     //some shells will toTowerCase the drive letter, so do it to rootDir for consistency
                     util_1.util.driveLetterToLower(this.rootDir))
                 };
-                this.program.setFile(fileObj, await this.getFileContents(fileObj.src, false));
+                this.program.setFile(fileObj, await this.getFileContents(fileObj.src));
             }
             else if (event === 'unlink') {
                 this.program.removeFile(thePath);
@@ -189,19 +236,26 @@ class ProgramBuilder {
      * The rootDir for this program.
      */
     get rootDir() {
+        if (!this.program) {
+            throw new Error('Cannot access `ProgramBuilder.rootDir` until after `ProgramBuilder.run()`');
+        }
         return this.program.options.rootDir;
     }
     /**
      * Run the entire process exactly one time.
      */
-    runOnce() {
+    runOnce(options) {
         //clear the console
         this.clearConsole();
         let cancellationToken = { isCanceled: false };
         //wait for the previous run to complete
         let runPromise = this.cancelLastRun().then(() => {
             //start the new run
-            return this._runOnce(cancellationToken);
+            return this._runOnce({
+                cancellationToken: cancellationToken,
+                validate: options === null || options === void 0 ? void 0 : options.validate,
+                noEmit: options === null || options === void 0 ? void 0 : options.noEmit
+            });
         });
         //a function used to cancel this run
         this.cancelLastRun = () => {
@@ -211,8 +265,8 @@ class ProgramBuilder {
         return runPromise;
     }
     printDiagnostics(diagnostics) {
-        var _a, _b;
-        if (this.options.showDiagnosticsInConsole === false) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        if (((_a = this.options) === null || _a === void 0 ? void 0 : _a.showDiagnosticsInConsole) === false) {
             return;
         }
         if (!diagnostics) {
@@ -221,54 +275,90 @@ class ProgramBuilder {
         //group the diagnostics by file
         let diagnosticsByFile = {};
         for (let diagnostic of diagnostics) {
-            if (!diagnosticsByFile[diagnostic.file.srcPath]) {
-                diagnosticsByFile[diagnostic.file.srcPath] = [];
+            const diagnosticFileKey = (_c = (_b = diagnostic.location) === null || _b === void 0 ? void 0 : _b.uri) !== null && _c !== void 0 ? _c : 'no-uri';
+            if (!diagnosticsByFile[diagnosticFileKey]) {
+                diagnosticsByFile[diagnosticFileKey] = [];
             }
-            diagnosticsByFile[diagnostic.file.srcPath].push(diagnostic);
+            diagnosticsByFile[diagnosticFileKey].push(diagnostic);
         }
         //get printing options
         const options = diagnosticUtils.getPrintDiagnosticOptions(this.options);
         const { cwd, emitFullPaths } = options;
-        let srcPaths = Object.keys(diagnosticsByFile).sort();
-        for (let srcPath of srcPaths) {
-            let diagnosticsForFile = diagnosticsByFile[srcPath];
+        //custom-template reporters are pre-resolved once so we don't recompile them per diagnostic;
+        //the resolved function is stashed on the entry as `run` so we don't have to keep a parallel array.
+        //invalid entries are warned about and skipped (we never want to abort a build over a config typo).
+        const reporters = diagnosticUtils.normalizeDiagnosticReporters((_d = this.options) === null || _d === void 0 ? void 0 : _d.diagnosticReporters, this.logger)
+            .map(reporter => (reporter.type === 'custom'
+            ? Object.assign(Object.assign({}, reporter), { run: diagnosticUtils.createCustomDiagnosticReporter(reporter.format) }) : reporter));
+        if (reporters.length === 0) {
+            return;
+        }
+        let fileUris = Object.keys(diagnosticsByFile).sort();
+        for (let fileUri of fileUris) {
+            let diagnosticsForFile = diagnosticsByFile[fileUri];
             //sort the diagnostics in line and column order
             let sortedDiagnostics = diagnosticsForFile.sort((a, b) => {
-                return (a.range.start.line - b.range.start.line ||
-                    a.range.start.character - b.range.start.character);
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+                return (((_c = (_b = (_a = a.location) === null || _a === void 0 ? void 0 : _a.range) === null || _b === void 0 ? void 0 : _b.start.line) !== null && _c !== void 0 ? _c : -1) - ((_f = (_e = (_d = b.location) === null || _d === void 0 ? void 0 : _d.range) === null || _e === void 0 ? void 0 : _e.start.line) !== null && _f !== void 0 ? _f : -1) ||
+                    ((_j = (_h = (_g = a.location) === null || _g === void 0 ? void 0 : _g.range) === null || _h === void 0 ? void 0 : _h.start.character) !== null && _j !== void 0 ? _j : -1) - ((_m = (_l = (_k = b.location) === null || _k === void 0 ? void 0 : _k.range) === null || _l === void 0 ? void 0 : _l.start.character) !== null && _m !== void 0 ? _m : -1));
             });
-            let filePath = srcPath;
+            let filePath = util_1.util.uriToPath(fileUri);
             if (!emitFullPaths) {
                 filePath = path.relative(cwd, filePath);
             }
             //load the file text
-            const file = this.program.getFile(srcPath);
+            const file = (_e = this.program) === null || _e === void 0 ? void 0 : _e.getFile(fileUri);
             //get the file's in-memory contents if available
-            const lines = (_b = (_a = file === null || file === void 0 ? void 0 : file.fileContents) === null || _a === void 0 ? void 0 : _a.split(/\r?\n/g)) !== null && _b !== void 0 ? _b : [];
+            const lines = (_g = (_f = file === null || file === void 0 ? void 0 : file.fileContents) === null || _f === void 0 ? void 0 : _f.split(/\r?\n/g)) !== null && _g !== void 0 ? _g : [];
             for (let diagnostic of sortedDiagnostics) {
                 //default the severity to error if undefined
                 let severity = typeof diagnostic.severity === 'number' ? diagnostic.severity : vscode_languageserver_1.DiagnosticSeverity.Error;
-                //format output
-                diagnosticUtils.printDiagnostic(options, severity, filePath, lines, diagnostic);
+                let relatedInformation = ((_j = (_h = util_1.util.toDiagnostic(diagnostic, diagnostic.source)) === null || _h === void 0 ? void 0 : _h.relatedInformation) !== null && _j !== void 0 ? _j : []).map(x => {
+                    var _a;
+                    let relatedInfoFilePath = util_1.util.uriToPath((_a = x.location) === null || _a === void 0 ? void 0 : _a.uri);
+                    if (!emitFullPaths) {
+                        relatedInfoFilePath = path.relative(cwd, relatedInfoFilePath);
+                    }
+                    return {
+                        filePath: relatedInfoFilePath,
+                        range: x.location.range,
+                        message: x.message
+                    };
+                });
+                //format output once per configured reporter
+                for (const reporter of reporters) {
+                    if (reporter.type === 'github-actions') {
+                        diagnosticUtils.printDiagnosticGithubActions({ options: options, severity: severity, filePath: filePath, diagnostic: diagnostic });
+                    }
+                    else if (reporter.type === 'custom') {
+                        reporter.run({ options: options, severity: severity, filePath: filePath, diagnostic: diagnostic });
+                    }
+                    else {
+                        diagnosticUtils.printDiagnostic(options, severity, filePath, lines, diagnostic, relatedInformation);
+                    }
+                }
             }
         }
     }
     /**
-     * Run the process once, allowing cancelability.
+     * Run the process once, allowing it to be cancelled.
      * NOTE: This should only be called by `runOnce`.
-     * @param cancellationToken
      */
-    async _runOnce(cancellationToken) {
+    async _runOnce(options) {
+        var _a, _b, _c, _d;
         let wereDiagnosticsPrinted = false;
         try {
             //maybe cancel?
-            if (cancellationToken.isCanceled === true) {
+            if (((_a = options === null || options === void 0 ? void 0 : options.cancellationToken) === null || _a === void 0 ? void 0 : _a.isCanceled) === true) {
                 return -1;
             }
-            //validate program
-            this.validateProject();
+            //the prop-drilled validate value takes precedence over this.options.validate.
+            //false means no, everything else (including missing) means true
+            if (((_b = options === null || options === void 0 ? void 0 : options.validate) !== null && _b !== void 0 ? _b : this.options.validate) !== false) {
+                this.validateProject();
+            }
             //maybe cancel?
-            if (cancellationToken.isCanceled === true) {
+            if (((_c = options === null || options === void 0 ? void 0 : options.cancellationToken) === null || _c === void 0 ? void 0 : _c.isCanceled) === true) {
                 return -1;
             }
             const diagnostics = this.getDiagnostics();
@@ -279,14 +369,13 @@ class ProgramBuilder {
                 this.logger.log(`Found ${errorCount} ${errorCount === 1 ? 'error' : 'errors'}`);
                 return errorCount;
             }
-            //create the deployment package (and transpile as well)
-            await this.createPackageIfEnabled();
+            if (options.noEmit !== true) {
+                await this.transpile();
+            }
             //maybe cancel?
-            if (cancellationToken.isCanceled === true) {
+            if (((_d = options === null || options === void 0 ? void 0 : options.cancellationToken) === null || _d === void 0 ? void 0 : _d.isCanceled) === true) {
                 return -1;
             }
-            //deploy the package
-            await this.deployPackageIfEnabled();
             return 0;
         }
         catch (e) {
@@ -296,120 +385,97 @@ class ProgramBuilder {
             throw e;
         }
     }
-    async createPackageIfEnabled() {
-        if (this.options.copyToStaging || this.options.createPackage || this.options.deploy) {
-            //transpile the project
-            await this.transpile();
-            //create the zip file if configured to do so
-            if (this.options.createPackage !== false || this.options.deploy) {
-                await this.logger.time(Logger_1.LogLevel.log, [`Creating package at ${this.options.outFile}`], async () => {
-                    await rokuDeploy.zipPackage(Object.assign(Object.assign({}, this.options), { outDir: util_1.util.getOutDir(this.options), outFile: path.basename(this.options.outFile) }));
-                });
+    /**
+     * Build the entire project and place the contents into the staging directory
+     */
+    async build() {
+        await this.buildThrottler.run(async () => {
+            //get every file referenced by the files array
+            let fileMap = Object.values(this.program.files).map(x => {
+                return {
+                    src: x.srcPath,
+                    dest: x.destPath
+                };
+            });
+            //remove files currently loaded in the program, we will transpile those instead (even if just for source maps)
+            let filteredFileMap = [];
+            for (let fileEntry of fileMap) {
+                if (this.program.hasFile(fileEntry.src) === false) {
+                    filteredFileMap.push(fileEntry);
+                }
             }
-        }
+            await this.logger.time(logging_1.LogLevel.log, ['Building'], async () => {
+                //transpile any brighterscript files
+                await this.program.build();
+            });
+        });
     }
     /**
      * Transpiles the entire program into the staging folder
+     * @deprecated use `.build()` instead
      */
     async transpile() {
-        let options = util_1.util.cwdWork(this.options.cwd, () => {
-            return rokuDeploy.getOptions(Object.assign(Object.assign({}, this.options), { outDir: util_1.util.getOutDir(this.options), outFile: path.basename(this.options.outFile) }));
-        });
-        //get every file referenced by the files array
-        let fileEntries = await rokuDeploy.getFilePaths(options.files, options.rootDir);
-        //remove files currently loaded in the program, we will transpile those instead (even if just for source maps)
-        let filteredFileEntries = [];
-        for (let fileEntry of fileEntries) {
-            if (this.program.hasFile(fileEntry.src) === false) {
-                filteredFileEntries.push(fileEntry);
-            }
-        }
-        this.plugins.emit('beforePrepublish', {
-            builder: this,
-            program: this.program,
-            files: filteredFileEntries
-        });
-        await this.logger.time(Logger_1.LogLevel.log, ['Copying to staging directory'], async () => {
-            //prepublish all non-program-loaded files to staging
-            await rokuDeploy.prepublishToStaging(Object.assign(Object.assign({}, options), { files: filteredFileEntries }));
-        });
-        this.plugins.emit('afterPrepublish', {
-            builder: this,
-            program: this.program,
-            files: filteredFileEntries
-        });
-        this.plugins.emit('beforePublish', {
-            builder: this,
-            program: this.program,
-            files: fileEntries
-        });
-        await this.logger.time(Logger_1.LogLevel.log, ['Transpiling'], async () => {
-            //transpile any brighterscript files
-            await this.program.transpile(fileEntries, options.stagingFolderPath);
-        });
-        this.plugins.emit('afterPublish', {
-            builder: this,
-            program: this.program,
-            files: fileEntries
-        });
-    }
-    async deployPackageIfEnabled() {
-        //deploy the project if configured to do so
-        if (this.options.deploy) {
-            await this.logger.time(Logger_1.LogLevel.log, ['Deploying package to', this.options.host], async () => {
-                await rokuDeploy.publish(Object.assign(Object.assign({}, this.options), { outDir: util_1.util.getOutDir(this.options), outFile: path.basename(this.options.outFile) }));
-            });
-        }
+        return this.build();
     }
     /**
-     * Parse and load the AST for every file in the project
+     * Load every file into the project
      */
-    async loadAllFilesAST() {
-        await this.logger.time(Logger_1.LogLevel.log, ['Parsing files'], async () => {
-            let errorCount = 0;
-            let files = await this.logger.time(Logger_1.LogLevel.debug, ['getFlePaths'], async () => {
+    async loadFiles() {
+        await this.logger.time(logging_1.LogLevel.log, ['load files'], async () => {
+            let files = await this.logger.time(logging_1.LogLevel.debug, ['getFilePaths'], async () => {
                 return util_1.util.getFilePaths(this.options);
             });
-            this.logger.trace('ProgramBuilder.loadAllFilesAST() files:', files);
+            this.logger.trace('ProgramBuilder.loadFiles() files:', files);
             const typedefFiles = [];
-            const nonTypedefFiles = [];
+            const allOtherFiles = [];
+            let manifestFile = null;
             for (const file of files) {
-                const srcLower = file.src.toLowerCase();
-                if (srcLower.endsWith('.d.bs')) {
+                // typedef files
+                if (/\.d\.bs$/i.test(file.dest)) {
                     typedefFiles.push(file);
+                    // all other files
                 }
                 else {
-                    nonTypedefFiles.push(file);
+                    if (/^manifest$/i.test(file.dest)) {
+                        //manifest file
+                        manifestFile = file;
+                    }
+                    allOtherFiles.push(file);
                 }
             }
-            //preload every type definition file first, which eliminates duplicate file loading
-            await Promise.all(typedefFiles.map(async (fileObj) => {
+            //load the manifest file first
+            if (manifestFile) {
+                this.program.loadManifest(manifestFile, false);
+            }
+            const loadFile = async (fileObj) => {
                 try {
                     this.program.setFile(fileObj, await this.getFileContents(fileObj.src));
                 }
                 catch (e) {
-                    //log the error, but don't fail this process because the file might be fixable later
-                    this.logger.log(e);
-                }
-            }));
-            const acceptableExtensions = ['.bs', '.brs', '.xml'];
-            //parse every file other than the type definitions
-            await Promise.all(nonTypedefFiles.map(async (fileObj) => {
-                try {
-                    let fileExtension = path.extname(fileObj.src).toLowerCase();
-                    //only process certain file types
-                    if (acceptableExtensions.includes(fileExtension)) {
-                        this.program.setFile(fileObj, await this.getFileContents(fileObj.src));
-                    }
-                }
-                catch (e) {
-                    //log the error, but don't fail this process because the file might be fixable later
-                    this.logger.log(e);
+                    this.logger.log(e); // log the error, but don't fail this process because the file might be fixable later
                 }
-            }));
-            return errorCount;
+            };
+            // preload every type definition file, which eliminates duplicate file loading
+            await Promise.all(typedefFiles.map(loadFile));
+            // load all other files
+            await Promise.all(allOtherFiles.map(loadFile));
         });
     }
+    /**
+     * Remove all files from the program that are in the specified folder path
+     * @param srcPath the path to the folder to remove
+     */
+    removeFilesInFolder(srcPath) {
+        let removedSomeFiles = false;
+        for (let filePath in this.program.files) {
+            //if the file path starts with the parent path and the file path does not exactly match the folder path
+            if (filePath.startsWith(srcPath) && filePath !== srcPath) {
+                this.program.removeFile(filePath);
+                removedSomeFiles = true;
+            }
+        }
+        return removedSomeFiles;
+    }
     /**
      * Scan every file and resolve all variable references.
      * If no errors were encountered, return true. Otherwise return false.