code stringlengths 1 2.08M | language stringclasses 1
value |
|---|---|
// Should not compile.
function f() {}
f`not closed \`
| JavaScript |
// Should not compile.
// Error: (4, 46): ')' expected
function invalidParam(noDefault, ...restParam, noRestAgain) {
// Should fail to parse since non rest param is not allowed after
// param.
} | JavaScript |
function f(...p) {
return p;
}
function g(a, ...p) {
return p;
}
assertArrayEquals([], f());
assertArrayEquals([0], f(0));
assertArrayEquals([0, 1], f(0, 1));
assertArrayEquals([], g());
assertArrayEquals([], g(0));
assertArrayEquals([1], g(0, 1));
assertArrayEquals([1, 2], g(0, 1, 2));
| JavaScript |
// Should not compile.
// Error: (5, 9): 'identifier' expected
var object = {
set x(...rest) {
// rest is not allowed for set accessor
}
};
| JavaScript |
// A binary tree class.
class Tree {
constructor(label, left, right) {
this.label = label;
this.left = left;
this.right = right;
}
}
// We don't yet support any syntax to set private named fields in classes.
import iterator from '@iter';
Tree.prototype[iterator] = function*() {
if (this.left) {
... | JavaScript |
function* forInGenerator3() {
var object = {
a: 0,
b: {
c: 1,
},
d: 2
};
for (var key in object) {
yield key;
for (var key2 in object[key]) {
yield key2;
}
}
}
function accumulate(iterator) {
var result = '';
for (var value of iterator) {
result = result + String... | JavaScript |
function* tryCatchGenerator() {
var x;
try {
yield 1;
throw 2;
yield 3;
} catch (e) {
x = e;
}
yield x;
}
function accumulate(iterator) {
var result = '';
for (var value of iterator) {
result = result + String(value);
}
return result;
}
// ----------------------------------------... | JavaScript |
function mapFilterGenerator() {
function* map(list, fun) {
for (var item of list) {
yield fun(item);
}
}
function* filter(list, fun) {
for (var item of list) {
if (fun(item)) {
yield item;
}
}
}
// squares even numbers. no intermediate array is created.
var numbers ... | JavaScript |
function* forInGenerator2() {
var object = {
a: 0,
b: 1,
c: 2
};
var key;
for (key in object) {
if (key == 'a') {
delete object.b;
object.d = 3;
}
yield key;
yield object[key];
}
}
function accumulate(iterator) {
var result = '';
for (var value of iterator) {
r... | JavaScript |
// Should not compile.
// Options: --generators=false
function* range(start, end) {
for (var i = start; i < end; i++) {
yield i;
}
}
| JavaScript |
function* forEachGenerator() {
yield* forInGenerator3();
yield* forInGenerator2();
}
function* forInGenerator3() {
var object = {
a: 0,
b: {
c: 1,
},
d: 2
};
for (var key in object) {
yield key;
for (var key2 in object[key]) {
yield key2;
}
}
}
function* forInGenera... | JavaScript |
// Should not compile.
// Options: --forOf=false
var s = [];
for (var i of yieldFor()) {
s.push(i);
}
| JavaScript |
// Should not compile.
function simpleGenerator() {
yield 1;
}
| JavaScript |
function* tryFinallyGenerator() {
var x = 1;
var y;
// finally inside a catch
try {
try {
yield x;
throw 7;
x = 2;
} finally {
x = 3;
}
} catch (e) {
y = e;
}
yield x * y;
// finally with no enclosing try
try {
y = 11;
yield y;
} finally {
y = 3;... | JavaScript |
function* simpleGenerator() {
yield 1;
}
function accumulate(iterator) {
var result = '';
for (var value of iterator) {
result = result + String(value);
}
return result;
}
// ----------------------------------------------------------------------------
assertEquals('1', accumulate(simpleGenerator()));
| JavaScript |
function* whileGenerator(max, continueValue, breakValue) {
var i = 0;
while (i < max) {
i++;
if (i == continueValue) {
continue;
}
if (i == breakValue) {
break;
}
yield i;
}
}
function accumulate(iterator) {
var result = '';
for (var value of iterator) {
result = resul... | JavaScript |
function* ifGenerator(condition) {
if (condition) {
yield 1;
}
if (!condition) {
yield 2;
}
if (condition) {
yield 3;
} else {
yield 4;
}
}
function accumulate(iterator) {
var result = '';
for (var value of iterator) {
result = result + String(value);
}
return result;
}
// --... | JavaScript |
function* labelledBreakGenerator() {
var x = 1;
var y = 2;
label:
while (true) {
x++;
while (true) {
yield x * y;
y++;
if (y == 3) {
continue label;
}
yield x * y * 5;
if (y == 4) {
break label;
}
yield x * y * 13;
}
yield x * y * 11;... | JavaScript |
function* forInGenerator() {
var object = {
a: 0,
b: 1,
c: 2
};
for (var key in object) {
if (key == 'a') {
delete object.b;
object.d = 3;
}
yield key;
yield object[key];
}
}
function accumulate(iterator) {
var result = '';
for (var value of iterator) {
result = ... | JavaScript |
function* endYieldGenerator() {
yield 1;
yield;
yield 2;
}
function accumulate(iterator) {
var result = '';
for (var value of iterator) {
result = result + String(value);
}
return result;
}
// ----------------------------------------------------------------------------
assertEquals('1', accumulate(... | JavaScript |
function* sequenceGenerator() {
var i = 1;
yield i;
i = 3;
yield i + 1;
{
var x = 3;
yield i + x;
yield x;
}
}
function accumulate(iterator) {
var result = '';
for (var value of iterator) {
result = result + String(value);
}
return result;
}
// -------------------------------------... | JavaScript |
// yield form within a catch block
function* tryCatchYieldGenerator() {
var x = 3;
try {
throw 5;
} catch (e) {
yield e * x;
}
}
function accumulate(iterator) {
var result = '';
for (var value of iterator) {
result = result + String(value);
}
return result;
}
// ---------------------------... | JavaScript |
function* doGenerator() {
var i = 0;
do {
if (++i % 2 == 0) continue;
yield i;
} while (i < 6);
}
function accumulate(iterator) {
var result = '';
for (var value of iterator) {
result = result + String(value);
}
return result;
}
// ------------------------------------------------------------... | JavaScript |
function* switchGenerator(val) {
switch (val) {
case 1:
yield val;
case 2:
yield val * 2;
break;
case 3:
break;
default:
yield val * 10;
}
// switch without a default
switch (val) {
case 1000:
yield val;
break;
}
yield val * 5;
}
function accu... | JavaScript |
function* statementTestGenerator() {
// all of these statement constructs should be allowed
// provided that they contain no yield statements
switch (1) {
case 2: break;
default: break;
}
try {
} catch (e) {}
try {
} finally {}
do {} while (false);
for (;false;) {}
//TODO(jmesserly): this had... | JavaScript |
function* forLexicallyNestedGenerator() {
yield* (function*() { yield [1,2,3]; yield* [4,5,6]; })();
}
function accumulate(iterator) {
var result = '';
for (var value of iterator) {
result = result + String(value);
}
return result;
}
// -------------------------------------------------------------------... | JavaScript |
var finallyVisited = false;
function* test() {
try {
yield 42;
} finally {
finallyVisited = true;
}
}
var it = test();
it.moveNext();
assertEquals(42, it.current);
assertFalse(finallyVisited);
it.moveNext();
assertTrue(finallyVisited);
finallyVisited = false;
for (var i of test()) {
assertEquals(42,... | JavaScript |
function* forEmptyGenerator() {
yield* [];
}
function accumulate(iterator) {
var result = '';
for (var value of iterator) {
result = result + String(value);
}
return result;
}
// ----------------------------------------------------------------------------
assertEquals('', accumulate(forEmptyGenerator()... | JavaScript |
function* forGenerator() {
var a = 1, b = 1;
for (var i = 0; i < 4; i++) {
// TODO(jmesserly): this was changed until we get destructing
//[a, b] = [b, a + b];
var t0 = b;
var t1 = a + b;
a = t0;
b = t1;
yield a;
}
}
function accumulate(iterator) {
var result = '';
for (var value... | JavaScript |
// finally inside a try finally
function* tryFinallyFinallyGenerator() {
var y;
try {
y = 13;
try {
yield y;
} finally {
y = 17;
}
yield y;
} finally {
y = 23;
}
yield y;
}
function accumulate(iterator) {
var result = '';
for (var value of iterator) {
result = res... | JavaScript |
module m {
export var x = 1;
export var y = 2;
}
import * from m;
assertEquals(3, x + y); | JavaScript |
// Should not compile.
// Error: 'd' is not a module
module a {
export module b {
module c from d;
}
}
| JavaScript |
// Should not compile.
// Error: 'y' is not exported by m
// Error: 'z' is not exported by m
// Error: 'w' is not exported by m
// Error: 'foo' is not exported by '@name'
// Error: 'bar' is not exported by '@name'
// Error: 'inner' is not exported by outer
// Error: 'object' is not a module
module m {
export var x =... | JavaScript |
// Should not compile.
// Error: 'c' is not exported by b
module a {
module b {
module c {};
}
export {c: d} from b;
}
| JavaScript |
module a {
export var i = 0;
export function inc() {
i++;
}
}
(function() {
// TODO(arv): Modules are strict. The codegen for modules should ensure that
// they are strict.
'use strict';
assertEquals(0, a.i);
a.inc();
assertEquals(1, a.i);
assertThrows(function() {
a.i = 2;
});
})();
//... | JavaScript |
// Should not compile.
// Error: 'c' is not a module
module a {
module b from c;
}
| JavaScript |
// Should not compile.
// Error: 'c' is not a module
module a {}
module b from a.c; | JavaScript |
// Should not compile.
// Error: 'c' is not a module
module a {}
module b from c; | JavaScript |
// Should not compile.
// Error: 'c' is not exported by b
module a {
module b {
module c {};
}
export {c} from b;
} | JavaScript |
import * from '@name';
var n1 = new Name();
assertTrue(isName(n1));
| JavaScript |
// Should not compile.
// Error: 'c' is not a module
module a {
export module b from c;
}
| JavaScript |
// Should not compile.
// Error: 'd' is not a module
module a {
module b {}
module c from b.d;
}
| JavaScript |
// Should not compile.
// Error: 'c' is not exported by b
module a {
module b {
module c {};
}
export c from b;
} | JavaScript |
module m {
export var x = 1;
export var y = 2;
}
import {x: renamedX, y} from m;
import x from m;
module m2 from m;
assertEquals(1, x);
assertEquals(1, renamedX);
assertEquals(2, y);
assertEquals(x, renamedX);
assertEquals(x, m.x);
// Closure tests cannot handle Object.create(null)
assertTrue(m === m2);
assertEq... | JavaScript |
import {Name: create, isName} from '@name';
import Name from '@name';
module n from '@name'
var n1 = create();
var n2 = Name();
var n3 = new Name();
assertTrue(isName(n1));
assertTrue(isName(n2));
assertTrue(isName(n3));
assertEquals(Name, create);
assertEquals(n.Name, Name);
assertEquals(isName, isName);
| JavaScript |
// Should not compile.
// Error: 'identifier' expected
function f(x,) {
return x;
}
| JavaScript |
// Should not compile.
// Error: initializer is not allowed in for-of loop with pattern
// Error: for-of statement may not have initializer
for (var {k} = {} of []) {
}
| JavaScript |
// Should not compile.
// Options: --destructuring=false
var [x, y] = [0, 1];
| JavaScript |
var object = {
set x({message: [head, ...tail], name}) {
assertEquals('a', head);
assertArrayEquals(['b', 'c'], tail);
assertEquals('Error', name);
}
};
object.x = new Error('abc');
| JavaScript |
function destructEvaluatesToRvalue() {
var a;
return [a] = [1, 2, 3];
}
// ----------------------------------------------------------------------------
var result = destructEvaluatesToRvalue();
assertArrayEquals([1, 2, 3], result);
| JavaScript |
function destructScopeThis() {
var x;
var o = {
f: function() {
[this.x] = [1];
}
};
o.f();
return {
x: x,
o_x: o.x
};
}
// ----------------------------------------------------------------------------
var result = destructScopeThis();
assertUndefined(result.x);
assertEquals(1, result... | JavaScript |
function destructVarDecl() {
// Const; and an array inside an object literal inside an array.
const a = 0, [b, {c, x: [d]}] = [1, {c: 2, x: [3]}];
// Now an object literal inside an array inside an object literal.
var {x: [{e}, f], g} = {x: [{e:4}, 5], g: 6};
// Two patterns in one var.
var {h} = {h: 7}, ... | JavaScript |
var a, b, c, d;
[a, [b, c], d] = ['hello', [',', 'junk'], ['world']];
// ----------------------------------------------------------------------------
assertEquals('hello', a);
assertEquals(',', b);
assertEquals('junk', c);
assertArrayEquals(['world'], d);
| JavaScript |
class C {
constructor({message: [head, ...tail], name}) {
assertEquals('a', head);
assertArrayEquals(['b', 'c'], tail);
assertEquals('Error', name);
}
method({message: [head, ...tail], name}) {
assertEquals('a', head);
assertArrayEquals(['b', 'c'], tail);
assertEquals('Error', name);
}
... | JavaScript |
// Should not compile.
// Error: innerX is not defined
try {
throw [0];
} catch ([innerX]) {
}
innerX;
| JavaScript |
// Destructuring bind alpha-renames 'arguments'; this ensures that
// renaming doesn't rename in nested scopes.
function destructNestedScopeArguments(x) {
[(function () { return arguments[1]; })(null, x)[0]] = [42];
}
// ----------------------------------------------------------------------------
var result = [];
d... | JavaScript |
function* gen() {
yield 'abc';
yield 'def';
}
var expectedHeads = ['a', 'd'];
var expectedTails = [['b', 'c'], ['e','f']];
var i = 0;
for (var [head, ...tail] of gen()) {
assertEquals(expectedHeads[i], head);
assertArrayEquals(expectedTails[i], tail);
i++;
}
assertEquals(2, i);
{
let x = 42;
for (let {l... | JavaScript |
// Should not compile.
// Error: (4, 23): Semi-colon expected
var f = ([...xs, ys]) => xs;
| JavaScript |
// Should not compile.
// Error: initializer is not allowed in for-in loop with pattern
for (var {k} = {} in {}) {
}
| JavaScript |
var f = ({x}) => x;
assertEquals(42, f({x: 42}));
var g = ({x: y, z: [a, b, ...c]}) => [y, a, b, c];
assertArrayEquals([1, 2, 3, [4, 5]], g({x: 1, z: [2, 3, 4, 5]}));
var h = ([a, {b: c, d}]) => [a, c, d];
assertArrayEquals([1, 2, 3], h([1, {b: 2, d: 3}]));
| JavaScript |
function destructRest() {
var a, b, c, d, e;
[...a] = [1, 2, 3];
[b, ...c] = [1, 2, 3];
[,,, ...d] = [1, 2, 3];
[...e] = {x: 'boom'};
return {a: a, b: b, c: c, d: d, e: e};
}
// ----------------------------------------------------------------------------
var result = destructRest();
assertArrayEquals([1, ... | JavaScript |
function f([x] = [1], {y} = {y: 2}) {
return x + y;
}
assertEquals(3, f()); | JavaScript |
var object = {
method({message: [head, ...tail], name}) {
assertEquals('a', head);
assertArrayEquals(['b', 'c'], tail);
assertEquals('Error', name);
}
};
object.method(new Error('abc'));
| JavaScript |
function destructObject() {
var a, b, c, d;
({a, x: b, y: {c, z: [,d]}} = {
a: 7, // field with shorthand a => a: a syntax
x: 8, // typical syntax
y: { // nested object destructuring
// missing binding 'c'
z: [10, 11, 12] // nested array destructuring
}
});
return {
a: ... | JavaScript |
var head = 'head';
var tail = 'tail';
var name = 'name';
try {
throw new Error('abc');
} catch ({message: [head, ...tail], name}) {
assertEquals('a', head);
assertArrayEquals(['b', 'c'], tail);
assertEquals('Error', name);
}
assertEquals('head', head);
assertEquals('tail', tail);
assertEquals('name', name); | JavaScript |
var [a = 0] = [];
assertEquals(0, a);
var {b = 1} = {};
assertEquals(1, b);
var {c = 2} = {c: 3};
assertEquals(3, c);
var {d = 4} = Object.create({d: 5});
assertEquals(5, d);
var {e: f = 6} = {};
assertEquals(6, f);
var {g: h = 7} = {h: 8};
assertEquals(7, h);
var [, , , i = 9] = [10, 11, 12];
assertEquals(9, i);... | JavaScript |
function destructArray() {
var a, b, c, d;
[a, [b], c, d] = ['hello', [',', 'junk'], ['world']];
return {
a: a,
b: b,
c: c,
d: d
};
}
// ----------------------------------------------------------------------------
var result = destructArray();
assertEquals('hello', result.a);
assertEquals(',',... | JavaScript |
var object = {
abc: 0, // Keep all the keys at length 3.
def: 1
};
var expectedHeads = ['a', 'd'];
var expectedTails = [['b', 'c'], ['e','f']];
var i = 0;
for (var [head, ...tail] in object) {
assertEquals(expectedHeads[i], head);
assertArrayEquals(expectedTails[i], tail);
i++;
}
assertEquals(2, i);
{
le... | JavaScript |
function destructEvaluationOrder() {
var a;
[a, a, a] = [1, 2, 3, 4];
return a;
}
// ----------------------------------------------------------------------------
var result = destructEvaluationOrder();
assertEquals(3, result);
| JavaScript |
function destructureArguments(x, y) {
[arguments[0], [arguments[1]]] = [1, [2]]
return x + y;
}
// ----------------------------------------------------------------------------
assertEquals(3, destructureArguments(1, 2));
| JavaScript |
function f([a, b, ...c], d) {
return [a, b, c, d];
}
assertArrayEquals([1, 2, [3, 4], 5], f([1, 2, 3, 4], 5)); | JavaScript |
function f({a, b: {c}}, d) {
return [a, c, d];
}
assertArrayEquals([1, 2, 3], f({a: 1, b: {c: 2}}, 3)); | JavaScript |
function f(...args) {
return args;
}
var result = f(0, ...undefined, 1);
// ----------------------------------------------------------------------------
assertArrayEquals([0, 1], result);
| JavaScript |
// Should not compile.
// Options: --spread=false
[0, 1, ...[2, 3]];
| JavaScript |
var d = new Date(...[2011, 4, 3]);
// ----------------------------------------------------------------------------
assertEquals(2011, d.getFullYear());
assertEquals(4, d.getMonth());
assertEquals(3, d.getDate());
| JavaScript |
class SpreadTestClass {
constructor(x, y) {
this.SpreadTestClass = SpreadTestClass;
this.self = this;
this.x = x;
this.y = y;
}
}
var object = new SpreadTestClass(...[0, 1]);
// ----------------------------------------------------------------------------
assertEquals(object.x, 0);
assertEquals(ob... | JavaScript |
function f(...args) {
return args;
}
var result = f(0, ...[1, 2], 3);
// ----------------------------------------------------------------------------
assertArrayEquals([0, 1, 2, 3], result);
| JavaScript |
// ----------------------------------------------------------------------------
assertArrayEquals([0, 1], [0, ...null, 1]);
assertArrayEquals([0, 1], [0, ...undefined, 1]);
assertArrayEquals([0, 1], [0, ...{}, 1]);
assertArrayEquals([0, 1, 2, 3], [0, ...{0: 1, 1: 2, length: 2}, 3]);
assertArrayEquals([0, 'a', 'b', 'c... | JavaScript |
function F(x, y, z) {
this.x = x;
this.y = y;
this.z = z;
this.self = this;
this.F = F;
}
var object = new F(0, ...[1, 2]);
// ----------------------------------------------------------------------------
assertEquals(0, object.x);
assertEquals(1, object.y);
assertEquals(2, object.z);
assertEquals(object, o... | JavaScript |
var obj = {
method: function(...args) {
return {
self: this,
args: args
};
}
};
var result = {
obj: obj,
result: obj.method(0, ...[1, 2], 3)
};
// ----------------------------------------------------------------------------
assertEquals(result.obj, result.result.self);
assertArrayEquals([... | JavaScript |
var obj = {
method: function(...args) {
return {
self: this,
args: args
};
}
};
var result = {
obj: obj,
result: obj['meth' + 'od'](0, ...[1, 2], 3)
};
// ----------------------------------------------------------------------------
assertEquals(result.obj, result.result.self);
assertArray... | JavaScript |
function G() {}
function F(x, y, z) {
var obj = new G;
obj.x = x;
obj.y = y;
obj.z = z;
obj.f = this;
obj.G = G;
obj.F = F;
return obj;
}
var object = new F(0, ...[1, 2]);
// ----------------------------------------------------------------------------
assertEquals(0, object.x);
assertEquals(1, objec... | JavaScript |
var a = [];
var b = [0, ...a];
var c = [...b, ...b];
var d;
var e = [0, ...d = [1, 2], 3];
var f = [0, ...[[1, 2], [3, 4]], 5];
// ----------------------------------------------------------------------------
assertArrayEquals([0], b);
assertArrayEquals([0, 0], c);
assertArrayEquals([1, 2], d);
assertArrayEquals([0, 1... | JavaScript |
// Should not compile.
var object = {
a() {},,
};
| JavaScript |
// Should not compile.
// Options: --propertyOptionalComma=false
var object = {
get x() {
return 42;
}
set x(v) {}
};
| JavaScript |
var object = {
a() {}
b() {}
c() {},
get d() {}
get e() {}
get f() {},
set g(g) {}
set h(h) {}
set i(i) {},
};
// ----------------------------------------------------------------------------
assertTrue(object.hasOwnProperty('a'));
assertTrue(object.hasOwnProperty('b'));
assertTrue(object.hasOwnPrope... | JavaScript |
// Should not compile.
var object = {
a: 0
b: 1
};
| JavaScript |
// Should not compile.
var object = {
a() {
},,
b() {}
};
| JavaScript |
import elementGet from '@name';
{
var getLog = [];
var object = {};
object[elementGet] = function(index) {
assertEquals(object, this);
getLog.push(index);
return function() {
assertEquals(object, this);
return index;
};
};
var tmp = {};
function f() {}
var re = /regexp/
a... | JavaScript |
import {elementGet, elementSet, elementDelete} from '@name';
{
var setLog = [];
var getLog = [];
var deleteLog = [];
var object = {};
object[elementGet] = function(name) {
assertEquals(object, this);
getLog.push(name);
return name;
};
var tmp = {};
function f() {}
var re = /regexp/;
... | JavaScript |
module Name from '@name';
{
function isIndex(s) {
// toUint32: s >>> 0
return s == String(s >>> 0);
}
function ArrayLike() {
// This should use a private name.
Object.defineProperty(this, '_length', {
value: 0,
writable: true
});
}
ArrayLike.prototype = Object.create({}, {
... | JavaScript |
function f(a = 1, b = 2) {
return a + b;
}
assertEquals(0, f.length);
assertEquals(3, f());
assertEquals(6, f(4));
assertEquals(24, f(8, 16));
function g(a, b = a) {
return a + b;
}
assertEquals(1, g.length);
assertEquals(4, g(2));
assertEquals(5, g(2, 3));
function C(obj = this) {
this.obj = obj;
}
assertEq... | JavaScript |
// Should not compile.
// Error: (6, 15): ')' expected
var object = {
// Defautl parameters are not allowed on setters.
set x(value = 42) {}
} | JavaScript |
function f() {
return 'outer';
}
{
(function f() {
return 'inner';
});
assertEquals('outer', f());
}
assertEquals('outer', f());
| JavaScript |
var result;
{
let let_x = 'let x';
let let_l = [];
for (var var_x = 1, var_y = 2, var_z = 3; var_x < 10; var_x ++) {
let l_x = var_x, l_y = var_y, l_z = var_z;
let_l.push( function() { return [ l_x, l_y, l_z ]; } );
}
result = let_l;
}
// ------------------------------------------------------------... | JavaScript |
for (var x = 0; x < 10; x ++) {
for (var y = 0; y < 10; y ++) {
let z = 'let z';
if (x == 7) {
continue;
}
}
}
// ----------------------------------------------------------------------------
| JavaScript |
function letInClosure(n) {
var l = [];
for (var i = 0; i < n; i ++) {
let let_i = i;
if (i % 3 == 0) {
continue;
}
l.push(function() {
return let_i;
});
}
return l;
}
// ----------------------------------------------------------------------------
var result = letInClosure(10);
... | JavaScript |
var a = 'var a';
{
var b = 'var b';
{
let c = 'let c';
{
var d = 'var d';
}
}
}
// ----------------------------------------------------------------------------
| JavaScript |
for (var i = 0; i < 5; i ++) {
let let_x = 'let x';
switch (i) {
case 0:
break;
case 2:
break;
default:
break;
}
}
// ----------------------------------------------------------------------------
| JavaScript |
for (var x = 0; x < 10; x ++) {
let y = 'let y';
}
// ----------------------------------------------------------------------------
| JavaScript |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.