brighterscript 0.70.3 → 0.71.0

package/dist/parser/Parser.spec.js

@@ -1190,6 +1190,136 @@ describe('parser', () => {
             (0, chai_config_spec_1.expect)(fn.annotations[0].getArguments()).to.deep.equal([-100]);
         });
     });
+    describe('grouped type expressions', () => {
+        it('is not allowed in brightscript mode', () => {
+            let parser = parse(`
+                sub main(param as (string or integer))
+                    print param
+                end sub
+            `, Parser_1.ParseMode.BrightScript);
+            (0, testHelpers_spec_1.expectDiagnosticsIncludes)(parser.diagnostics, [DiagnosticMessages_1.DiagnosticMessages.functionParameterTypeIsInvalid('param', '(')]);
+        });
+        it('allows group type expressions in parameters', () => {
+            let { diagnostics } = parse(`
+                sub main(param as (string or integer))
+                    print param
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+        it('allows group type expressions in type casts', () => {
+            let { diagnostics } = parse(`
+                sub main(val)
+                    printThing(val as (string or integer))
+                end sub
+                sub printThing(thing as (string or integer))
+                    print thing
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+        it('allows union of grouped type expressions', () => {
+            let { diagnostics } = parse(`
+                sub main(param as (string or integer) or (float or dynamic))
+                    print param
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+        it('allows nested grouped type expressions', () => {
+            let { diagnostics } = parse(`
+                sub main(param as ((string or integer) or (float or dynamic)))
+                    print param
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+        it('allows complicated grouped type expression', () => {
+            let { diagnostics } = parse(`
+                sub main(param as (({name as string} and {age as integer}) or (string and SomeInterface) or Klass and roAssociativeArray) )
+                    print param
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+    });
+    describe('union types', () => {
+        it('is not allowed in brightscript mode', () => {
+            let parser = parse(`
+                sub main(param as string or integer)
+                    print param
+                end sub
+            `, Parser_1.ParseMode.BrightScript);
+            (0, testHelpers_spec_1.expectDiagnosticsIncludes)(parser.diagnostics, [DiagnosticMessages_1.DiagnosticMessages.expectedStatementOrFunctionCallButReceivedExpression()]);
+        });
+        it('allows union types in parameters', () => {
+            let { diagnostics } = parse(`
+                sub main(param as string or integer)
+                    print param
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+        it('allows union types in type casts', () => {
+            let { diagnostics } = parse(`
+                sub main(val)
+                    printThing(val as string or integer)
+                end sub
+                sub printThing(thing as string or integer)
+                    print thing
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+    });
+    describe('intersection types', () => {
+        it('is not allowed in brightscript mode', () => {
+            let parser = parse(`
+                sub main(param as string and integer)
+                    print param
+                end sub
+            `, Parser_1.ParseMode.BrightScript);
+            (0, testHelpers_spec_1.expectDiagnosticsIncludes)(parser.diagnostics, [DiagnosticMessages_1.DiagnosticMessages.expectedStatementOrFunctionCallButReceivedExpression()]);
+        });
+        it('allows intersection types in parameters', () => {
+            let { diagnostics } = parse(`
+                sub main(param as string and integer)
+                    print param
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+        it('allows intersection types in type casts', () => {
+            let { diagnostics } = parse(`
+                sub main(val)
+                    printThing(val as string and integer)
+                end sub
+                sub printThing(thing as string and integer)
+                    print thing
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+        describe('invalid syntax', () => {
+            it('flags union type with missing sides', () => {
+                let { diagnostics } = parse(`
+                    sub main(param as Thing or )
+                        print param
+                    end sub
+                `, Parser_1.ParseMode.BrighterScript);
+                (0, testHelpers_spec_1.expectDiagnostics)(diagnostics, [DiagnosticMessages_1.DiagnosticMessages.expectedIdentifierAfterKeyword('or').message]);
+            });
+            it('flags missing type inside binary type', () => {
+                var _a;
+                let { diagnostics } = parse(`
+                    sub main(param as string or and float)
+                        print param
+                    end sub
+                `, Parser_1.ParseMode.BrighterScript);
+                (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.exist;
+            });
+        });
+    });
     describe('typecast statement', () => {
         it('allows typecast statement ', () => {
             let { ast, diagnostics } = parse(`
@@ -1297,6 +1427,294 @@ describe('parser', () => {
             (0, chai_config_spec_1.expect)(ast.statements[0].func.body.statements[0].name.text).to.eq('alias');
         });
     });
+    describe('type statement', () => {
+        it('allows type statement ', () => {
+            let { ast, diagnostics } = parse(`
+                TYPE x = string
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)((0, reflection_1.isTypeStatement)(ast.statements[0])).to.be.true;
+            const stmt = ast.statements[0];
+            (0, chai_config_spec_1.expect)(stmt.tokens.type.text).to.eq('TYPE');
+            (0, chai_config_spec_1.expect)(stmt.tokens.value).to.exist;
+        });
+        it('is disallowed in brightscript mode', () => {
+            let { diagnostics } = parse(`
+                type x = string
+            `, Parser_1.ParseMode.BrightScript);
+            (0, testHelpers_spec_1.expectDiagnosticsIncludes)(diagnostics, [
+                DiagnosticMessages_1.DiagnosticMessages.bsFeatureNotSupportedInBrsFiles('type statements')
+            ]);
+        });
+        it('disallows `type` for function name', () => {
+            let { diagnostics } = parse(`
+                function type() as integer
+                    return 1
+                end function
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectDiagnostics)(diagnostics, [
+                DiagnosticMessages_1.DiagnosticMessages.cannotUseReservedWordAsIdentifier('type').message
+            ]);
+        });
+        it('disallows `type` for variable name', () => {
+            let { diagnostics } = parse(`
+                function foo() as integer
+                    type = 1
+                    return type
+                end function
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectDiagnostics)(diagnostics, [
+                DiagnosticMessages_1.DiagnosticMessages.cannotUseReservedWordAsIdentifier('type').message
+            ]);
+        });
+        it('has error when rhs is not a type', () => {
+            let { diagnostics } = parse(`
+                type x = 123
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectDiagnostics)(diagnostics, [
+                DiagnosticMessages_1.DiagnosticMessages.expectedIdentifierAfterKeyword('=').message
+            ]);
+        });
+        it('allows type statement with complicated type', () => {
+            let { ast, diagnostics } = parse(`
+                type x = string or CustomKlass or roAssociativeArray
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)((0, reflection_1.isTypeStatement)(ast.statements[0])).to.be.true;
+            const stmt = ast.statements[0];
+            (0, chai_config_spec_1.expect)(stmt.tokens.type.text).to.eq('type');
+            (0, chai_config_spec_1.expect)(stmt.tokens.value).to.exist;
+        });
+    });
+    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
+            `, Parser_1.ParseMode.BrightScript);
+            (0, testHelpers_spec_1.expectDiagnosticsIncludes)(diagnostics, [
+                DiagnosticMessages_1.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
+            `, Parser_1.ParseMode.BrightScript);
+            (0, testHelpers_spec_1.expectDiagnosticsIncludes)(diagnostics, [
+                DiagnosticMessages_1.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
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.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
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.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
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.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
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.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
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.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
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.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
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.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
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.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
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+    });
+    describe('for each with types', () => {
+        it('parses without errors', () => {
+            let { diagnostics } = parse(`
+                function main()
+                    for each item as string in ["a", "b", "c"]
+                        print item
+                    end for
+                end function
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+        it('allows complicated expressions', () => {
+            let { diagnostics } = parse(`
+                function main(data)
+                    for each item as {a as integer or boolean, b as SomeInterface[], c as {id as string} } or string in data
+                        print item
+                    end for
+                end function
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+    });
+    describe('typed functions as types', () => {
+        it('disallowed in brightscript mode', () => {
+            let { diagnostics } = parse(`
+                function test(func as function())
+                    return func()
+                end function
+             `, Parser_1.ParseMode.BrightScript);
+            (0, testHelpers_spec_1.expectDiagnosticsIncludes)(diagnostics, [
+                DiagnosticMessages_1.DiagnosticMessages.unexpectedToken(')')
+            ]);
+        });
+        it('can be passed as param types', () => {
+            let { diagnostics } = parse(`
+                function test(func as function())
+                    return func()
+                end function
+             `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+        it('can have a return type', () => {
+            let { diagnostics } = parse(`
+                function test(func as sub() as integer) as integer
+                    return func()
+                end function
+             `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+        it('can use sub or function', () => {
+            let { diagnostics } = parse(`
+                function test(func as sub() as integer) as integer
+                    return func()
+                end function
+
+                function test2(func as function() as integer) as integer
+                    return func()
+                 end function
+             `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+        it('can have primitive parameters', () => {
+            let { diagnostics } = parse(`
+                function test(func as function(name as string, num as integer) as integer) as integer
+                    return func("hello", 123)
+                end function
+             `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+        it('can have complex parameters', () => {
+            let { diagnostics } = parse(`
+                interface IFace
+                    name as string
+                end interface
+
+                function test(func as function(thing as IFace) as integer) as integer
+                    return func({name: "hello"})
+                end function
+             `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+        it('can have compound parameters', () => {
+            let { diagnostics } = parse(`
+                interface IFace
+                    name as string
+                end interface
+
+                function test(func as function(arg1 as string or integer, arg2 as IFace) as integer) as integer
+                    return func("hello", {name: "hello"})
+                end function
+             `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+        it('can be used as return types', () => {
+            let { diagnostics } = parse(`
+                function test() as function() as integer
+                    return function() as integer
+                        return 123
+                    end function
+                end function
+             `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+        it('can have a union as return type', () => {
+            let { diagnostics } = parse(`
+                type foo = function() as integer or string
+                function test() as foo
+                    return function() as integer
+                        return 123
+                    end function
+                end function
+             `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+    });
 });
 function parse(text, mode) {
     let { tokens } = Lexer_1.Lexer.scan(text);