From ce00997693451b7230d898e5da40640a5b892606 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Thu, 16 Apr 2015 13:29:20 -0700 Subject: [PATCH] Added symbols files. --- ...owFunctionWhenUsingArguments01_ES6.symbols | 62 +++++++++++++++++++ ...owFunctionWhenUsingArguments02_ES6.symbols | 6 ++ ...owFunctionWhenUsingArguments03_ES6.symbols | 9 +++ ...owFunctionWhenUsingArguments04_ES6.symbols | 12 ++++ ...owFunctionWhenUsingArguments05_ES6.symbols | 10 +++ ...owFunctionWhenUsingArguments06_ES6.symbols | 10 +++ ...owFunctionWhenUsingArguments07_ES6.symbols | 11 ++++ ...owFunctionWhenUsingArguments09_ES6.symbols | 10 +++ ...owFunctionWhenUsingArguments10_ES6.symbols | 12 ++++ ...owFunctionWhenUsingArguments11_ES6.symbols | 13 ++++ ...owFunctionWhenUsingArguments14_ES6.symbols | 17 +++++ ...owFunctionWhenUsingArguments15_ES6.symbols | 20 ++++++ ...owFunctionWhenUsingArguments16_ES6.symbols | 19 ++++++ ...owFunctionWhenUsingArguments17_ES6.symbols | 20 ++++++ ...owFunctionWhenUsingArguments18_ES6.symbols | 18 ++++++ ...owFunctionWhenUsingArguments19_ES6.symbols | 31 ++++++++++ 16 files changed, 280 insertions(+) create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments01_ES6.symbols create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.symbols create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.symbols create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.symbols create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.symbols create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.symbols create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.symbols create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.symbols create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.symbols create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.symbols create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.symbols diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments01_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments01_ES6.symbols new file mode 100644 index 00000000000..698b32da7ad --- /dev/null +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments01_ES6.symbols @@ -0,0 +1,62 @@ +=== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments01_ES6.ts === +var a = () => { +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 0, 3)) + + var arg = arguments[0]; // error +>arg : Symbol(arg, Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 1, 7)) +>arguments : Symbol(arguments) +} + +var b = function () { +>b : Symbol(b, Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 4, 3)) + + var a = () => { +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 5, 7)) + + var arg = arguments[0]; // error +>arg : Symbol(arg, Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 6, 11)) +>arguments : Symbol(arguments) + } +} + +function baz() { +>baz : Symbol(baz, Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 8, 1)) + + () => { + var arg = arguments[0]; +>arg : Symbol(arg, Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 12, 5)) +>arguments : Symbol(arguments) + } +} + +function foo(inputFunc: () => void) { } +>foo : Symbol(foo, Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 14, 1)) +>inputFunc : Symbol(inputFunc, Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 16, 13)) + +foo(() => { +>foo : Symbol(foo, Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 14, 1)) + + var arg = arguments[0]; // error +>arg : Symbol(arg, Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 18, 7)) +>arguments : Symbol(arguments) + +}); + +function bar() { +>bar : Symbol(bar, Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 19, 3)) + + var arg = arguments[0]; // no error +>arg : Symbol(arg, Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 22, 7)) +>arguments : Symbol(arguments) +} + + +() => { + function foo() { +>foo : Symbol(foo, Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 26, 7)) + + var arg = arguments[0]; // no error +>arg : Symbol(arg, Decl(emitArrowFunctionWhenUsingArguments01_ES6.ts, 28, 5)) +>arguments : Symbol(arguments) + } +} diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.symbols new file mode 100644 index 00000000000..e403a2c3da1 --- /dev/null +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.symbols @@ -0,0 +1,6 @@ +=== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments02_ES6.ts === + +var a = () => arguments; +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments02_ES6.ts, 1, 3)) +>arguments : Symbol(arguments) + diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.symbols new file mode 100644 index 00000000000..08bae382794 --- /dev/null +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.symbols @@ -0,0 +1,9 @@ +=== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments03_ES6.ts === + +var arguments; +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments03_ES6.ts, 1, 3)) + +var a = () => arguments; +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments03_ES6.ts, 2, 3)) +>arguments : Symbol(arguments) + diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.symbols new file mode 100644 index 00000000000..708615a95c6 --- /dev/null +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.symbols @@ -0,0 +1,12 @@ +=== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments04_ES6.ts === + +function f() { +>f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments04_ES6.ts, 0, 0)) + + var arguments; +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments04_ES6.ts, 2, 7)) + + var a = () => arguments; +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments04_ES6.ts, 3, 7)) +>arguments : Symbol(arguments) +} diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.symbols new file mode 100644 index 00000000000..379a5cf92f1 --- /dev/null +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.symbols @@ -0,0 +1,10 @@ +=== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments05_ES6.ts === + +function f(arguments) { +>f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments05_ES6.ts, 0, 0)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments05_ES6.ts, 1, 11)) + + var a = () => arguments; +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments05_ES6.ts, 2, 7)) +>arguments : Symbol(arguments) +} diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.symbols new file mode 100644 index 00000000000..e59f487f864 --- /dev/null +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.symbols @@ -0,0 +1,10 @@ +=== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments06_ES6.ts === + +function f(arguments) { +>f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments06_ES6.ts, 0, 0)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments06_ES6.ts, 1, 11)) + + var a = () => () => arguments; +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments06_ES6.ts, 2, 7)) +>arguments : Symbol(arguments) +} diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.symbols new file mode 100644 index 00000000000..5de21ffbebd --- /dev/null +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.symbols @@ -0,0 +1,11 @@ +=== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments07_ES6.ts === + +function f(arguments) { +>f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments07_ES6.ts, 0, 0)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments07_ES6.ts, 1, 11)) + + var a = (arguments) => () => arguments; +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments07_ES6.ts, 2, 7)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments07_ES6.ts, 2, 13)) +>arguments : Symbol(arguments) +} diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.symbols new file mode 100644 index 00000000000..ff8f114c052 --- /dev/null +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.symbols @@ -0,0 +1,10 @@ +=== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments09_ES6.ts === + +function f(_arguments) { +>f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments09_ES6.ts, 0, 0)) +>_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments09_ES6.ts, 1, 11)) + + var a = () => () => arguments; +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments09_ES6.ts, 2, 7)) +>arguments : Symbol(arguments) +} diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.symbols new file mode 100644 index 00000000000..1d9965fa6ad --- /dev/null +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.symbols @@ -0,0 +1,12 @@ +=== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments10_ES6.ts === + +function f() { +>f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments10_ES6.ts, 0, 0)) + + var _arguments = 10; +>_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments10_ES6.ts, 2, 7)) + + var a = () => () => arguments; +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments10_ES6.ts, 3, 7)) +>arguments : Symbol(arguments) +} diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.symbols new file mode 100644 index 00000000000..a8f9c86c1b2 --- /dev/null +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.symbols @@ -0,0 +1,13 @@ +=== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments11_ES6.ts === + +function f(arguments) { +>f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments11_ES6.ts, 0, 0)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments11_ES6.ts, 1, 11)) + + var _arguments = 10; +>_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments11_ES6.ts, 2, 7)) + + var a = () => () => arguments; +>a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments11_ES6.ts, 3, 7)) +>arguments : Symbol(arguments) +} diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols new file mode 100644 index 00000000000..623cc4c9690 --- /dev/null +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols @@ -0,0 +1,17 @@ +=== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments14_ES6.ts === + +function f() { +>f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments14_ES6.ts, 0, 0)) + + if (Math.random()) { +>Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) +>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1664, 1)) +>random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) + + let arguments = 100; +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments14_ES6.ts, 3, 11)) + + return () => arguments; +>arguments : Symbol(arguments) + } +} diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols new file mode 100644 index 00000000000..d140c21284c --- /dev/null +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols @@ -0,0 +1,20 @@ +=== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments15_ES6.ts === + +function f() { +>f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments15_ES6.ts, 0, 0)) + + var arguments = "hello"; +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments15_ES6.ts, 2, 7)) + + if (Math.random()) { +>Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) +>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1664, 1)) +>random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) + + const arguments = 100; +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments15_ES6.ts, 4, 13)) + + return () => arguments; +>arguments : Symbol(arguments) + } +} diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols new file mode 100644 index 00000000000..e970b527d56 --- /dev/null +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols @@ -0,0 +1,19 @@ +=== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments16_ES6.ts === + +function f() { +>f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments16_ES6.ts, 0, 0)) + + var arguments = "hello"; +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments16_ES6.ts, 2, 7), Decl(emitArrowFunctionWhenUsingArguments16_ES6.ts, 6, 7)) + + if (Math.random()) { +>Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) +>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1664, 1)) +>random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) + + return () => arguments[0]; +>arguments : Symbol(arguments) + } + var arguments = "world"; +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments16_ES6.ts, 2, 7), Decl(emitArrowFunctionWhenUsingArguments16_ES6.ts, 6, 7)) +} diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols new file mode 100644 index 00000000000..8612e0896d1 --- /dev/null +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols @@ -0,0 +1,20 @@ +=== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments17_ES6.ts === + +function f() { +>f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 0, 0)) + + var { arguments } = { arguments: "hello" }; +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 2, 9), Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 6, 7)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 2, 25)) + + if (Math.random()) { +>Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) +>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1664, 1)) +>random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) + + return () => arguments[0]; +>arguments : Symbol(arguments) + } + var arguments = "world"; +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 2, 9), Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 6, 7)) +} diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols new file mode 100644 index 00000000000..96f9712635c --- /dev/null +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols @@ -0,0 +1,18 @@ +=== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments18_ES6.ts === + +function f() { +>f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments18_ES6.ts, 0, 0)) + + var { arguments: args } = { arguments }; +>args : Symbol(args, Decl(emitArrowFunctionWhenUsingArguments18_ES6.ts, 2, 9)) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments18_ES6.ts, 2, 31)) + + if (Math.random()) { +>Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) +>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1664, 1)) +>random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) + + return () => arguments; +>arguments : Symbol(arguments) + } +} diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.symbols new file mode 100644 index 00000000000..9e6392daaf1 --- /dev/null +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.symbols @@ -0,0 +1,31 @@ +=== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments19_ES6.ts === + +function f() { +>f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 0, 0)) + + function g() { +>g : Symbol(g, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 1, 14)) + + var _arguments = 10; // No capture in 'g', so no conflict. +>_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 3, 11)) + + function h() { +>h : Symbol(h, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 3, 28)) + + var capture = () => arguments; // Should trigger an '_arguments' capture into function 'h' +>capture : Symbol(capture, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 5, 15)) +>arguments : Symbol(arguments) + + foo(_arguments); // Error as this does not resolve to the user defined '_arguments' +>foo : Symbol(foo, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 8, 5)) +>_arguments : Symbol(_arguments, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 3, 11)) + } + } + + function foo(x: any) { +>foo : Symbol(foo, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 8, 5)) +>x : Symbol(x, Decl(emitArrowFunctionWhenUsingArguments19_ES6.ts, 10, 17)) + + return 100; + } +}