Backported v1 inline interface syntax (#1592)

Co-authored-by: Bronley Plumb <bronley@gmail.com>

Author: markwpearce

src/files/BrsFile.spec.ts

@@ -4420,6 +4420,24 @@ describe('BrsFile', () => {
                 end sub
             `);
         });
+
+        describe('inline interfaces', () => {
+            it('transpiles to "dynamic"', () => {
+                testTranspile(`
+                    function foo(input as {name as string}) as {id as string}
+                        output as {id as string} = {id: input.name}
+                        return output
+                    end function
+                    `, `
+                    function foo(input as dynamic) as dynamic
+                        output = {
+                            id: input.name
+                        }
+                        return output
+                    end function
+                `);
+            });
+        });
     });
 
     it('allows up to 63 function params', () => {

src/parser/Parser.spec.ts

@@ -9,7 +9,7 @@ import { PrintStatement, FunctionStatement, NamespaceStatement, ImportStatement
 import { Range } from 'vscode-languageserver';
 import { DiagnosticMessages } from '../DiagnosticMessages';
 import { isAliasStatement, isBlock, isCommentStatement, isFunctionStatement, isIfStatement, isIndexedGetExpression, isTypecastStatement } from '../astUtils/reflection';
-import { expectDiagnostics, expectZeroDiagnostics } from '../testHelpers.spec';
+import { expectDiagnostics, expectDiagnosticsIncludes, expectZeroDiagnostics } from '../testHelpers.spec';
 import { BrsTranspileState } from './BrsTranspileState';
 import { SourceNode } from 'source-map';
 import { BrsFile } from '../files/BrsFile';
@@ -1422,6 +1422,131 @@ describe('parser', () => {
             expect(((ast.statements[0] as FunctionStatement).func.body.statements[0] as AssignmentStatement).name.text).to.eq('alias');
         });
     });
+
+    describe('inline interfaces', () => {
+        it('inline interface param types disallowed in brightscript mode', () => {
+            let { diagnostics } = parse(`
+                sub test(foo as {x as string})
+                    print foo.x
+                end sub
+            `, ParseMode.BrightScript);
+            expectDiagnosticsIncludes(diagnostics, [
+                DiagnosticMessages.functionParameterTypeIsInvalid('foo', '{').message
+            ]);
+        });
+
+        it('inline interface return types disallowed in brightscript mode', () => {
+            let { diagnostics } = parse(`
+                function test() as {x as string}
+                    print {x: "hello"}
+                end function
+            `, ParseMode.BrightScript);
+            expectDiagnosticsIncludes(diagnostics, [
+                DiagnosticMessages.invalidFunctionReturnType('{').message
+            ]);
+        });
+
+        it('inline interface as param type', () => {
+            let { ast, diagnostics } = parse(`
+                sub test(foo as {x as string})
+                    print foo.x
+                end sub
+            `, ParseMode.BrighterScript);
+            expectZeroDiagnostics(diagnostics);
+            expect(ast.statements.length).to.eq(1);
+        });
+
+        it('inline interface as return type', () => {
+            let { ast, diagnostics } = parse(`
+               function test() as {x as string}
+                    print {x: "hello"}
+                end function
+            `, ParseMode.BrighterScript);
+            expectZeroDiagnostics(diagnostics);
+            expect(ast.statements.length).to.eq(1);
+        });
+
+        it('parses a big inline interface as param type', () => {
+            let { ast, diagnostics } = parse(`
+                sub test(foo as {
+                    x as string,
+                    y as {a as integer}
+                    z})
+                    print foo.x + y.a.toStr()
+                end sub
+            `, ParseMode.BrighterScript);
+            expectZeroDiagnostics(diagnostics);
+            expect(ast.statements.length).to.eq(1);
+        });
+
+        it('allows optional members', () => {
+            let { ast, diagnostics } = parse(`
+                sub test(p as {x as string, optional y})
+                end sub
+            `, ParseMode.BrighterScript);
+            expectZeroDiagnostics(diagnostics);
+            expect(ast.statements.length).to.eq(1);
+        });
+
+        it('is allowed as typecast', () => {
+            let { diagnostics } = parse(`
+                sub test(p)
+                    print (p as {name as string}).name
+                end sub
+            `, ParseMode.BrighterScript);
+            expectZeroDiagnostics(diagnostics);
+        });
+
+        it('is allowed as class and interface field', () => {
+            let { diagnostics } = parse(`
+                class Klass
+                    x as {name as string}
+                end class
+                interface Iface
+                    y as {age as integer}
+                end interface
+            `, ParseMode.BrighterScript);
+            expectZeroDiagnostics(diagnostics);
+        });
+
+        it('can have custom type as member type', () => {
+            let { diagnostics } = parse(`
+                interface IFace
+                   name as string
+                end interface
+                function test(z as {foo as IFace})
+                    return z.foo.name
+                end function
+            `, ParseMode.BrighterScript);
+            expectZeroDiagnostics(diagnostics);
+        });
+
+        it('can have per-member doc comment', () => {
+            let { diagnostics } = parse(`
+                interface IFace
+                    inline as {
+                        ' comment 1
+                        name as string
+                        ' comment 2
+                        age as integer
+                    }
+                end interface
+                function test(z as {foo as IFace})
+                    return z.foo.inline.name
+                end function
+            `, ParseMode.BrighterScript);
+            expectZeroDiagnostics(diagnostics);
+        });
+
+        it('can have string literals as members', () => {
+            let { diagnostics } = parse(`
+                function test(z as {"this is a stringliteral" as string})
+                    return z["this is a stringliteral"]
+                end function
+            `, ParseMode.BrighterScript);
+            expectZeroDiagnostics(diagnostics);
+        });
+    });
 });
 
 function parse(text: string, mode?: ParseMode) {

src/parser/Parser.ts

@@ -2767,9 +2767,14 @@ export class Parser {
                 typeToken = this.advance();
             } else if (this.options.mode === ParseMode.BrighterScript) {
                 try {
-                    // see if we can get a namespaced identifer
-                    const qualifiedType = this.getNamespacedVariableNameExpression(ignoreDiagnostics);
-                    typeToken = createToken(TokenKind.Identifier, qualifiedType.getName(this.options.mode), qualifiedType.range);
+                    if (this.check(TokenKind.LeftCurlyBrace)) {
+                        // could be an inline interface
+                        typeToken = this.inlineInterface();
+                    } else {
+                        // see if we can get a namespaced identifer
+                        const qualifiedType = this.getNamespacedVariableNameExpression(ignoreDiagnostics);
+                        typeToken = createToken(TokenKind.Identifier, qualifiedType.getName(this.options.mode), qualifiedType.range);
+                    }
                 } catch {
                     //could not get an identifier - just get whatever's next
                     typeToken = this.advance();
@@ -2780,7 +2785,7 @@ export class Parser {
             }
             resultToken = resultToken ?? typeToken;
             if (resultToken && this.options.mode === ParseMode.BrighterScript) {
-                // check for brackets
+                // check for brackets for typed arrays
                 while (this.check(TokenKind.LeftSquareBracket) && this.peekNext().kind === TokenKind.RightSquareBracket) {
                     const leftBracket = this.advance();
                     const rightBracket = this.advance();
@@ -2802,6 +2807,76 @@ export class Parser {
         return resultToken;
     }
 
+    private inlineInterface() {
+        const openToken = this.advance();
+        const memberTokens: Token[] = [];
+        memberTokens.push(openToken);
+        while (this.matchAny(TokenKind.Newline, TokenKind.Comment)) { }
+        while (this.checkAny(TokenKind.Identifier, ...AllowedProperties, TokenKind.StringLiteral, TokenKind.Optional)) {
+            let optionalKeyword = this.consumeTokenIf(TokenKind.Optional);
+            if (this.checkAny(TokenKind.Identifier, ...AllowedProperties, TokenKind.StringLiteral)) {
+                if (this.check(TokenKind.As)) {
+                    if (this.checkAnyNext(TokenKind.Comment, TokenKind.Newline)) {
+                        // as <EOL>
+                        // `as` is the field name
+                    } else if (this.checkNext(TokenKind.As)) {
+                        //  as as ____
+                        // first `as` is the field name
+                    } else if (optionalKeyword) {
+                        // optional as ____
+                        // optional is the field name, `as` starts type
+                        // rewind current token
+                        optionalKeyword = null;
+                        this.current--;
+                    }
+                }
+            } else {
+                // no name after `optional` ... optional is the name
+                // rewind current token
+                optionalKeyword = null;
+                this.current--;
+            }
+            if (optionalKeyword) {
+                memberTokens.push(optionalKeyword);
+            }
+            if (!this.checkAny(TokenKind.Identifier, ...this.allowedLocalIdentifiers, TokenKind.StringLiteral)) {
+                this.diagnostics.push({
+                    ...DiagnosticMessages.unexpectedToken(this.peek().text),
+                    range: this.peek().range
+                });
+                throw this.lastDiagnosticAsError();
+            }
+            if (this.checkAny(TokenKind.Identifier, ...AllowedProperties, TokenKind.StringLiteral)) {
+                this.advance();
+            } else {
+                this.diagnostics.push({
+                    ...DiagnosticMessages.unexpectedToken(this.peek().text),
+                    range: this.peek().range
+                });
+                throw this.lastDiagnosticAsError();
+            }
+
+            if (this.check(TokenKind.As)) {
+                memberTokens.push(this.advance()); // as
+                memberTokens.push(this.typeToken()); // type
+            }
+            while (this.matchAny(TokenKind.Comma, TokenKind.Newline, TokenKind.Comment)) { }
+        }
+        if (!this.check(TokenKind.RightCurlyBrace)) {
+            this.diagnostics.push({
+                ...DiagnosticMessages.unexpectedToken(this.peek().text),
+                range: this.peek().range
+            });
+            throw this.lastDiagnosticAsError();
+        }
+        const closeToken = this.advance();
+        memberTokens.push(closeToken);
+
+        const completeInlineInterfaceToken = createToken(TokenKind.Dynamic, null, util.createBoundingRange(...memberTokens));
+
+        return completeInlineInterfaceToken;
+    }
+
     private primary(): Expression {
         switch (true) {
             case this.matchAny(