/** * @license * Copyright Google LLC All Rights Reserved. * * Use of this source code is governed by an MIT-style license that can be * found in the LICENSE file at https://angular.dev/license */ import {expect} from '@angular/private/testing/matchers'; import { AbsoluteSourceSpan, ArrowFunction, ASTWithSource, BindingPipe, BindingPipeType, Call, EmptyExpr, Interpolation, LiteralMap, LiteralMapPropertyKey, ParseSpan, PropertyRead, TemplateBinding, VariableBinding, } from '../../src/expression_parser/ast'; import {Lexer} from '../../src/expression_parser/lexer'; import {Parser, SplitInterpolation} from '../../src/expression_parser/parser'; import {ParseError} from '../../src/parse_util'; import {getFakeSpan} from './utils/span'; import {unparse, unparseWithSpan} from './utils/unparser'; import {validate} from './utils/validator'; describe('parser', () => { describe('parseAction', () => { it('should parse numbers', () => { checkAction('1'); }); it('should parse strings', () => { checkAction("'1'", '"1"'); checkAction('"1"'); }); it('should parse null', () => { checkAction('null'); }); it('should parse undefined', () => { checkAction('undefined'); }); it('should parse unary - and + expressions', () => { checkAction('-1', '-1'); checkAction('+1', '+1'); checkAction(`-'1'`, `-"1"`); checkAction(`+'1'`, `+"1"`); }); it('should parse unary ! expressions', () => { checkAction('!true'); checkAction('!!true'); checkAction('!!!true'); }); it('should parse postfix ! expression', () => { checkAction('true!'); checkAction('a!.b'); checkAction('a!!!!.b'); checkAction('a!()'); checkAction('a.b!()'); }); it('should parse exponentiation expressions', () => { checkAction('1*2**3', '1 * 2 ** 3'); }); it('should parse multiplicative expressions', () => { checkAction('3*4/2%5', '3 * 4 / 2 % 5'); }); it('should parse additive expressions', () => { checkAction('3 + 6 - 2'); }); it('should parse relational expressions', () => { checkAction('2 < 3'); checkAction('2 > 3'); checkAction('2 <= 2'); checkAction('2 >= 2'); checkAction(`"key" in obj`); checkAction(`foo instanceof Foo`); }); it('should parse equality expressions', () => { checkAction('2 == 3'); checkAction('2 != 3'); }); it('should parse strict equality expressions', () => { checkAction('2 === 3'); checkAction('2 !== 3'); }); it('should parse expressions', () => { checkAction('true && true'); checkAction('true || false'); checkAction('null ?? 0'); checkAction('null ?? undefined ?? 0'); }); it('should parse typeof expression', () => { checkAction(`typeof {} === "object"`); checkAction('(!(typeof {} === "number"))'); }); it('should parse void expression', () => { checkAction(`void 0`); checkAction('(!(void 0))'); }); it('should parse grouped expressions', () => { checkAction('(1 + 2) * 3'); }); it('should parse in expressions', () => { checkAction(`'key' in obj`, `"key" in obj`); checkAction(`('key' in obj) && true`, `("key" in obj) && true`); }); it('should ignore comments in expressions', () => { checkAction('a //comment', 'a'); }); it('should parse instanceof expressions', () => { checkAction(`obj instanceof MyClass`, `obj instanceof MyClass`); checkAction(`(obj instanceof MyClass) || false`, `(obj instanceof MyClass) || false`); }); it('should retain // in string literals', () => { checkAction(`"http://www.google.com"`, `"http://www.google.com"`); }); it('should parse an empty string', () => { checkAction(''); }); it('should parse assignment operators with property reads', () => { checkAction('a = b'); checkAction('a += b'); checkAction('a -= b'); checkAction('a *= b'); checkAction('a /= b'); checkAction('a %= b'); checkAction('a **= b'); checkAction('a &&= b'); checkAction('a ||= b'); checkAction('a ??= b'); }); it('should parse assignment operators with keyed reads', () => { checkAction('a[0] = b'); checkAction('a[0] += b'); checkAction('a[0] -= b'); checkAction('a[0] *= b'); checkAction('a[0] /= b'); checkAction('a[0] %= b'); checkAction('a[0] **= b'); checkAction('a[0] &&= b'); checkAction('a[0] ||= b'); checkAction('a[0] ??= b'); }); describe('literals', () => { it('should parse array', () => { checkAction('[1][0]'); checkAction('[[1]][0][0]'); checkAction('[]'); checkAction('[].length'); checkAction('[1, 2].length'); checkAction('[1, 2,]', '[1, 2]'); }); it('should parse map', () => { checkAction('{}'); checkAction('{a: 1, "b": 2}[2]'); checkAction('{}["a"]'); checkAction('{a: 1, b: 2,}', '{a: 1, b: 2}'); }); it('should only allow identifier, string, or keyword as map key', () => { expectActionError('{(:0}', 'expected identifier, keyword, or string'); expectActionError('{1234:0}', 'expected identifier, keyword, or string'); expectActionError('{#myField:0}', 'expected identifier, keyword or string'); }); it('should parse property shorthand declarations', () => { checkAction('{a, b, c}', '{a: a, b: b, c: c}'); checkAction('{a: 1, b}', '{a: 1, b: b}'); checkAction('{a, b: 1}', '{a: a, b: 1}'); checkAction('{a: 1, b, c: 2}', '{a: 1, b: b, c: 2}'); }); it('should not allow property shorthand declaration on quoted properties', () => { expectActionError('{"a-b"}', 'expected : at column 7'); }); it('should not infer invalid identifiers as shorthand property declarations', () => { expectActionError('{a.b}', 'expected } at column 3'); expectActionError('{a["b"]}', 'expected } at column 3'); expectActionError('{1234}', ' expected identifier, keyword, or string at column 2'); }); it('should parse spread assignments in object literals', () => { checkAction('{...foo}'); checkAction('{one: 1, ...foo, two: 2}'); checkAction('{...foo, middle: true, ...bar}'); checkAction('{...{...{...{foo: 1}}}}'); }); it('should spread elements in array literals', () => { checkAction('[...foo]'); checkAction('[1, ...foo, 2]'); checkAction('[...foo, middle, ...bar]'); checkAction('[...[...[...[1]]]]'); checkAction('[a, ...b, ...[1, 2, 3]]'); }); }); describe('member access', () => { it('should parse field access', () => { checkAction('a'); checkAction('this.a', 'a'); checkAction('a.a'); }); it('should error for private identifiers with implicit receiver', () => { checkActionWithError( '#privateField', '', 'Private identifiers are not supported. Unexpected private identifier: #privateField at column 1', ); }); it('should only allow identifier or keyword as member names', () => { checkActionWithError('x.', 'x.', 'identifier or keyword'); checkActionWithError('x.(', 'x.', 'identifier or keyword'); checkActionWithError('x. 1234', 'x.', 'identifier or keyword'); checkActionWithError('x."foo"', 'x.', 'identifier or keyword'); checkActionWithError( 'x.#privateField', 'x.', 'Private identifiers are not supported. Unexpected private identifier: #privateField, expected identifier or keyword', ); }); it('should parse safe field access', () => { checkAction('a?.a'); checkAction('a.a?.a'); }); it('should parse incomplete safe field accesses', () => { checkActionWithError('a?.a.', 'a?.a.', 'identifier or keyword'); checkActionWithError('a.a?.a.', 'a.a?.a.', 'identifier or keyword'); checkActionWithError('a.a?.a?. 1234', 'a.a?.a?.', 'identifier or keyword'); }); }); describe('property write', () => { it('should parse property writes', () => { checkAction('a.a = 1 + 2'); checkAction('this.a.a = 1 + 2', 'a.a = 1 + 2'); checkAction('a.a.a = 1 + 2'); }); describe('malformed property writes', () => { it('should recover on empty rvalues', () => { checkActionWithError('a.a = ', 'a.a = ', 'Unexpected end of expression'); }); it('should recover on incomplete rvalues', () => { checkActionWithError('a.a = 1 + ', 'a.a = 1 + ', 'Unexpected end of expression'); }); it('should recover on missing properties', () => { checkActionWithError( 'a. = 1', 'a. = 1', 'Expected identifier for property access at column 2', ); }); it('should error on writes after a property write', () => { const ast = parseAction('a.a = 1 = 2'); expect(unparse(ast)).toEqual('a.a = 1'); validate(ast); expect(ast.errors.length).toBe(1); expect(ast.errors[0].msg).toContain("Unexpected token '='"); }); }); }); describe('calls', () => { it('should parse calls', () => { checkAction('fn()'); checkAction('add(1, 2)'); checkAction('a.add(1, 2)'); checkAction('fn().add(1, 2)'); checkAction('fn()(1, 2)'); }); it('should parse an EmptyExpr with a correct span for a trailing empty argument', () => { const ast = parseAction('fn(1, )').ast as Call; expect(ast.args[1]).toBeInstanceOf(EmptyExpr); const sourceSpan = (ast.args[1] as EmptyExpr).sourceSpan; expect([sourceSpan.start, sourceSpan.end]).toEqual([5, 6]); }); it('should parse safe calls', () => { checkAction('fn?.()'); checkAction('add?.(1, 2)'); checkAction('a.add?.(1, 2)'); checkAction('a?.add?.(1, 2)'); checkAction('fn?.().add?.(1, 2)'); checkAction('fn?.()?.(1, 2)'); }); it('should parse rest arguments in calls', () => { checkAction('fn(...foo)'); checkAction('fn(1, ...foo, 2)'); checkAction('fn(...foo, middle, ...bar)'); checkAction('fn(a, ...b, ...[1, 2, 3])'); }); it('should parse rest arguments in safe calls', () => { checkAction('fn?.(...foo)'); checkAction('fn?.(1, ...foo, 2)'); checkAction('fn?.(...foo, middle, ...bar)'); checkAction('fn?.(a, ...b, ...[1, 2, 3])'); }); }); describe('keyed read', () => { it('should parse keyed reads', () => { checkBinding('a["a"]'); checkBinding('this.a["a"]', 'a["a"]'); checkBinding('a.a["a"]'); }); it('should parse safe keyed reads', () => { checkBinding('a?.["a"]'); checkBinding('this.a?.["a"]', 'a?.["a"]'); checkBinding('a.a?.["a"]'); checkBinding('a.a?.["a" | foo]', 'a.a?.[("a" | foo)]'); }); describe('malformed keyed reads', () => { it('should recover on missing keys', () => { checkActionWithError('a[]', 'a[]', 'Key access cannot be empty'); }); it('should recover on incomplete expression keys', () => { checkActionWithError('a[1 + ]', 'a[1 + ]', 'Unexpected token ]'); }); it('should recover on unterminated keys', () => { checkActionWithError( 'a[1 + 2', 'a[1 + 2]', 'Missing expected ] at the end of the expression', ); }); it('should recover on incomplete and unterminated keys', () => { checkActionWithError( 'a[1 + ', 'a[1 + ]', 'Missing expected ] at the end of the expression', ); }); }); }); describe('keyed write', () => { it('should parse keyed writes', () => { checkAction('a["a"] = 1 + 2'); checkAction('this.a["a"] = 1 + 2', 'a["a"] = 1 + 2'); checkAction('a.a["a"] = 1 + 2'); }); it('should report on safe keyed writes', () => { expectActionError('a?.["a"] = 123', 'cannot be used in the assignment'); }); describe('malformed keyed writes', () => { it('should recover on empty rvalues', () => { checkActionWithError('a["a"] = ', 'a["a"] = ', 'Unexpected end of expression'); }); it('should recover on incomplete rvalues', () => { checkActionWithError('a["a"] = 1 + ', 'a["a"] = 1 + ', 'Unexpected end of expression'); }); it('should recover on missing keys', () => { checkActionWithError('a[] = 1', 'a[] = 1', 'Key access cannot be empty'); }); it('should recover on incomplete expression keys', () => { checkActionWithError('a[1 + ] = 1', 'a[1 + ] = 1', 'Unexpected token ]'); }); it('should recover on unterminated keys', () => { checkActionWithError('a[1 + 2 = 1', 'a[1 + 2] = 1', 'Missing expected ]'); }); it('should recover on incomplete and unterminated keys', () => { const ast = parseAction('a[1 + = 1'); expect(unparse(ast)).toEqual('a[1 + ] = 1'); validate(ast); const errors = ast.errors.map((e) => e.msg); expect(errors.length).toBe(2); expect(errors[0]).toContain('Unexpected token ='); expect(errors[1]).toContain('Missing expected ]'); }); it('should error on writes after a keyed write', () => { const ast = parseAction('a[1] = 1 = 2'); expect(unparse(ast)).toEqual('a[1] = 1'); validate(ast); expect(ast.errors.length).toBe(1); expect(ast.errors[0].msg).toContain("Unexpected token '='"); }); it('should recover on parenthesized empty rvalues', () => { const ast = parseAction('(a[1] = b) = c = d'); expect(unparse(ast)).toEqual('(a[1] = b)'); validate(ast); expect(ast.errors.length).toBe(1); expect(ast.errors[0].msg).toContain("Unexpected token '='"); }); }); }); describe('conditional', () => { it('should parse ternary/conditional expressions', () => { checkAction('7 == 3 + 4 ? 10 : 20'); checkAction('false ? 10 : 20'); }); it('should report incorrect ternary operator syntax', () => { expectActionError('true?1', 'Conditional expression true?1 requires all 3 expressions'); }); }); describe('assignment', () => { it('should support field assignments', () => { checkAction('a = 12'); checkAction('a.a.a = 123'); checkAction('a = 123; b = 234;'); }); it('should report on safe field assignments', () => { expectActionError('a?.a = 123', 'cannot be used in the assignment'); }); it('should support array updates', () => { checkAction('a[0] = 200'); }); }); it('should error when using pipes', () => { expectActionError('x|blah', 'Cannot have a pipe'); }); it('should report when encountering interpolation', () => { expectActionError('{{a()}}', 'Got interpolation ({{}}) where expression was expected'); }); it('should not report interpolation inside a string', () => { expect(parseAction(`"{{a()}}"`).errors).toEqual([]); expect(parseAction(`'{{a()}}'`).errors).toEqual([]); expect(parseAction(`"{{a('\\"')}}"`).errors).toEqual([]); expect(parseAction(`'{{a("\\'")}}'`).errors).toEqual([]); }); describe('template literals', () => { it('should parse template literals without interpolations', () => { checkBinding('`hello world`'); checkBinding('`foo $`'); checkBinding('`foo }`'); checkBinding('`foo $ {}`'); }); it('should parse template literals with interpolations', () => { checkBinding('`hello ${name}`'); checkBinding('`${name} Johnson`'); checkBinding('`foo${bar}baz`'); checkBinding('`${a} - ${b} - ${c}`'); checkBinding('`foo ${{$: true}} baz`'); checkBinding('`foo ${`hello ${`${a} - b`}`} baz`'); checkBinding('[`hello ${name}`, `see ${name} later`]'); checkBinding('`hello ${name}` + 123'); }); it('should parse template literals with pipes inside interpolations', () => { checkBinding('`hello ${name | capitalize}!!!`', '`hello ${(name | capitalize)}!!!`'); checkBinding('`hello ${(name | capitalize)}!!!`', '`hello ${((name | capitalize))}!!!`'); }); it('should parse template literals in objects literals', () => { checkBinding('{"a": `${name}`}'); checkBinding('{"a": `hello ${name}!`}'); checkBinding('{"a": `hello ${`hello ${`hello`}`}!`}'); checkBinding('{"a": `hello ${{"b": `hello`}}`}'); }); it('should report error if interpolation is empty', () => { expectBindingError('`hello ${}`', 'Template literal interpolation cannot be empty'); }); it('should parse tagged template literals with no interpolations', () => { checkBinding('tag`hello!`'); checkBinding('tags.first`hello!`'); checkBinding('tags[0]`hello!`'); checkBinding('tag()`hello!`'); checkBinding('(tag ?? otherTag)`hello!`'); checkBinding('tag!`hello!`'); }); it('should parse tagged template literals with interpolations', () => { checkBinding('tag`hello ${name}!`'); checkBinding('tags.first`hello ${name}!`'); checkBinding('tags[0]`hello ${name}!`'); checkBinding('tag()`hello ${name}!`'); checkBinding('(tag ?? otherTag)`hello ${name}!`'); checkBinding('tag!`hello ${name}!`'); }); it('should not mistake operator for tagged literal tag', () => { checkBinding('typeof `hello!`'); checkBinding('typeof `hello ${name}!`'); }); }); describe('regular expression literals', () => { it('should parse a regular expression literal without flags', () => { checkBinding('/abc/'); checkBinding('/[a/]$/'); checkBinding('/a\\w+/'); checkBinding('/^http:\\/\\/foo\\.bar/'); }); it('should parse a regular expression literal with flags', () => { checkBinding('/abc/g'); checkBinding('/[a/]$/gi'); checkBinding('/a\\w+/gim'); checkBinding('/^http:\\/\\/foo\\.bar/i'); }); it('should parse a regular expression that is a part of other expressions', () => { checkBinding('/abc/.test("foo")'); checkBinding('"foo".match(/(abc)/)[1].toUpperCase()'); checkBinding('/abc/.test("foo") && something || somethingElse'); }); it('should report invalid regular expression flag', () => { expectBindingError('"foo".match(/abc/O)', 'Unsupported regular expression flag "O"'); }); it('should report duplicated regular expression flags', () => { expectBindingError('"foo".match(/abc/gig)', 'Duplicate regular expression flag "g"'); }); }); }); describe('parse spans', () => { it('should record property read span', () => { const ast = parseAction('foo'); expect(unparseWithSpan(ast)).toContain(['foo', 'foo']); expect(unparseWithSpan(ast)).toContain(['foo', '[nameSpan] foo']); }); it('should record accessed property read span', () => { const ast = parseAction('foo.bar'); expect(unparseWithSpan(ast)).toContain(['foo.bar', 'foo.bar']); expect(unparseWithSpan(ast)).toContain(['foo.bar', '[nameSpan] bar']); }); it('should record safe property read span', () => { const ast = parseAction('foo?.bar'); expect(unparseWithSpan(ast)).toContain(['foo?.bar', 'foo?.bar']); expect(unparseWithSpan(ast)).toContain(['foo?.bar', '[nameSpan] bar']); }); it('should record call span', () => { const ast = parseAction('foo()'); expect(unparseWithSpan(ast)).toContain(['foo()', 'foo()']); expect(unparseWithSpan(ast)).toContain(['foo()', '[argumentSpan] ']); expect(unparseWithSpan(ast)).toContain(['foo', '[nameSpan] foo']); }); it('should record call argument span', () => { const ast = parseAction('foo(1 + 2)'); expect(unparseWithSpan(ast)).toContain(['foo(1 + 2)', '[argumentSpan] 1 + 2']); }); it('should record accessed call span', () => { const ast = parseAction('foo.bar()'); expect(unparseWithSpan(ast)).toContain(['foo.bar()', 'foo.bar()']); expect(unparseWithSpan(ast)).toContain(['foo.bar', '[nameSpan] bar']); }); it('should record property write span', () => { const ast = parseAction('a = b'); expect(unparseWithSpan(ast)).toContain(['a = b', 'a = b']); expect(unparseWithSpan(ast)).toContain(['a', '[nameSpan] a']); }); it('should record accessed property write span', () => { const ast = parseAction('a.b = c'); expect(unparseWithSpan(ast)).toContain(['a.b = c', 'a.b = c']); expect(unparseWithSpan(ast)).toContain(['a.b', '[nameSpan] b']); }); it('should record spans for untagged template literals with no interpolations', () => { const ast = parseAction('`hello world`'); const unparsed = unparseWithSpan(ast); expect(unparsed).toEqual([ ['`hello world`', '`hello world`'], ['hello world', '`hello world`'], ]); }); it('should record spans for untagged template literals with interpolations', () => { const ast = parseAction('`before ${one} - ${two} - ${three} after`'); const unparsed = unparseWithSpan(ast); expect(unparsed).toEqual([ ['`before ${one} - ${two} - ${three} after`', '`before ${one} - ${two} - ${three} after`'], ['before ', '`before '], ['one', 'one'], ['one', '[nameSpan] one'], ['', ''], // Implicit receiver [' - ', ' - '], ['two', 'two'], ['two', '[nameSpan] two'], ['', ''], // Implicit receiver [' - ', ' - '], ['three', 'three'], ['three', '[nameSpan] three'], ['', ''], // Implicit receiver [' after', ' after`'], ]); }); it('should record spans for tagged template literal with no interpolations', () => { const ast = parseAction('tag`text`'); const unparsed = unparseWithSpan(ast); expect(unparsed).toEqual([ ['tag`text`', 'tag`text`'], ['tag', 'tag'], ['tag', '[nameSpan] tag'], ['', ''], // Implicit receiver ['`text`', '`text`'], ['text', '`text`'], ]); }); it('should record spans for tagged template literal with interpolations', () => { const ast = parseAction('tag`before ${one} - ${two} - ${three} after`'); const unparsed = unparseWithSpan(ast); expect(unparsed).toEqual([ [ 'tag`before ${one} - ${two} - ${three} after`', 'tag`before ${one} - ${two} - ${three} after`', ], ['tag', 'tag'], ['tag', '[nameSpan] tag'], ['', ''], // Implicit receiver ['`before ${one} - ${two} - ${three} after`', '`before ${one} - ${two} - ${three} after`'], ['before ', '`before '], ['one', 'one'], ['one', '[nameSpan] one'], ['', ''], // Implicit receiver [' - ', ' - '], ['two', 'two'], ['two', '[nameSpan] two'], ['', ''], // Implicit receiver [' - ', ' - '], ['three', 'three'], ['three', '[nameSpan] three'], ['', ''], // Implicit receiver [' after', ' after`'], ]); }); it('should record spans for binary assignment operations', () => { expect(unparseWithSpan(parseAction('a.b ??= c'))).toEqual([ ['a.b ??= c', 'a.b ??= c'], ['a.b', 'a.b'], ['a.b', '[nameSpan] b'], ['a', 'a'], ['a', '[nameSpan] a'], ['', ''], ['c', 'c'], ['c', '[nameSpan] c'], ['', ' '], ]); expect(unparseWithSpan(parseAction('a[b] ||= c'))).toEqual([ ['a[b] ||= c', 'a[b] ||= c'], ['a[b]', 'a[b]'], ['a', 'a'], ['a', '[nameSpan] a'], ['', ''], ['b', 'b'], ['b', '[nameSpan] b'], ['', ''], ['c', 'c'], ['c', '[nameSpan] c'], ['', ' '], ]); }); it('should include parenthesis in spans', () => { // When a LHS expression is parenthesized, the parenthesis on the left used to be // excluded from the span. This test verifies that the parenthesis are properly included // in the span for both LHS and RHS expressions. // https://github.com/angular/angular/issues/40721 expectSpan('(foo) && (bar)'); expectSpan('(foo) || (bar)'); expectSpan('(foo) == (bar)'); expectSpan('(foo) === (bar)'); expectSpan('(foo) != (bar)'); expectSpan('(foo) !== (bar)'); expectSpan('(foo) > (bar)'); expectSpan('(foo) >= (bar)'); expectSpan('(foo) < (bar)'); expectSpan('(foo) <= (bar)'); expectSpan('(foo) + (bar)'); expectSpan('(foo) - (bar)'); expectSpan('(foo) * (bar)'); expectSpan('(foo) / (bar)'); expectSpan('(foo) % (bar)'); expectSpan('(foo) | pipe'); expectSpan('(foo)()'); expectSpan('(foo).bar'); expectSpan('(foo)?.bar'); expectSpan('(foo).bar = (baz)'); expectSpan('(foo | pipe) == false'); expectSpan('(((foo) && bar) || baz) === true'); function expectSpan(input: string) { expect(unparseWithSpan(parseBinding(input))).toContain([jasmine.any(String), input]); } }); it('should produce correct span for typeof expression', () => { const ast = parseAction('foo = typeof bar'); expect(unparseWithSpan(ast)).toEqual([ ['foo = typeof bar', 'foo = typeof bar'], ['foo', 'foo'], ['foo', '[nameSpan] foo'], ['', ''], ['typeof bar', 'typeof bar'], ['bar', 'bar'], ['bar', '[nameSpan] bar'], ['', ' '], ]); }); it('should produce correct span for void expression', () => { const ast = parseAction('foo = void bar'); expect(unparseWithSpan(ast)).toEqual([ ['foo = void bar', 'foo = void bar'], ['foo', 'foo'], ['foo', '[nameSpan] foo'], ['', ''], ['void bar', 'void bar'], ['bar', 'bar'], ['bar', '[nameSpan] bar'], ['', ' '], ]); }); it('should record span for a regex without flags', () => { const ast = parseBinding('/^http:\\/\\/foo\\.bar/'); expect(unparseWithSpan(ast)).toContain([ '/^http:\\/\\/foo\\.bar/', '/^http:\\/\\/foo\\.bar/', ]); }); it('should record span for a regex with flags', () => { const ast = parseBinding('/^http:\\/\\/foo\\.bar/gim'); expect(unparseWithSpan(ast)).toContain([ '/^http:\\/\\/foo\\.bar/gim', '/^http:\\/\\/foo\\.bar/gim', ]); }); it('should record span for literal map keys', () => { const ast = parseBinding('{one: 1, two: "the number two", three, "four": 4, ...five}'); const literal = ast.ast as LiteralMap; const getSource = (span: ParseSpan) => ast.source?.substring(span.start, span.end); expect(getSource(literal.keys[0].span)).toBe('one'); expect(getSource(literal.keys[1].span)).toBe('two'); expect(getSource(literal.keys[2].span)).toBe('three'); expect(getSource(literal.keys[3].span)).toBe('"four"'); expect(getSource(literal.keys[4].span)).toBe('...'); }); it('should record span for spread elements', () => { expect(unparseWithSpan(parseBinding('[...foo]'))).toEqual([ ['[...foo]', '[...foo]'], ['...foo', '...foo'], ['foo', 'foo'], ['foo', '[nameSpan] foo'], ['', ''], ]); }); it('should record span for rest arguments in functions', () => { expect(unparseWithSpan(parseBinding('fn(1, ...foo)'))).toEqual([ ['fn(1, ...foo)', 'fn(1, ...foo)'], ['fn(1, ...foo)', '[argumentSpan] 1, ...foo'], ['fn', 'fn'], ['fn', '[nameSpan] fn'], ['', ''], ['1', '1'], ['...foo', '...foo'], ['foo', 'foo'], ['foo', '[nameSpan] foo'], ['', ''], ]); }); }); describe('general error handling', () => { it('should report an unexpected token', () => { expectActionError('[1,2] trac', "Unexpected token 'trac'"); }); it('should report reasonable error for unconsumed tokens', () => { expectActionError(')', 'Unexpected token ) at column 1 in [)]'); }); it('should report a missing expected token', () => { expectActionError('a(b', 'Missing expected ) at the end of the expression [a(b]'); }); it('should report a single error for an `as` expression inside a parenthesized expression', () => { expectActionError( `foo(($event.target as HTMLElement).value)`, 'Missing closing parentheses at column 20', 1, ); expectActionError( `foo(((($event.target as HTMLElement))).value)`, 'Missing closing parentheses at column 22', 1, ); }); }); describe('parseBinding', () => { describe('pipes', () => { it('should parse pipes', () => { checkBinding('a(b | c)', 'a((b | c))'); checkBinding('a.b(c.d(e) | f)', 'a.b((c.d(e) | f))'); checkBinding('[1, 2, 3] | a', '([1, 2, 3] | a)'); checkBinding('{a: 1, "b": 2} | c', '({a: 1, "b": 2} | c)'); checkBinding('a[b] | c', '(a[b] | c)'); checkBinding('a?.b | c', '(a?.b | c)'); checkBinding('true | a', '(true | a)'); checkBinding('a | b:c | d', '((a | b:c) | d)'); checkBinding('a | b:(c | d)', '(a | b:((c | d)))'); }); describe('should parse incomplete pipes', () => { const cases: Array<[string, string, string, string]> = [ [ 'should parse missing pipe names: end', 'a | b | ', '((a | b) | )', 'Unexpected end of input, expected identifier or keyword', ], [ 'should parse missing pipe names: middle', 'a | | b', '((a | ) | b)', 'Unexpected token |, expected identifier or keyword', ], [ 'should parse missing pipe names: start', ' | a | b', '(( | a) | b)', 'Unexpected token |', ], [ 'should parse missing pipe args: end', 'a | b | c: ', '((a | b) | c:)', 'Unexpected end of expression', ], [ 'should parse missing pipe args: middle', 'a | b: | c', '((a | b:) | c)', 'Unexpected token |', ], [ 'should parse incomplete pipe args', 'a | b: (a | ) + | c', '((a | b:((a | )) + ) | c)', 'Unexpected token |', ], ]; for (const [name, input, output, err] of cases) { it(name, () => { checkBinding(input, output); expectBindingError(input, err); }); } it('should parse an incomplete pipe with a source span that includes trailing whitespace', () => { const bindingText = 'foo | '; const binding = parseBinding(bindingText).ast as BindingPipe; // The sourceSpan should include all characters of the input. expect(rawSpan(binding.sourceSpan)).toEqual([0, bindingText.length]); // The nameSpan should be positioned at the end of the input. expect(rawSpan(binding.nameSpan)).toEqual([bindingText.length, bindingText.length]); }); it('should parse pipes with the correct type when supportsDirectPipeReferences is enabled', () => { expect((parseBinding('0 | Foo', true).ast as BindingPipe).type).toBe( BindingPipeType.ReferencedDirectly, ); expect((parseBinding('0 | foo', true).ast as BindingPipe).type).toBe( BindingPipeType.ReferencedByName, ); }); it('should parse pipes with the correct type when supportsDirectPipeReferences is disabled', () => { expect((parseBinding('0 | Foo', false).ast as BindingPipe).type).toBe( BindingPipeType.ReferencedByName, ); expect((parseBinding('0 | foo', false).ast as BindingPipe).type).toBe( BindingPipeType.ReferencedByName, ); }); }); it('should only allow identifier or keyword as formatter names', () => { expectBindingError('"Foo"|(', 'identifier or keyword'); expectBindingError('"Foo"|1234', 'identifier or keyword'); expectBindingError('"Foo"|"uppercase"', 'identifier or keyword'); expectBindingError('"Foo"|#privateIdentifier"', 'identifier or keyword'); }); it('should not crash when prefix part is not tokenizable', () => { checkBinding('"a:b"', '"a:b"'); }); }); it('should store the source in the result', () => { expect(parseBinding('someExpr').source).toBe('someExpr'); }); it('should report chain expressions', () => { expectError(parseBinding('1;2'), 'contain chained expression'); }); it('should report assignment', () => { expectError(parseBinding('a=2'), 'contain assignments'); }); it('should report when encountering interpolation', () => { expectBindingError('{{a.b}}', 'Got interpolation ({{}}) where expression was expected'); }); it('should not report interpolation inside a string', () => { expect(parseBinding(`"{{exp}}"`).errors).toEqual([]); expect(parseBinding(`'{{exp}}'`).errors).toEqual([]); expect(parseBinding(`'{{\\"}}'`).errors).toEqual([]); expect(parseBinding(`'{{\\'}}'`).errors).toEqual([]); }); it('should parse conditional expression', () => { checkBinding('a < b ? a : b'); }); it('should ignore comments in bindings', () => { checkBinding('a //comment', 'a'); }); it('should retain // in string literals', () => { checkBinding(`"http://www.google.com"`, `"http://www.google.com"`); }); it('should expose object shorthand information in AST', () => { const parser = new Parser(new Lexer()); const ast = parser.parseBinding('{bla}', getFakeSpan(), 0); const map = ast.ast as LiteralMap; expect(map instanceof LiteralMap).toBe(true); expect(map.keys.length).toBe(1); expect((map.keys[0] as LiteralMapPropertyKey).isShorthandInitialized).toBe(true); }); describe('arrow functions', () => { it('should parse a single-parameter arrow function', () => { checkBinding('a => a'); }); it('should parse a single-parameter arrow function with parentheses', () => { checkBinding('(a) => a', 'a => a'); }); it('should parse an arrow function with not parameters', () => { checkBinding('() => 1'); }); it('should parse an arrow function with multiple parameters', () => { checkBinding('(a, b, c, d, e) => a / b + c * d'); }); it('should parse an immediately-invoked arrow function', () => { checkBinding('((a, b) => a + b)(1, 2)'); }); it('should parse an arrow function that returns other arrow functions', () => { checkBinding('(a, b) => c => (d, e) => () => a + b + c + d + e'); }); it('should parse an arrow function that returns an object literal', () => { checkBinding('() => ({a: 1, b: 2})'); }); it('should parse an arrow function containing an assignment', () => { checkBinding('(a, b) => c = a + b'); }); it('should be able to pass an arrow function through a pipe', () => { checkBinding('(a, b) => a + b | pipe', '((a, b) => a + b | pipe)'); }); it('should parse an arrow function that returns an array', () => { checkBinding('(a, b) => [a, b, foo]'); }); describe('arrow function spans', () => { it('should produce spans for the entire arrow function', () => { expect(unparseWithSpan(parseBinding('a => a'))).toEqual([ ['a => a', 'a => a'], ['a', 'a'], ['a', '[nameSpan] a'], ['', ' '], ]); expect(unparseWithSpan(parseBinding('(a, b, c) => a + b + c'))).toEqual([ ['(a, b, c) => a + b + c', '(a, b, c) => a + b + c'], ['a + b + c', 'a + b + c'], ['a + b', 'a + b'], ['a', 'a'], ['a', '[nameSpan] a'], ['', ' '], ['b', 'b'], ['b', '[nameSpan] b'], ['', ' '], ['c', 'c'], ['c', '[nameSpan] c'], ['', ' '], ]); }); it('should produce spans for the arrow function parameters', () => { const ast = parseBinding('(foo, bar, baz) => foo + bar + baz'); const arrowFn = ast.ast as ArrowFunction; const getSource = (span: ParseSpan) => ast.source?.substring(span.start, span.end); expect(getSource(arrowFn.parameters[0].span)).toBe('foo'); expect(getSource(arrowFn.parameters[1].span)).toBe('bar'); expect(getSource(arrowFn.parameters[2].span)).toBe('baz'); }); }); describe('arrow function validations', () => { it('should not allow pipe to be used inside an arrow function', () => { expectBindingError( '(a, b) => (a + b | pipe)', 'Cannot have a pipe in an action expression', ); }); it('should report an error for an arrow function with a body', () => { expectBindingError('() => {}', 'Multi-line arrow functions are not supported'); }); it('should report missing comma between arrow function parameters', () => { expectBindingError('(a b) => a + b', 'Missing expected ,'); }); it('should report arrow function parameter starting with a comma', () => { expectBindingError('(, a) => a', 'Unexpected token ,'); }); it('should report arrow function parameter with a trailing comma', () => { expectBindingError('(a, ) => a', 'Unexpected token )'); }); it('should report an arrow function without a closing paren', () => { expectBindingError( '(a => a + 1', 'Missing closing parentheses at the end of the expression', ); }); it('should report an arrow function without an opening paren', () => { expectBindingError('a) => a + 1', "Unexpected token ')'"); }); it('should report an error inside the arrow function expression', () => { expectBindingError('(a) => a. + 1', 'Unexpected token +, expected identifier or keyword'); }); it('should report an error for chained expression in arrow function', () => { expectBindingError( '() => foo(); bar()', 'Binding expression cannot contain chained expression', ); expectBindingError( '() => (foo; bar)', 'Binding expression cannot contain chained expression', ); }); }); }); }); describe('parseTemplateBindings', () => { function humanize(bindings: TemplateBinding[]): Array<[string, string | null, boolean]> { return bindings.map((binding) => { const key = binding.key.source; const value = binding.value ? binding.value.source : null; const keyIsVar = binding instanceof VariableBinding; return [key, value, keyIsVar]; }); } function humanizeSpans( bindings: TemplateBinding[], attr: string, ): Array<[string, string, string | null]> { return bindings.map((binding) => { const {sourceSpan, key, value} = binding; const sourceStr = attr.substring(sourceSpan.start, sourceSpan.end); const keyStr = attr.substring(key.span.start, key.span.end); let valueStr = null; if (value) { const {start, end} = value instanceof ASTWithSource ? value.ast.sourceSpan : value.span; valueStr = attr.substring(start, end); } return [sourceStr, keyStr, valueStr]; }); } it('should parse key and value', () => { const cases: Array<[string, string, string | null, boolean, string, string, string | null]> = [ // expression, key, value, VariableBinding, source span, key span, value span ['*a=""', 'a', null, false, 'a="', 'a', null], ['*a="b"', 'a', 'b', false, 'a="b', 'a', 'b'], ['*a-b="c"', 'a-b', 'c', false, 'a-b="c', 'a-b', 'c'], ['*a="1+1"', 'a', '1+1', false, 'a="1+1', 'a', '1+1'], ]; for (const [attr, key, value, keyIsVar, sourceSpan, keySpan, valueSpan] of cases) { const bindings = parseTemplateBindings(attr); expect(humanize(bindings)).toEqual([[key, value, keyIsVar]]); expect(humanizeSpans(bindings, attr)).toEqual([[sourceSpan, keySpan, valueSpan]]); } }); it('should variable declared via let', () => { const bindings = parseTemplateBindings('*a="let b"'); expect(humanize(bindings)).toEqual([ // key, value, VariableBinding ['a', null, false], ['b', null, true], ]); }); it('should allow multiple pairs', () => { const bindings = parseTemplateBindings('*a="1 b 2"'); expect(humanize(bindings)).toEqual([ // key, value, VariableBinding ['a', '1', false], ['aB', '2', false], ]); }); it('should allow space and colon as separators', () => { const bindings = parseTemplateBindings('*a="1,b 2"'); expect(humanize(bindings)).toEqual([ // key, value, VariableBinding ['a', '1', false], ['aB', '2', false], ]); }); it('should store the templateUrl', () => { const bindings = parseTemplateBindings('*a="1,b 2"', '/foo/bar.html'); expect(humanize(bindings)).toEqual([ // key, value, VariableBinding ['a', '1', false], ['aB', '2', false], ]); expect((bindings[0].value as ASTWithSource).location).toEqual('/foo/bar.html@0:0'); }); it('should support common usage of ngIf', () => { const bindings = parseTemplateBindings('*ngIf="cond | pipe as foo, let x; ngIf as y"'); expect(humanize(bindings)).toEqual([ // [ key, value, VariableBinding ] ['ngIf', 'cond | pipe', false], ['foo', 'ngIf', true], ['x', null, true], ['y', 'ngIf', true], ]); }); it('should support common usage of ngFor', () => { let bindings: TemplateBinding[]; bindings = parseTemplateBindings('*ngFor="let person of people"'); expect(humanize(bindings)).toEqual([ // [ key, value, VariableBinding ] ['ngFor', null, false], ['person', null, true], ['ngForOf', 'people', false], ]); bindings = parseTemplateBindings( '*ngFor="let item; of items | slice:0:1 as collection, trackBy: func; index as i"', ); expect(humanize(bindings)).toEqual([ // [ key, value, VariableBinding ] ['ngFor', null, false], ['item', null, true], ['ngForOf', 'items | slice:0:1', false], ['collection', 'ngForOf', true], ['ngForTrackBy', 'func', false], ['i', 'index', true], ]); bindings = parseTemplateBindings( '*ngFor="let item, of: [1,2,3] | pipe as items; let i=index, count as len"', ); expect(humanize(bindings)).toEqual([ // [ key, value, VariableBinding ] ['ngFor', null, false], ['item', null, true], ['ngForOf', '[1,2,3] | pipe', false], ['items', 'ngForOf', true], ['i', 'index', true], ['len', 'count', true], ]); }); it('should parse pipes', () => { const bindings = parseTemplateBindings('*key="value|pipe "'); expect(humanize(bindings)).toEqual([ // [ key, value, VariableBinding ] ['key', 'value|pipe', false], ]); const {value} = bindings[0]; expect(value).toBeInstanceOf(ASTWithSource); expect((value as ASTWithSource).ast).toBeInstanceOf(BindingPipe); }); describe('"let" binding', () => { it('should support single declaration', () => { const bindings = parseTemplateBindings('*key="let i"'); expect(humanize(bindings)).toEqual([ // [ key, value, VariableBinding ] ['key', null, false], ['i', null, true], ]); }); it('should support multiple declarations', () => { const bindings = parseTemplateBindings('*key="let a; let b"'); expect(humanize(bindings)).toEqual([ // [ key, value, VariableBinding ] ['key', null, false], ['a', null, true], ['b', null, true], ]); }); it('should support empty string assignment', () => { const bindings = parseTemplateBindings(`*key="let a=''; let b='';"`); expect(humanize(bindings)).toEqual([ // [ key, value, VariableBinding ] ['key', null, false], ['a', '', true], ['b', '', true], ]); }); it('should support key and value names with dash', () => { const bindings = parseTemplateBindings('*key="let i-a = j-a,"'); expect(humanize(bindings)).toEqual([ // [ key, value, VariableBinding ] ['key', null, false], ['i-a', 'j-a', true], ]); }); it('should support declarations with or without value assignment', () => { const bindings = parseTemplateBindings('*key="let item; let i = k"'); expect(humanize(bindings)).toEqual([ // [ key, value, VariableBinding ] ['key', null, false], ['item', null, true], ['i', 'k', true], ]); }); it('should support declaration before an expression', () => { const bindings = parseTemplateBindings('*directive="let item in expr; let a = b"'); expect(humanize(bindings)).toEqual([ // [ key, value, VariableBinding ] ['directive', null, false], ['item', null, true], ['directiveIn', 'expr', false], ['a', 'b', true], ]); }); }); describe('"as" binding', () => { it('should support single declaration', () => { const bindings = parseTemplateBindings('*ngIf="exp as local"'); expect(humanize(bindings)).toEqual([ // [ key, value, VariableBinding ] ['ngIf', 'exp', false], ['local', 'ngIf', true], ]); }); it('should support declaration after an expression', () => { const bindings = parseTemplateBindings('*ngFor="let item of items as iter; index as i"'); expect(humanize(bindings)).toEqual([ // [ key, value, VariableBinding ] ['ngFor', null, false], ['item', null, true], ['ngForOf', 'items', false], ['iter', 'ngForOf', true], ['i', 'index', true], ]); }); it('should support key and value names with dash', () => { const bindings = parseTemplateBindings('*key="foo, k-b as l-b;"'); expect(humanize(bindings)).toEqual([ // [ key, value, VariableBinding ] ['key', 'foo', false], ['l-b', 'k-b', true], ]); }); }); describe('source, key, value spans', () => { it('should map empty expression', () => { const attr = '*ngIf=""'; const bindings = parseTemplateBindings(attr); expect(humanizeSpans(bindings, attr)).toEqual([ // source span, key span, value span ['ngIf="', 'ngIf', null], ]); }); it('should map variable declaration via "let"', () => { const attr = '*key="let i"'; const bindings = parseTemplateBindings(attr); expect(humanizeSpans(bindings, attr)).toEqual([ // source span, key span, value span ['key="', 'key', null], // source span stretches till next binding ['let i', 'i', null], ]); }); it('shoud map multiple variable declarations via "let"', () => { const attr = '*key="let item; let i=index; let e=even;"'; const bindings = parseTemplateBindings(attr); expect(humanizeSpans(bindings, attr)).toEqual([ // source span, key span, value span ['key="', 'key', null], ['let item; ', 'item', null], ['let i=index; ', 'i', 'index'], ['let e=even;', 'e', 'even'], ]); }); it('shoud map expression with pipe', () => { const attr = '*ngIf="cond | pipe as foo, let x; ngIf as y"'; const bindings = parseTemplateBindings(attr); expect(humanizeSpans(bindings, attr)).toEqual([ // source span, key span, value span ['ngIf="cond | pipe ', 'ngIf', 'cond | pipe'], ['ngIf="cond | pipe as foo, ', 'foo', 'ngIf'], ['let x; ', 'x', null], ['ngIf as y', 'y', 'ngIf'], ]); }); it('should report unexpected token when encountering interpolation', () => { const attr = '*ngIf="name && {{name}}"'; expectParseTemplateBindingsError( attr, 'Parser Error: Unexpected token {, expected identifier, keyword, or string at column 10 in [name && {{name}}] in foo.html@0:0', ); }); it('should map variable declaration via "as"', () => { const attr = '*ngFor="let item; of items | slice:0:1 as collection, trackBy: func; index as i"'; const bindings = parseTemplateBindings(attr); expect(humanizeSpans(bindings, attr)).toEqual([ // source span, key span, value span ['ngFor="', 'ngFor', null], ['let item; ', 'item', null], ['of items | slice:0:1 ', 'of', 'items | slice:0:1'], ['of items | slice:0:1 as collection, ', 'collection', 'of'], ['trackBy: func; ', 'trackBy', 'func'], ['index as i', 'i', 'index'], ]); }); it('should map literal array', () => { const attr = '*ngFor="let item, of: [1,2,3] | pipe as items; let i=index, count as len, "'; const bindings = parseTemplateBindings(attr); expect(humanizeSpans(bindings, attr)).toEqual([ // source span, key span, value span ['ngFor="', 'ngFor', null], ['let item, ', 'item', null], ['of: [1,2,3] | pipe ', 'of', '[1,2,3] | pipe'], ['of: [1,2,3] | pipe as items; ', 'items', 'of'], ['let i=index, ', 'i', 'index'], ['count as len,', 'len', 'count'], ]); }); }); }); describe('parseInterpolation', () => { it('should return null if no interpolation', () => { expect(parseInterpolation('nothing')).toBe(null); }); it('should not parse malformed interpolations as strings', () => { const ast = parseInterpolation('{{a}} {{example}}')!.ast as Interpolation; expect(ast.strings).toEqual(['', ' {{example}}']); expect(ast.expressions.length).toEqual(1); expect((ast.expressions[0] as PropertyRead).name).toEqual('a'); }); it('should parse no prefix/suffix interpolation', () => { const ast = parseInterpolation('{{a}}')!.ast as Interpolation; expect(ast.strings).toEqual(['', '']); expect(ast.expressions.length).toEqual(1); expect((ast.expressions[0] as PropertyRead).name).toEqual('a'); }); it('should parse interpolation inside quotes', () => { const ast = parseInterpolation('"{{a}}"')!.ast as Interpolation; expect(ast.strings).toEqual(['"', '"']); expect(ast.expressions.length).toEqual(1); expect((ast.expressions[0] as PropertyRead).name).toEqual('a'); }); it('should parse interpolation with interpolation characters inside quotes', () => { checkInterpolation('{{"{{a}}"}}', '{{ "{{a}}" }}'); checkInterpolation('{{"{{"}}', '{{ "{{" }}'); checkInterpolation('{{"}}"}}', '{{ "}}" }}'); checkInterpolation('{{"{"}}', '{{ "{" }}'); checkInterpolation('{{"}"}}', '{{ "}" }}'); }); it('should parse interpolation with escaped quotes', () => { checkInterpolation(`{{'It\\'s just Angular'}}`, `{{ "It's just Angular" }}`); checkInterpolation(`{{'It\\'s {{ just Angular'}}`, `{{ "It's {{ just Angular" }}`); checkInterpolation(`{{'It\\'s }} just Angular'}}`, `{{ "It's }} just Angular" }}`); }); it('should parse interpolation with escaped backslashes', () => { checkInterpolation(`{{foo.split('\\\\')}}`, `{{ foo.split("\\") }}`); checkInterpolation(`{{foo.split('\\\\\\\\')}}`, `{{ foo.split("\\\\") }}`); checkInterpolation(`{{foo.split('\\\\\\\\\\\\')}}`, `{{ foo.split("\\\\\\") }}`); }); it('should not parse interpolation with mismatching quotes', () => { expect(parseInterpolation(`{{ "{{a}}' }}`)).toBeNull(); }); it('should parse prefix/suffix with multiple interpolation', () => { const originalExp = 'before {{ a }} middle {{ b }} after'; const ast = parseInterpolation(originalExp)!.ast; expect(unparse(ast)).toEqual(originalExp); validate(ast); }); it('should report empty interpolation expressions', () => { expectError( parseInterpolation('{{}}')!, 'Blank expressions are not allowed in interpolated strings', ); expectError( parseInterpolation('foo {{ }}')!, 'Parser Error: Blank expressions are not allowed in interpolated strings', ); expectError( parseInterpolation('{{ }}')!, 'Parser Error: Blank expressions are not allowed in interpolated strings', ); }); it('should produce an empty expression ast for empty interpolations', () => { const parsed = parseInterpolation('{{}}')!.ast as Interpolation; expect(parsed.expressions.length).toBe(1); expect(parsed.expressions[0]).toBeInstanceOf(EmptyExpr); }); it('should parse conditional expression', () => { checkInterpolation('{{ a < b ? a : b }}'); }); it('should parse expression with newline characters', () => { checkInterpolation(`{{ 'foo' +\n 'bar' +\r 'baz' }}`, `{{ "foo" + "bar" + "baz" }}`); }); describe('comments', () => { it('should ignore comments in interpolation expressions', () => { checkInterpolation('{{a //comment}}', '{{ a }}'); }); it('should error when interpolation only contains a comment', () => { expectError( parseInterpolation('{{ // foobar }}')!, 'Parser Error: Interpolation expression cannot only contain a comment at column 0 in [{{ // foobar }}]', ); }); it('should retain // in single quote strings', () => { checkInterpolation(`{{ 'http://www.google.com' }}`, `{{ "http://www.google.com" }}`); }); it('should retain // in double quote strings', () => { checkInterpolation(`{{ "http://www.google.com" }}`, `{{ "http://www.google.com" }}`); }); it('should ignore comments after string literals', () => { checkInterpolation(`{{ "a//b" //comment }}`, `{{ "a//b" }}`); }); it('should retain // in complex strings', () => { checkInterpolation( `{{"//a\'//b\`//c\`//d\'//e" //comment}}`, `{{ "//a\'//b\`//c\`//d\'//e" }}`, ); }); it('should retain // in nested, unterminated strings', () => { checkInterpolation(`{{ "a\'b\`" //comment}}`, `{{ "a\'b\`" }}`); }); it('should ignore quotes inside a comment', () => { checkInterpolation(`"{{name // " }}"`, `"{{ name }}"`); }); }); }); describe('parseSimpleBinding', () => { it('should parse a field access', () => { const p = parseSimpleBinding('name'); expect(unparse(p)).toEqual('name'); validate(p); }); it('should report when encountering pipes', () => { expectError( validate(parseSimpleBinding('a | somePipe')), 'Host binding expression cannot contain pipes', ); }); it('should report when encountering interpolation', () => { expectError( validate(parseSimpleBinding('{{exp}}')), 'Got interpolation ({{}}) where expression was expected', ); }); it('should not report interpolation inside a string', () => { expect(parseSimpleBinding(`"{{exp}}"`).errors).toEqual([]); expect(parseSimpleBinding(`'{{exp}}'`).errors).toEqual([]); expect(parseSimpleBinding(`'{{\\"}}'`).errors).toEqual([]); expect(parseSimpleBinding(`'{{\\'}}'`).errors).toEqual([]); }); it('should report when encountering field write', () => { expectError(validate(parseSimpleBinding('a = b')), 'Bindings cannot contain assignments'); }); it('should throw if a pipe is used inside a conditional', () => { expectError( validate(parseSimpleBinding('(hasId | myPipe) ? "my-id" : ""')), 'Host binding expression cannot contain pipes', ); }); it('should throw if a pipe is used inside a call', () => { expectError( validate(parseSimpleBinding('getId(true, id | myPipe)')), 'Host binding expression cannot contain pipes', ); }); it('should throw if a pipe is used inside a call to a property access', () => { expectError( validate(parseSimpleBinding('idService.getId(true, id | myPipe)')), 'Host binding expression cannot contain pipes', ); }); it('should throw if a pipe is used inside a call to a safe property access', () => { expectError( validate(parseSimpleBinding('idService?.getId(true, id | myPipe)')), 'Host binding expression cannot contain pipes', ); }); it('should throw if a pipe is used inside a property access', () => { expectError( validate(parseSimpleBinding('a[id | myPipe]')), 'Host binding expression cannot contain pipes', ); }); it('should throw if a pipe is used inside a keyed read expression', () => { expectError( validate(parseSimpleBinding('a[id | myPipe].b')), 'Host binding expression cannot contain pipes', ); }); it('should throw if a pipe is used inside a safe property read', () => { expectError( validate(parseSimpleBinding('(id | myPipe)?.id')), 'Host binding expression cannot contain pipes', ); }); it('should throw if a pipe is used inside a non-null assertion', () => { expectError( validate(parseSimpleBinding('[id | myPipe]!')), 'Host binding expression cannot contain pipes', ); }); it('should throw if a pipe is used inside a prefix not expression', () => { expectError( validate(parseSimpleBinding('!(id | myPipe)')), 'Host binding expression cannot contain pipes', ); }); it('should throw if a pipe is used inside a binary expression', () => { expectError( validate(parseSimpleBinding('(id | myPipe) === true')), 'Host binding expression cannot contain pipes', ); }); }); describe('wrapLiteralPrimitive', () => { it('should wrap a literal primitive', () => { expect(unparse(validate(createParser().wrapLiteralPrimitive('foo', '', 0)))).toEqual('"foo"'); }); }); describe('error recovery', () => { function recover(text: string, expected?: string) { const expr = validate(parseAction(text)); expect(unparse(expr)).toEqual(expected || text); } it('should be able to recover from an extra paren', () => recover('((a)))', '((a))')); it('should be able to recover from an extra bracket', () => recover('[[a]]]', '[[a]]')); it('should be able to recover from a missing )', () => recover('(a;b', '(a); b;')); it('should be able to recover from a missing ]', () => recover('[a,b', '[a, b]')); it('should be able to recover from a missing selector', () => recover('a.')); it('should be able to recover from a missing selector in a array literal', () => recover('[[a.], b, c]')); it('should recover from parenthesized `as` expressions', () => { recover('foo(($event.target as HTMLElement).value)', 'foo(($event.target).value)'); recover('foo(((($event.target as HTMLElement))).value)', 'foo(((($event.target))).value)'); recover('foo(((bar as HTMLElement) as Something).value)', 'foo(((bar)).value)'); }); it('should be able to recover from a broken expression in a template literal', () => { recover('`before ${expr.}`', '`before ${expr.}`'); recover('`${expr.} after`', '`${expr.} after`'); recover('`before ${expr.} after`', '`before ${expr.} after`'); }); }); describe('offsets', () => { it('should retain the offsets of an interpolation', () => { const interpolations = splitInterpolation('{{a}} {{b}} {{c}}')!; expect(interpolations.offsets).toEqual([2, 9, 16]); }); it('should retain the offsets into the expression AST of interpolations', () => { const source = parseInterpolation('{{a}} {{b}} {{c}}')!; const interpolation = source.ast as Interpolation; expect(interpolation.expressions.map((e) => e.span.start)).toEqual([2, 9, 16]); }); }); }); function createParser(supportsDirectPipeReferences = false) { return new Parser(new Lexer(), supportsDirectPipeReferences); } function parseAction(text: string): ASTWithSource { return createParser().parseAction(text, getFakeSpan(), 0); } function parseBinding(text: string, supportsDirectPipeReferences?: boolean): ASTWithSource { return createParser(supportsDirectPipeReferences).parseBinding(text, getFakeSpan(), 0); } function parseTemplateBindings(attribute: string, templateUrl = 'foo.html'): TemplateBinding[] { const result = _parseTemplateBindings(attribute, templateUrl); expect(result.errors).toEqual([]); expect(result.warnings).toEqual([]); return result.templateBindings; } function expectParseTemplateBindingsError(attribute: string, error: string) { const result = _parseTemplateBindings(attribute, 'foo.html'); expect(result.errors[0].msg).toEqual(error); } function _parseTemplateBindings(attribute: string, templateUrl: string) { const match = attribute.match(/^\*(.+)="(.*)"$/); expect(match).withContext(`failed to extract key and value from ${attribute}`).toBeTruthy(); const [_, key, value] = match!; const absKeyOffset = 1; // skip the * prefix const absValueOffset = attribute.indexOf('=') + '="'.length; const parser = createParser(); return parser.parseTemplateBindings( key, value, getFakeSpan(templateUrl), absKeyOffset, absValueOffset, ); } function parseInterpolation(text: string): ASTWithSource | null { return createParser().parseInterpolation(text, getFakeSpan(), 0, null); } function splitInterpolation(text: string): SplitInterpolation | null { return createParser().splitInterpolation(text, getFakeSpan(), [], null); } function parseSimpleBinding(text: string): ASTWithSource { return createParser().parseSimpleBinding(text, getFakeSpan(), 0); } function checkInterpolation(exp: string, expected?: string) { const ast = parseInterpolation(exp); if (expected == null) expected = exp; if (ast === null) { throw Error(`Failed to parse expression "${exp}"`); } expect(unparse(ast)).toEqual(expected); validate(ast); } function checkBinding(exp: string, expected?: string) { const ast = parseBinding(exp); if (expected == null) expected = exp; expect(unparse(ast)).toEqual(expected); validate(ast); } function checkAction(exp: string, expected?: string) { const ast = parseAction(exp); if (expected == null) expected = exp; expect(unparse(ast)).toEqual(expected); validate(ast); } function expectError(ast: {errors: ParseError[]}, message: string, errorCount?: number) { if (errorCount != null) { expect(ast.errors.length).toBe(errorCount); } else { expect(ast.errors.length).toBeGreaterThan(0); } for (const error of ast.errors) { if (error.msg.indexOf(message) >= 0) { return; } } const errMsgs = ast.errors.map((err) => err.msg).join('\n'); throw Error( `Expected an error containing "${message}" to be reported, but got the errors:\n` + errMsgs, ); } function expectActionError(text: string, message: string, errorCount?: number) { expectError(validate(parseAction(text)), message, errorCount); } function expectBindingError(text: string, message: string) { expectError(validate(parseBinding(text)), message); } /** * Check that a malformed action parses to a recovered AST while emitting an error. */ function checkActionWithError(text: string, expected: string, error: string) { checkAction(text, expected); expectActionError(text, error); } function rawSpan(span: AbsoluteSourceSpan): [number, number] { return [span.start, span.end]; }