Support for type definition files

.eslintrc.js

@@ -91,6 +91,7 @@ module.exports = {
         'func-style': 'off',
         'function-call-argument-newline': 'off',
         'function-paren-newline': 'off',
+        'getter-return': 'off',
         'guard-for-in': 'off',
         'id-length': 'off',
         'indent': 'off',

.vscode/launch.json

@@ -24,7 +24,7 @@
             "type": "node",
             "request": "launch",
             // "preLaunchTask": "build",
-            "smartStep": false,
+            "smartStep": true,
             "program": "${workspaceFolder}/node_modules/mocha/bin/_mocha",
             "sourceMaps": true,
             "args": [
@@ -36,7 +36,12 @@
             ],
             "cwd": "${workspaceRoot}",
             "protocol": "inspector",
-            "internalConsoleOptions": "openOnSessionStart"
+            "internalConsoleOptions": "openOnSessionStart",
+            "resolveSourceMapLocations": [
+                "${workspaceFolder}/**",
+                "!**/node_modules/typescript/**",
+                "!**/node_modules/vscode-languageserver/**"
+            ]
         }
     ]
 }

bsconfig.schema.json

@@ -128,6 +128,11 @@
             "type": "boolean",
             "default": false
         },
+        "emitDefinitions": {
+            "description": "Emit type definition files (`d.bs`) during transpile",
+            "type": "boolean",
+            "default": true
+        },
         "diagnosticFilters": {
             "description": "A collection of filters used to hide diagnostics for certain files",
             "type": "array",

package.json

@@ -123,6 +123,7 @@
         "moment": "^2.23.0",
         "p-settle": "^2.1.0",
         "parse-ms": "^2.1.0",
+        "path-complete-extname": "^1.0.0",
         "roku-deploy": "^3.2.3",
         "serialize-error": "^7.0.1",
         "source-map": "^0.7.3",

src/BsConfig.ts

@@ -98,6 +98,12 @@ export interface BsConfig {
      */
     emitFullPaths?: boolean;
 
+    /**
+     * Emit type definition files (`d.bs`)
+     * @default true
+     */
+    emitDefinitions?: boolean;
+
     /**
      * A list of filters used to exclude diagnostics from the output
      */

src/LanguageServer.ts

@@ -891,7 +891,6 @@ export class LanguageServer {
             this.connection.tracer.log(e);
             this.sendCriticalFailure(`Critical error parsing/ validating ${filePath}: ${e.message}`);
         }
-        console.log('Validate done');
     }
 
     private async validateAll() {

src/Program.spec.ts

@@ -61,7 +61,10 @@ describe('Program', () => {
 
                 //resolve lib.brs from memory instead of going to disk
                 program.fileResolvers.push((pathAbsolute) => {
-                    if (pathAbsolute === s`${rootDir}/source/lib.brs`) {
+                    if (
+                        pathAbsolute === s`${rootDir}/source/lib.brs` ||
+                        pathAbsolute === s`${rootDir}/source/lib.d.bs`
+                    ) {
                         return `'comment`;
                     }
                 });
@@ -736,7 +739,7 @@ describe('Program', () => {
 
     describe('getCompletions', () => {
         it('should include first-level namespace names for brighterscript files', async () => {
-            await program.addOrReplaceFile({ src: `${rootDir}/source/main.bs`, dest: 'source/main.brs' }, `
+            await program.addOrReplaceFile('source/main.bs', `
                 namespace NameA.NameB.NameC
                     sub DoSomething()
                     end sub
@@ -754,7 +757,7 @@ describe('Program', () => {
         });
 
         it('resolves completions for namespaces with next namespace part for brighterscript file', async () => {
-            await program.addOrReplaceFile({ src: `${rootDir}/source/main.bs`, dest: 'source/main.brs' }, `
+            const file = await program.addOrReplaceFile({ src: `${rootDir}/source/main.bs`, dest: 'source/main.brs' }, `
                 namespace NameA.NameB.NameC
                     sub DoSomething()
                     end sub
@@ -763,6 +766,7 @@ describe('Program', () => {
                     NameA.
                 end sub
             `);
+            await file.isReady();
             let completions = (await program.getCompletions(`${rootDir}/source/main.bs`, Position.create(6, 26))).map(x => x.label);
             expect(completions).to.include('NameB');
             expect(completions).not.to.include('NameA');

src/Program.ts

@@ -20,12 +20,13 @@ import type { ManifestValue } from './preprocessor/Manifest';
 import { parseManifest } from './preprocessor/Manifest';
 import { URI } from 'vscode-uri';
 import PluginInterface from './PluginInterface';
-import { isXmlFile } from './astUtils/reflection';
+import { isBrsFile, isXmlFile } from './astUtils/reflection';
 const startOfSourcePkgPath = `source${path.sep}`;
 
 export interface SourceObj {
     pathAbsolute: string;
     source: string;
+    definitions?: string;
 }
 
 export interface TranspileObj {
@@ -111,7 +112,7 @@ export class Program {
     private diagnostics = [] as BsDiagnostic[];
 
     /**
-     * A map of every file loaded into this program
+     * A map of every file loaded into this program, indexed by its original file location
      */
     public files = {} as Record<string, BscFile>;
     private pkgMap = {} as Record<string, BscFile>;
@@ -297,63 +298,61 @@ export class Program {
     public async addOrReplaceFile<T extends BscFile>(fileEntry: FileObj, fileContents?: string): Promise<T>;
     public async addOrReplaceFile<T extends BscFile>(fileParam: FileObj | string, fileContents?: string): Promise<T> {
         assert.ok(fileParam, 'fileEntry is required');
-        let pathAbsolute: string;
+        let srcPath: string;
         let pkgPath: string;
         if (typeof fileParam === 'string') {
-            pathAbsolute = s`${this.options.rootDir}/${fileParam}`;
+            srcPath = s`${this.options.rootDir}/${fileParam}`;
             pkgPath = s`${fileParam}`;
         } else {
-            pathAbsolute = s`${fileParam.src}`;
+            srcPath = s`${fileParam.src}`;
             pkgPath = s`${fileParam.dest}`;
         }
-        let file = await this.logger.time(LogLevel.debug, ['Program.addOrReplaceFile()', chalk.green(pathAbsolute)], async () => {
+        let file = await this.logger.time(LogLevel.debug, ['Program.addOrReplaceFile()', chalk.green(srcPath)], async () => {
 
-            assert.ok(pathAbsolute, 'fileEntry.src is required');
+            assert.ok(srcPath, 'fileEntry.src is required');
             assert.ok(pkgPath, 'fileEntry.dest is required');
 
             //if the file is already loaded, remove it
-            if (this.hasFile(pathAbsolute)) {
-                this.removeFile(pathAbsolute);
+            if (this.hasFile(srcPath)) {
+                this.removeFile(srcPath);
             }
-            let fileExtension = path.extname(pathAbsolute).toLowerCase();
+            let fileExtension = path.extname(srcPath).toLowerCase();
             let file: BscFile | undefined;
 
             //load the file contents by file path if not provided
             let getFileContents = async () => {
                 if (fileContents === undefined) {
-                    return this.getFileContents(pathAbsolute);
+                    return this.getFileContents(srcPath);
                 } else {
                     return fileContents;
                 }
             };
-            //get the extension of the file
+
             if (fileExtension === '.brs' || fileExtension === '.bs') {
-                let brsFile = new BrsFile(pathAbsolute, pkgPath, this);
+                let brsFile = new BrsFile(srcPath, pkgPath, this);
 
                 //add file to the `source` dependency list
                 if (brsFile.pkgPath.startsWith(startOfSourcePkgPath)) {
                     this.createSourceScope();
                     this.dependencyGraph.addDependency('scope:source', brsFile.dependencyGraphKey);
                 }
 
+
                 //add the file to the program
-                this.files[pathAbsolute] = brsFile;
+                this.files[srcPath] = brsFile;
                 this.pkgMap[brsFile.pkgPath.toLowerCase()] = brsFile;
                 let fileContents: SourceObj = {
-                    pathAbsolute: pathAbsolute,
+                    pathAbsolute: srcPath,
                     source: await getFileContents()
                 };
                 this.plugins.emit('beforeFileParse', fileContents);
 
-                this.logger.time(LogLevel.info, ['parse', chalk.green(pathAbsolute)], () => {
+                this.logger.time(LogLevel.info, ['parse', chalk.green(srcPath)], () => {
                     brsFile.parse(fileContents.source);
                 });
                 file = brsFile;
 
-                this.dependencyGraph.addOrReplace(
-                    brsFile.dependencyGraphKey,
-                    brsFile.ownScriptImports.filter(x => !!x.pkgPath).map(x => x.pkgPath.toLowerCase())
-                );
+                brsFile.attachDependencyGraph(this.dependencyGraph);
 
                 this.plugins.emit('afterFileValidate', brsFile);
             } else if (
@@ -362,11 +361,11 @@ export class Program {
                 //resides in the components folder (Roku will only parse xml files in the components folder)
                 pkgPath.toLowerCase().startsWith(util.pathSepNormalize(`components/`))
             ) {
-                let xmlFile = new XmlFile(pathAbsolute, pkgPath, this);
+                let xmlFile = new XmlFile(srcPath, pkgPath, this);
                 //add the file to the program
-                this.files[pathAbsolute] = xmlFile;
+                this.files[srcPath] = xmlFile;
                 let fileContents: SourceObj = {
-                    pathAbsolute: pathAbsolute,
+                    pathAbsolute: srcPath,
                     source: await getFileContents()
                 };
                 this.plugins.emit('beforeFileParse', fileContents);
@@ -418,11 +417,11 @@ export class Program {
      * with the same path with only case being different.
      * @param pathAbsolute
      */
-    public getFileByPathAbsolute(pathAbsolute: string) {
+    public getFileByPathAbsolute<T extends BrsFile | XmlFile>(pathAbsolute: string) {
         pathAbsolute = s`${pathAbsolute}`;
         for (let filePath in this.files) {
             if (filePath.toLowerCase() === pathAbsolute.toLowerCase()) {
-                return this.files[filePath];
+                return this.files[filePath] as T;
             }
         }
     }
@@ -460,7 +459,10 @@ export class Program {
      * @param pathAbsolute
      */
     public removeFile(pathAbsolute: string) {
-        pathAbsolute = s`${pathAbsolute}`;
+        if (!path.isAbsolute(pathAbsolute)) {
+            throw new Error(`Path must be absolute: "${pathAbsolute}"`);
+        }
+
         let file = this.getFile(pathAbsolute);
         if (file) {
             this.plugins.emit('beforeFileDispose', file);
@@ -476,7 +478,7 @@ export class Program {
                 this.plugins.emit('afterScopeDispose', scope);
             }
             //remove the file from the program
-            delete this.files[pathAbsolute];
+            delete this.files[file.pathAbsolute];
             delete this.pkgMap[file.pkgPath.toLowerCase()];
 
             this.dependencyGraph.remove(file.dependencyGraphKey);
@@ -792,6 +794,13 @@ export class Program {
                 fsExtra.writeFile(outputPath, result.code),
                 writeMapPromise
             ]);
+
+            if (isBrsFile(file) && this.options.emitDefinitions !== false) {
+                const typedef = file.getTypedef();
+                const typedefPath = outputPath.replace(/\.brs$/i, '.d.bs');
+                await fsExtra.writeFile(typedefPath, typedef);
+            }
+
             this.plugins.emit('afterFileTranspile', entry);
         });
 
@@ -843,4 +852,4 @@ export class Program {
     }
 }
 
-export type FileResolver = (pathAbsolute: string) => string | undefined | Thenable<string | undefined>;
+export type FileResolver = (pathAbsolute: string) => string | undefined | Thenable<string | undefined> | void;

src/ProgramBuilder.spec.ts

@@ -12,13 +12,14 @@ import { Range } from '.';
 import { DiagnosticSeverity } from './astUtils';
 import { BrsFile } from './files/BrsFile';
 
-let tmpPath = s`${process.cwd()}/.tmp`;
-let rootDir = s`${tmpPath}/rootDir`;
-let stagingFolderPath = s`${tmpPath}/staging`;
-
 describe('ProgramBuilder', () => {
+
+    let tmpPath = s`${process.cwd()}/.tmp`;
+    let rootDir = s`${tmpPath}/rootDir`;
+    let stagingFolderPath = s`${tmpPath}/staging`;
+
     beforeEach(() => {
-        fsExtra.ensureDirSync(tmpPath);
+        fsExtra.ensureDirSync(rootDir);
         fsExtra.emptyDirSync(tmpPath);
     });
     afterEach(() => {
@@ -28,13 +29,13 @@ describe('ProgramBuilder', () => {
     });
 
     let builder: ProgramBuilder;
-    let b: any;
     beforeEach(async () => {
         builder = new ProgramBuilder();
-        b = builder;
-        b.options = await util.normalizeAndResolveConfig(undefined);
-        b.program = new Program(b.options);
-        b.logger = new Logger();
+        builder.options = await util.normalizeAndResolveConfig({
+            rootDir: rootDir
+        });
+        builder.program = new Program(builder.options);
+        builder.logger = new Logger();
     });
 
     afterEach(() => {
@@ -54,13 +55,45 @@ describe('ProgramBuilder', () => {
                 dest: 'file.xml'
             }]));
 
-            b.program = {
-                addOrReplaceFile: () => { }
-            };
-            let stub = sinon.stub(b.program, 'addOrReplaceFile');
-            await b.loadAllFilesAST();
+            let stub = sinon.stub(builder.program, 'addOrReplaceFile');
+            await builder['loadAllFilesAST']();
             expect(stub.getCalls()).to.be.lengthOf(3);
         });
+
+        it('loads all type definitions first', async () => {
+            const requestedFiles = [] as string[];
+            builder.program.fileResolvers.push((filePath) => {
+                requestedFiles.push(s(filePath));
+            });
+            fsExtra.outputFileSync(s`${rootDir}/source/main.brs`, '');
+            fsExtra.outputFileSync(s`${rootDir}/source/main.d.bs`, '');
+            fsExtra.outputFileSync(s`${rootDir}/source/lib.d.bs`, '');
+            fsExtra.outputFileSync(s`${rootDir}/source/lib.brs`, '');
+            const stub = sinon.stub(builder.program, 'addOrReplaceFile');
+            await builder['loadAllFilesAST']();
+            const srcPaths = stub.getCalls().map(x => x.args[0].src);
+            //the d files should be first
+            expect(srcPaths.indexOf(s`${rootDir}/source/main.d.bs`)).within(0, 1);
+            expect(srcPaths.indexOf(s`${rootDir}/source/lib.d.bs`)).within(0, 1);
+            //the non-d files should be last
+            expect(srcPaths.indexOf(s`${rootDir}/source/main.brs`)).within(2, 3);
+            expect(srcPaths.indexOf(s`${rootDir}/source/lib.brs`)).within(2, 3);
+
+            //the d files should NOT be requested from the FS
+            expect(requestedFiles).not.to.include(s`${rootDir}/source/lib.d.bs`);
+            expect(requestedFiles).not.to.include(s`${rootDir}/source/main.d.bs`);
+        });
+
+        it('does not load non-existent type definition file', async () => {
+            const requestedFiles = [] as string[];
+            builder.program.fileResolvers.push((filePath) => {
+                requestedFiles.push(s(filePath));
+            });
+            fsExtra.outputFileSync(s`${rootDir}/source/main.brs`, '');
+            await builder['loadAllFilesAST']();
+            //the d file should not be requested because `loadAllFilesAST` knows it doesn't exist
+            expect(requestedFiles).not.to.include(s`${rootDir}/source/main.d.bs`);
+        });
     });
 
     describe('run', () => {