1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
# Scope
# -----
# * Variable Safety
# * Variable Shadowing
# * Auto-closure (`do`)
# * Global Scope Leaks
test "reference `arguments` inside of functions", ->
sumOfArgs = ->
sum = (a,b) -> a + b
sum = 0
sum += num for num in arguments
sum
eq 10, sumOfArgs(0, 1, 2, 3, 4)
test "assignment to an Object.prototype-named variable should not leak to outer scope", ->
# FIXME: fails on IE
(->
constructor = 'word'
)()
ok constructor isnt 'word'
test "siblings of splat parameters shouldn't leak to surrounding scope", ->
x = 10
oops = (x, args...) ->
oops(20, 1, 2, 3)
eq x, 10
test "catch statements should introduce their argument to scope", ->
try throw ''
catch e
do -> e = 5
eq 5, e
test "loop variable should be accessible after for-of loop", ->
d = (x for x of {1:'a',2:'b'})
ok x in ['1','2']
test "loop variable should be accessible after for-in loop", ->
d = (x for x in [1,2])
eq x, 2
test "loop variable should be accessible after for-from loop", ->
d = (x for x from [1,2])
eq x, 2
class Array then slice: fail # needs to be global
class Object then hasOwnProperty: fail
test "#1973: redefining Array/Object constructors shouldn't confuse __X helpers", ->
arr = [1..4]
arrayEq [3, 4], arr[2..]
obj = {arr}
for own k of obj
eq arr, obj[k]
test "#2255: global leak with splatted @-params", ->
ok not x?
arrayEq [0], ((@x...) -> @x).call {}, 0
ok not x?
test "#1183: super + fat arrows", ->
dolater = (cb) -> cb()
class A
constructor: ->
@_i = 0
foo : (cb) ->
dolater =>
@_i += 1
cb()
class B extends A
constructor : ->
super()
foo : (cb) ->
dolater =>
dolater =>
@_i += 2
super cb
b = new B
b.foo => eq b._i, 3
test "#1183: super + wrap", ->
class A
m : -> 10
class B extends A
constructor : -> super()
m: -> r = try super()
m: -> r = super()
eq (new B).m(), 10
test "#1183: super + closures", ->
class A
constructor: ->
@i = 10
foo : -> @i
class B extends A
foo : ->
ret = switch 1
when 0 then 0
when 1 then super()
ret
eq (new B).foo(), 10
test "#2331: bound super regression", ->
class A
@value = 'A'
method: -> @constructor.value
class B extends A
method: => super()
eq (new B).method(), 'A'
test "#3259: leak with @-params within destructured parameters", ->
fn = ({@foo}, [@bar], [{@baz}]) ->
foo = bar = baz = false
fn.call {}, {foo: 'foo'}, ['bar'], [{baz: 'baz'}]
eq 'undefined', typeof foo
eq 'undefined', typeof bar
eq 'undefined', typeof baz
|
