brighterscript 1.0.0-alpha.25 → 1.0.0-alpha.26

package/dist/parser/Parser.spec.js

@@ -24,167 +24,6 @@ describe('parser', () => {
             diagnostics: []
         });
     });
-    /*
-        describe.skip('findReferences', () => {
-            it('gets called if references are missing', () => {
-                const parser = Parser.parse(`
-                    sub main()
-                    end sub
-
-                    sub UnusedFunction()
-                    end sub
-                `);
-                expect(parser.references.functionStatements.map(x => x.name.text)).to.eql([
-                    'main',
-                    'UnusedFunction'
-                ]);
-                //simulate a tree-shaking plugin by removing the `UnusedFunction`
-                parser.ast.statements.splice(1);
-                //tell the parser we modified the AST and need to regenerate references
-                parser.invalidateReferences();
-                expect(parser['_references']).not.to.exist;
-                //calling `references` automatically regenerates the references
-                expect(parser.references.functionStatements.map(x => x.name.text)).to.eql([
-                    'main'
-                ]);
-            });
-
-            function expressionsToStrings(expressions: Set<Expression>) {
-                return [...expressions.values()].map(x => {
-                    const file = new BrsFile({
-                        srcPath: '',
-                        destPath: '',
-                        program: new Program({} as any)
-                    });
-                    const state = new BrsTranspileState(file);
-                    return new SourceNode(null, null, null, x.transpile(state)).toString();
-                });
-            }
-
-            // eslint-disable-next-line func-names, prefer-arrow-callback
-            it('works for references.expressions', function () {
-                this.timeout(5000); // this test takes a long time on github
-                const parser = Parser.parse(`
-                    b += "plus-equal"
-                    a += 1 + 2
-                    b += getValue1() + getValue2()
-                    increment++
-                    decrement--
-                    some.node@.doCallfunc()
-                    bravo(3 + 4).jump(callMe())
-                    obj = {
-                        val1: someValue
-                    }
-                    arr = [
-                        one
-                    ]
-                    thing = alpha.bravo
-                    alpha.charlie()
-                    delta(alpha.delta)
-                    call1().a.b.call2()
-                    class Person
-                        name as string = "bob"
-                    end class
-                    function thing(p1 = name.space.getSomething())
-
-                    end function
-                `);
-                const expected = [
-                    '"plus-equal"',
-                    'b',
-                    'b += "plus-equal"',
-                    '1',
-                    '2',
-                    'a',
-                    'a += 1 + 2',
-                    'getValue1()',
-                    'getValue2()',
-                    'b',
-                    'b += getValue1() + getValue2()',
-                    'increment++',
-                    'decrement--',
-                    //currently the "toString" does a transpile, so that's why this is different.
-                    'some.node.callfunc("doCallfunc", invalid)',
-                    '3',
-                    '4',
-                    '3 + 4',
-                    'callMe()',
-                    'bravo(3 + 4).jump(callMe())',
-                    'someValue',
-                    '{\n    val1: someValue\n}',
-                    'one',
-                    '[\n    one\n]',
-                    'alpha.bravo',
-                    'alpha.charlie()',
-                    'alpha.delta',
-                    'delta(alpha.delta)',
-                    'call1().a.b.call2()',
-                    '"bob"',
-                    'name.space.getSomething()'
-                ];
-
-                expect(
-                    expressionsToStrings(parser.references.expressions)
-                ).to.eql(expected);
-
-                //tell the parser we modified the AST and need to regenerate references
-                parser.invalidateReferences();
-
-                expect(
-                    expressionsToStrings(parser.references.expressions).sort()
-                ).to.eql(expected.sort());
-            });
-
-            it('works for references.expressions', () => {
-                const parser = Parser.parse(`
-                    value = true or type(true) = "something" or Enums.A.Value = "value" and Enum1.Value = Name.Space.Enum2.Value
-                `);
-                const expected = [
-                    'true',
-                    'type(true)',
-                    '"something"',
-                    'true',
-                    'Enums.A.Value',
-                    '"value"',
-                    'Enum1.Value',
-                    'Name.Space.Enum2.Value',
-                    'true or type(true) = "something" or Enums.A.Value = "value" and Enum1.Value = Name.Space.Enum2.Value'
-                ];
-
-                expect(
-                    expressionsToStrings(parser.references.expressions)
-                ).to.eql(expected);
-
-                //tell the parser we modified the AST and need to regenerate references
-                parser.invalidateReferences();
-
-                expect(
-                    expressionsToStrings(parser.references.expressions).sort()
-                ).to.eql(expected.sort());
-            });
-
-            it('works for logical expression', () => {
-                const parser = Parser.parse(`
-                    value = Enums.A.Value = "value"
-                `);
-                const expected = [
-                    'Enums.A.Value',
-                    '"value"',
-                    'Enums.A.Value = "value"'
-                ];
-
-                expect(
-                    expressionsToStrings(parser.references.expressions)
-                ).to.eql(expected);
-
-                //tell the parser we modified the AST and need to regenerate references
-                parser.invalidateReferences();
-
-                expect(
-                    expressionsToStrings(parser.references.expressions).sort()
-                ).to.eql(expected.sort());
-            });
-        }); */
     describe('callfunc operator', () => {
         it('is not allowed in brightscript mode', () => {
             var _a;
@@ -221,30 +60,30 @@ describe('parser', () => {
         it('works for ?.', () => {
             const expression = getExpression(`value = person?.name`);
             (0, chai_config_spec_1.expect)(expression).to.be.instanceOf(Expression_1.DottedGetExpression);
-            (0, chai_config_spec_1.expect)(expression.dot.kind).to.eql(TokenKind_1.TokenKind.QuestionDot);
+            (0, chai_config_spec_1.expect)(expression.tokens.dot.kind).to.eql(TokenKind_1.TokenKind.QuestionDot);
         });
         it('works for ?[', () => {
             const expression = getExpression(`value = person?["name"]`, { matcher: reflection_1.isIndexedGetExpression });
             (0, chai_config_spec_1.expect)(expression).to.be.instanceOf(Expression_1.IndexedGetExpression);
-            (0, chai_config_spec_1.expect)(expression.openingSquare.kind).to.eql(TokenKind_1.TokenKind.QuestionLeftSquare);
-            (0, chai_config_spec_1.expect)(expression.questionDotToken).not.to.exist;
+            (0, chai_config_spec_1.expect)(expression.tokens.openingSquare.kind).to.eql(TokenKind_1.TokenKind.QuestionLeftSquare);
+            (0, chai_config_spec_1.expect)(expression.tokens.questionDot).not.to.exist;
         });
         it('works for ?.[', () => {
             var _a;
             const expression = getExpression(`value = person?.["name"]`, { matcher: reflection_1.isIndexedGetExpression });
             (0, chai_config_spec_1.expect)(expression).to.be.instanceOf(Expression_1.IndexedGetExpression);
-            (0, chai_config_spec_1.expect)(expression.openingSquare.kind).to.eql(TokenKind_1.TokenKind.LeftSquareBracket);
-            (0, chai_config_spec_1.expect)((_a = expression.questionDotToken) === null || _a === void 0 ? void 0 : _a.kind).to.eql(TokenKind_1.TokenKind.QuestionDot);
+            (0, chai_config_spec_1.expect)(expression.tokens.openingSquare.kind).to.eql(TokenKind_1.TokenKind.LeftSquareBracket);
+            (0, chai_config_spec_1.expect)((_a = expression.tokens.questionDot) === null || _a === void 0 ? void 0 : _a.kind).to.eql(TokenKind_1.TokenKind.QuestionDot);
         });
         it('works for ?@', () => {
             const expression = getExpression(`value = someXml?@someAttr`);
             (0, chai_config_spec_1.expect)(expression).to.be.instanceOf(Expression_1.XmlAttributeGetExpression);
-            (0, chai_config_spec_1.expect)(expression.at.kind).to.eql(TokenKind_1.TokenKind.QuestionAt);
+            (0, chai_config_spec_1.expect)(expression.tokens.at.kind).to.eql(TokenKind_1.TokenKind.QuestionAt);
         });
         it('works for ?(', () => {
             const expression = getExpression(`value = person.getName?()`);
             (0, chai_config_spec_1.expect)(expression).to.be.instanceOf(Expression_1.CallExpression);
-            (0, chai_config_spec_1.expect)(expression.openingParen.kind).to.eql(TokenKind_1.TokenKind.QuestionLeftParen);
+            (0, chai_config_spec_1.expect)(expression.tokens.openingParen.kind).to.eql(TokenKind_1.TokenKind.QuestionLeftParen);
         });
         it('works for print statements using question mark', () => {
             const { statements } = parse(`
@@ -258,12 +97,12 @@ describe('parser', () => {
         it.skip('works for ?( in anonymous function', () => {
             const expression = getExpression(`thing = (function() : end function)?()`);
             (0, chai_config_spec_1.expect)(expression).to.be.instanceOf(Expression_1.CallExpression);
-            (0, chai_config_spec_1.expect)(expression.openingParen.kind).to.eql(TokenKind_1.TokenKind.QuestionLeftParen);
+            (0, chai_config_spec_1.expect)(expression.tokens.openingParen.kind).to.eql(TokenKind_1.TokenKind.QuestionLeftParen);
         });
         it('works for ?( in new call', () => {
             const expression = getExpression(`thing = new Person?()`, { parseMode: Parser_1.ParseMode.BrighterScript });
             (0, chai_config_spec_1.expect)(expression).to.be.instanceOf(Expression_1.NewExpression);
-            (0, chai_config_spec_1.expect)(expression.call.openingParen.kind).to.eql(TokenKind_1.TokenKind.QuestionLeftParen);
+            (0, chai_config_spec_1.expect)(expression.call.tokens.openingParen.kind).to.eql(TokenKind_1.TokenKind.QuestionLeftParen);
         });
         it('distinguishes between optional chaining and ternary expression', () => {
             const parser = parse(`
@@ -480,14 +319,14 @@ describe('parser', () => {
             let statements = parser.statements[0].func.body.statements;
             let first = statements[0].value;
             (0, chai_config_spec_1.expect)(first).to.be.instanceof(Expression_1.XmlAttributeGetExpression);
-            (0, chai_config_spec_1.expect)(first.name.text).to.equal('firstName');
-            (0, chai_config_spec_1.expect)(first.at.text).to.equal('@');
-            (0, chai_config_spec_1.expect)(first.obj.name.text).to.equal('personXml');
+            (0, chai_config_spec_1.expect)(first.tokens.name.text).to.equal('firstName');
+            (0, chai_config_spec_1.expect)(first.tokens.at.text).to.equal('@');
+            (0, chai_config_spec_1.expect)(first.obj.tokens.name.text).to.equal('personXml');
             let second = statements[1].value;
             (0, chai_config_spec_1.expect)(second).to.be.instanceof(Expression_1.XmlAttributeGetExpression);
-            (0, chai_config_spec_1.expect)(second.name.text).to.equal('age');
-            (0, chai_config_spec_1.expect)(second.at.text).to.equal('@');
-            (0, chai_config_spec_1.expect)(second.obj.name.text).to.equal('firstChild');
+            (0, chai_config_spec_1.expect)(second.tokens.name.text).to.equal('age');
+            (0, chai_config_spec_1.expect)(second.tokens.at.text).to.equal('@');
+            (0, chai_config_spec_1.expect)(second.obj.tokens.name.text).to.equal('firstChild');
         });
         it('does not allow chaining of @ symbols', () => {
             let parser = parse(`
@@ -617,7 +456,7 @@ describe('parser', () => {
                 let stmt = statements[0].func.body.statements[0];
                 (0, chai_config_spec_1.expect)((0, reflection_1.isExpressionStatement)(stmt)).to.be.true;
                 (0, chai_config_spec_1.expect)((0, reflection_1.isVariableExpression)((stmt).expression)).to.be.true;
-                (0, chai_config_spec_1.expect)(stmt.expression.name.text).to.equal('NameA');
+                (0, chai_config_spec_1.expect)(stmt.expression.tokens.name.text).to.equal('NameA');
             });
             it('adds unended call statements', () => {
                 let { tokens } = Lexer_1.Lexer.scan(`
@@ -629,7 +468,7 @@ describe('parser', () => {
                 let stmt = statements[0].func.body.statements[0];
                 (0, chai_config_spec_1.expect)((0, reflection_1.isExpressionStatement)(stmt)).to.be.true;
                 (0, chai_config_spec_1.expect)((0, reflection_1.isCallExpression)((stmt).expression)).to.be.true;
-                (0, chai_config_spec_1.expect)(stmt.expression.callee.name.text).to.equal('lcase');
+                (0, chai_config_spec_1.expect)(stmt.expression.callee.tokens.name.text).to.equal('lcase');
             });
             it('adds unended indexed get statements', () => {
                 let { tokens } = Lexer_1.Lexer.scan(`
@@ -643,7 +482,7 @@ describe('parser', () => {
                 let stmt = statements[0].func.body.statements[0];
                 (0, chai_config_spec_1.expect)((0, reflection_1.isExpressionStatement)(stmt)).to.be.true;
                 (0, chai_config_spec_1.expect)((0, reflection_1.isIndexedGetExpression)((stmt).expression)).to.be.true;
-                (0, chai_config_spec_1.expect)(stmt.expression.obj.name.text).to.equal('nums');
+                (0, chai_config_spec_1.expect)(stmt.expression.obj.tokens.name.text).to.equal('nums');
             });
             it('adds dotted gets', () => {
                 let { tokens } = Lexer_1.Lexer.scan(`
@@ -664,8 +503,8 @@ describe('parser', () => {
                 let stmt = statements[0].func.body.statements[0];
                 (0, chai_config_spec_1.expect)((0, reflection_1.isExpressionStatement)(stmt)).to.be.true;
                 (0, chai_config_spec_1.expect)((0, reflection_1.isDottedGetExpression)((stmt).expression)).to.be.true;
-                (0, chai_config_spec_1.expect)(stmt.expression.obj.name.text).to.equal('a');
-                (0, chai_config_spec_1.expect)(stmt.expression.name.text).to.equal('b');
+                (0, chai_config_spec_1.expect)(stmt.expression.obj.tokens.name.text).to.equal('a');
+                (0, chai_config_spec_1.expect)(stmt.expression.tokens.name.text).to.equal('b');
             });
             it('adds function statement with missing type after as', () => {
                 var _a;
@@ -926,7 +765,7 @@ describe('parser', () => {
                 }), {
                     walkMode: visitors_1.WalkMode.visitAllRecursive
                 });
-                (0, chai_config_spec_1.expect)(elements.map(x => x.keyToken.kind)).to.eql([TokenKind_1.TokenKind.Identifier, TokenKind_1.TokenKind.Identifier]);
+                (0, chai_config_spec_1.expect)(elements.map(x => x.tokens.key.kind)).to.eql([TokenKind_1.TokenKind.Identifier, TokenKind_1.TokenKind.Identifier]);
             });
         });
         it('"end" is not allowed as a local identifier', () => {
@@ -1033,13 +872,13 @@ describe('parser', () => {
             let fn = statements[0];
             (0, chai_config_spec_1.expect)(fn.annotations).to.exist;
             (0, chai_config_spec_1.expect)(fn.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
-            (0, chai_config_spec_1.expect)(fn.annotations[0].nameToken.text).to.equal('meta1');
+            (0, chai_config_spec_1.expect)(fn.annotations[0].tokens.name.text).to.equal('meta1');
             (0, chai_config_spec_1.expect)(fn.annotations[0].name).to.equal('meta1');
             (0, chai_config_spec_1.expect)(statements[1]).to.be.instanceof(Statement_1.FunctionStatement);
             fn = statements[1];
             (0, chai_config_spec_1.expect)(fn.annotations).to.exist;
             (0, chai_config_spec_1.expect)(fn.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
-            (0, chai_config_spec_1.expect)(fn.annotations[0].nameToken.text).to.equal('meta2');
+            (0, chai_config_spec_1.expect)(fn.annotations[0].tokens.name.text).to.equal('meta2');
         });
         it('attaches annotations inside a function body', () => {
             var _a, _b;
@@ -1085,7 +924,7 @@ describe('parser', () => {
             let fn = statements[0];
             (0, chai_config_spec_1.expect)(fn.annotations).to.exist;
             (0, chai_config_spec_1.expect)(fn.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
-            (0, chai_config_spec_1.expect)(fn.annotations[0].nameToken.text).to.equal('meta1');
+            (0, chai_config_spec_1.expect)(fn.annotations[0].tokens.name.text).to.equal('meta1');
             (0, chai_config_spec_1.expect)(fn.annotations[0].call).to.be.instanceof(Expression_1.CallExpression);
         });
         it('attaches annotations to a class', () => {
@@ -1427,6 +1266,24 @@ describe('parser', () => {
             `, Parser_1.ParseMode.BrighterScript);
             (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.exist;
         });
+        it('allows declaring types on assignment in Brighterscript mode', () => {
+            let { diagnostics } = parse(`
+                sub foo()
+                    x as string = formatJson("some string")
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+        it('does not allow declaring types on assignment in brightscript mode', () => {
+            var _a, _b;
+            let { diagnostics } = parse(`
+                sub foo()
+                    x as string = formatJson("some string")
+                end sub
+            `, Parser_1.ParseMode.BrightScript);
+            (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.exist;
+            (0, chai_config_spec_1.expect)((_b = diagnostics[0]) === null || _b === void 0 ? void 0 : _b.message).to.include('typed assignment');
+        });
     });
     describe('union types', () => {
         it('is not allowed in brightscript mode', () => {