Merge branch 'master' into jsSigHelp

Conflicts:
	src/services/outliningElementsCollector.ts
	src/services/services.ts

tests/cases/compiler/declarationEmitDefaultExport8.ts

@@ -0,0 +1,6 @@
+// @declaration: true
+// @target: es6
+
+var _default = 1;
+export {_default as d}
+export default 1 + 2;

tests/cases/compiler/errorRecoveryInClassDeclaration.ts

@@ -0,0 +1,7 @@
+class C {
+    public bar() {
+        var v = foo(
+            public blaz() {}
+            );
+    }
+}

tests/cases/compiler/exportDefaultTypeAnnoation.ts

@@ -1,4 +0,0 @@
-// @target: es5
-// @module: commonjs
-
-export default : number;

tests/cases/compiler/exportDefaultTypeAnnoation2.ts

@@ -1,6 +0,0 @@
-// @target: es5
-// @module: commonjs
-
-declare module "mod" {
-    export default : number;
-}

tests/cases/compiler/exportDefaultTypeAnnoation3.ts

@@ -1,15 +0,0 @@
-// @target: es5
-// @module: commonjs
-
-// @fileName: mod.d.ts
-declare module "mod" {
-    export default : number;
-}
-
-// @fileName: reference1.ts
-import d from "mod";
-var s: string = d; // Error
-
-// @fileName: reference2.ts
-import { default as d } from "mod";
-var s: string = d; // Error

tests/cases/compiler/generatorES6_1.ts

@@ -0,0 +1,4 @@
+// @target: es6
+function* foo() {
+    yield
+}

tests/cases/compiler/generatorES6_2.ts

@@ -0,0 +1,6 @@
+// @target: es6
+class C {
+    public * foo() {
+        yield 1
+    }
+}

tests/cases/compiler/generatorES6_3.ts

@@ -0,0 +1,4 @@
+// @target: es6
+var v = function*() {
+    yield 0
+}

tests/cases/compiler/generatorES6_4.ts

@@ -0,0 +1,6 @@
+// @target: es6
+var v = { 
+   *foo() {
+       yield 0
+   }
+}

tests/cases/compiler/generatorES6_5.ts

@@ -0,0 +1,4 @@
+// @target: es6
+function* foo() {
+    yield a ? b : c;
+}

tests/cases/compiler/generatorES6_6.ts

@@ -0,0 +1,6 @@
+// @target: es6
+class C {
+  *[Symbol.iterator]() {
+    let a = yield 1;
+  }
+}

tests/cases/compiler/reservedWords2.ts

@@ -0,0 +1,12 @@
+import while = require("dfdf");
+import * as  while from "foo"
+
+var typeof = 10;
+function throw() {}
+module void {}
+var {while, return} = { while: 1, return: 2 };
+var {this, switch: { continue} } = { this: 1, switch: { continue: 2 }};
+var [debugger, if] = [1, 2];
+enum void {}
+
+

tests/cases/compiler/strictMode1.ts

@@ -1,3 +0,0 @@
-"use strict";
-class A {}
-class B extends A {}

tests/cases/compiler/strictMode2.ts

@@ -1,6 +0,0 @@
-"use strict";
-
-function foo() {
-
-    return 30;
-}

tests/cases/compiler/strictMode3.ts

@@ -1,11 +0,0 @@
-"use strict";
-
-class A {
-}
-
-class B extends A {
-}
-
-function foo() {
-    return this.window;
-}

tests/cases/compiler/strictMode4.ts

@@ -1,4 +0,0 @@
-"use strict";
-
-class A {
-}

tests/cases/compiler/strictMode5.ts

@@ -1,18 +0,0 @@
-function foo(...args) {
-    "use strict"
-}
-
-class A {
-    m() {
-        "use strict"
-
-        var v = () => {
-            return this.n();
-        };
-    }
-    n() {}
-}
-
-function bar(x: number = 10) {
-    "use strict"
-}

tests/cases/compiler/strictModeReservedWord.ts

@@ -0,0 +1,26 @@
+let let = 10;
+
+function foo() {
+    "use strict"
+    var public = 10;
+    var static = "hi";
+    let let = "blah";
+    var package = "hello"
+    function package() { }
+    function bar(private, implements, let) { }
+    function baz<implements, protected>() { }
+    function barn(cb: (private, public, package) => void) { }
+    barn((private, public, package) => { });
+
+    var myClass = class package extends public {}
+
+    var b: public.bar;
+
+    function foo(x: private.x) { }
+    function foo1(x: private.package.x) { }
+    function foo2(x: private.package.protected) { }
+    let b: interface.package.implements.B;
+    ublic();
+    static();
+}
+

tests/cases/compiler/strictModeReservedWord2.ts

@@ -0,0 +1,23 @@
+"use strict"
+interface public { }
+interface implements {
+    foo(package, protected);
+}
+enum package { }
+enum foo {
+    public,
+    private,
+    pacakge
+}
+
+const enum private {
+    public,
+    private,
+    pacakge
+}
+
+const enum bar {
+    public,
+    private,
+    pacakge
+}

tests/cases/compiler/strictModeReservedWordInClassDeclaration.ts

@@ -0,0 +1,28 @@
+interface public { }
+
+class Foo {
+    constructor(private, public, static) {
+        private = public = static;
+    }
+    public banana(x: public) { }
+}
+
+class C {
+    constructor(public public, let) {
+    }
+    foo1(private, static, public) {
+        function let() { }
+        var z = function let() { };
+    }
+
+    public pulbic() { } // No Error;
+}
+
+class D<public, private>{ }
+
+class E implements public { }
+
+class F implements public.private.B { }
+class F1 implements public.private.implements { }
+class G extends package { }
+class H extends package.A { }

tests/cases/compiler/strictModeReservedWordInDestructuring.ts

@@ -0,0 +1,6 @@
+"use strict"
+var [public] = [1];
+var { x: public } = { x: 1 };
+var [[private]] = [["hello"]];
+var { y: { s: static }, z: { o: { p: package} }} = { y: { s: 1 }, z: { o: { p: 'h' } } };
+var {public, protected} = { public: 1, protected: 2 };

tests/cases/compiler/strictModeReservedWordInImportEqualDeclaration.ts

@@ -0,0 +1,4 @@
+// @module: commonjs
+
+"use strict"
+import public = require("1");

tests/cases/compiler/strictModeReservedWordInModuleDeclaration.ts

@@ -0,0 +1,6 @@
+"use strict"
+module public { }
+module private { }
+module public.whatever {
+}
+module private.public.foo { }

tests/cases/compiler/strictModeWordInExportDeclaration.ts

@@ -0,0 +1,6 @@
+// @target: ES6
+"use strict"
+var x = 1;
+export { x as foo }
+export { x as implements }
+export { x as while }

tests/cases/compiler/strictModeWordInImportDeclaration.ts

@@ -0,0 +1,5 @@
+// @target: ES6
+"use strict"
+import * as package from "./1"
+import {foo as private} from "./1"
+import public from "./1"

tests/cases/conformance/decorators/class/decoratedClassFromExternalModule.ts

@@ -0,0 +1,9 @@
+// @target: es6
+// @Filename: decorated.ts
+function decorate() { }
+
+@decorate
+export default class Decorated { }
+
+// @Filename: undecorated.ts
+import Decorated from 'decorated';

tests/cases/conformance/decorators/class/method/decoratorOnClassMethod11.ts

@@ -1,9 +1,9 @@
-// @target: ES5
-module M {
-    class C {
-        decorator(target: Object, key: string): void { }
-
-        @this.decorator
-        method() { }
-    }
+// @target: ES5
+module M {
+    class C {
+        decorator(target: Object, key: string): void { }
+
+        @this.decorator
+        method() { }
+    }
 }

tests/cases/conformance/decorators/class/method/decoratorOnClassMethod13.ts

@@ -0,0 +1,7 @@
+// @target: ES6
+declare function dec(): <T>(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T>;
+
+class C {
+    @dec ["1"]() { }
+    @dec ["b"]() { }
+}

tests/cases/conformance/es6/Symbols/symbolDeclarationEmit1.ts

@@ -1,5 +1,5 @@
 //@target: ES6
 //@declaration: true
 class C {
-    [Symbol.isRegExp]: number;
+    [Symbol.toPrimitive]: number;
 }

tests/cases/conformance/es6/Symbols/symbolDeclarationEmit11.ts

@@ -2,7 +2,7 @@
 //@declaration: true
 class C {
     static [Symbol.iterator] = 0;
-    static [Symbol.toPrimitive]() { }
-    static get [Symbol.isRegExp]() { return ""; }
-    static set [Symbol.isRegExp](x) { }
+    static [Symbol.isConcatSpreadable]() { }
+    static get [Symbol.toPrimitive]() { return ""; }
+    static set [Symbol.toPrimitive](x) { }
 }

tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts

@@ -8,7 +8,7 @@ module M {
         [Symbol.isConcatSpreadable](): I {
             return undefined
         }
-        get [Symbol.isRegExp]() { return undefined; }
-        set [Symbol.isRegExp](x: I) { }
+        get [Symbol.toPrimitive]() { return undefined; }
+        set [Symbol.toPrimitive](x: I) { }
     }
 }

tests/cases/conformance/es6/Symbols/symbolDeclarationEmit13.ts

@@ -1,6 +1,6 @@
 //@target: ES6
 //@declaration: true
 class C {
-    get [Symbol.isRegExp]() { return ""; }
+    get [Symbol.toPrimitive]() { return ""; }
     set [Symbol.toStringTag](x) { }
 }

tests/cases/conformance/es6/Symbols/symbolDeclarationEmit14.ts

@@ -1,6 +1,6 @@
 //@target: ES6
 //@declaration: true
 class C {
-    get [Symbol.isRegExp]() { return ""; }
+    get [Symbol.toPrimitive]() { return ""; }
     get [Symbol.toStringTag]() { return ""; }
 }

tests/cases/conformance/es6/Symbols/symbolDeclarationEmit2.ts

@@ -1,5 +1,5 @@
 //@target: ES6
 //@declaration: true
 class C {
-    [Symbol.isRegExp] = "";
+    [Symbol.toPrimitive] = "";
 }

tests/cases/conformance/es6/Symbols/symbolDeclarationEmit3.ts

@@ -1,7 +1,7 @@
 //@target: ES6
 //@declaration: true
 class C {
-    [Symbol.isRegExp](x: number);
-    [Symbol.isRegExp](x: string);
-    [Symbol.isRegExp](x: any) { }
+    [Symbol.toPrimitive](x: number);
+    [Symbol.toPrimitive](x: string);
+    [Symbol.toPrimitive](x: any) { }
 }

tests/cases/conformance/es6/Symbols/symbolDeclarationEmit4.ts

@@ -1,6 +1,6 @@
 //@target: ES6
 //@declaration: true
 class C {
-    get [Symbol.isRegExp]() { return ""; }
-    set [Symbol.isRegExp](x) { }
+    get [Symbol.toPrimitive]() { return ""; }
+    set [Symbol.toPrimitive](x) { }
 }

tests/cases/conformance/es6/Symbols/symbolProperty21.ts

@@ -8,6 +8,6 @@ declare function foo<T, U>(p: I<T, U>): { t: T; u: U };
 
 foo({
     [Symbol.isConcatSpreadable]: "",
-    [Symbol.isRegExp]: 0,
+    [Symbol.toPrimitive]: 0,
     [Symbol.unscopables]: true
 });

tests/cases/conformance/es6/Symbols/symbolProperty5.ts

@@ -1,7 +1,7 @@
 //@target: ES6
 var x = {
     [Symbol.iterator]: 0,
-    [Symbol.isRegExp]() { },
+    [Symbol.toPrimitive]() { },
     get [Symbol.toStringTag]() {
         return 0;
     }

tests/cases/conformance/es6/Symbols/symbolProperty6.ts

@@ -2,7 +2,7 @@
 class C {
     [Symbol.iterator] = 0;
     [Symbol.unscopables]: number;
-    [Symbol.isRegExp]() { }
+    [Symbol.toPrimitive]() { }
     get [Symbol.toStringTag]() {
         return 0;
     }

tests/cases/conformance/es6/Symbols/symbolProperty8.ts

@@ -1,5 +1,5 @@
 //@target: ES6
 interface I {
     [Symbol.unscopables]: number;
-    [Symbol.isRegExp]();
+    [Symbol.toPrimitive]();
 }

tests/cases/conformance/es6/arrowFunction/emitArrowFunctionES6.ts

@@ -6,3 +6,15 @@ var f4 = (x: string, y: number, z=10) => { }
 function foo(func: () => boolean) { }
 foo(() => true);
 foo(() => { return false; });
+
+// Binding patterns in arrow functions
+var p1 = ([a]) => { };
+var p2 = ([...a]) => { };
+var p3 = ([, a]) => { };
+var p4 = ([, ...a]) => { };
+var p5 = ([a = 1]) => { };
+var p6 = ({ a }) => { };
+var p7 = ({ a: { b } }) => { };
+var p8 = ({ a = 1 }) => { };
+var p9 = ({ a: { b = 1 } = { b: 1 } }) => { };
+var p10 = ([{ value, done }]) => { };

tests/cases/conformance/es6/classDeclaration/emitClassDeclarationWithSuperMethodCall01.ts

@@ -0,0 +1,12 @@
+//@target: es6
+
+class Parent {
+    foo() {
+    }
+}
+
+class Foo extends Parent {
+    foo() {
+        var x = () => super.foo();
+    }
+}

tests/cases/conformance/es6/destructuring/iterableArrayPattern1.ts

@@ -0,0 +1,14 @@
+//@target: ES6
+var [a, b] = new SymbolIterator;
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/destructuring/iterableArrayPattern10.ts

@@ -0,0 +1,17 @@
+//@target: ES6
+function fun([a, b]) { }
+fun(new FooIterator);
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/destructuring/iterableArrayPattern11.ts

@@ -0,0 +1,17 @@
+//@target: ES6
+function fun([a, b] = new FooIterator) { }
+fun(new FooIterator);
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/destructuring/iterableArrayPattern12.ts

@@ -0,0 +1,17 @@
+//@target: ES6
+function fun([a, ...b] = new FooIterator) { }
+fun(new FooIterator);
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/destructuring/iterableArrayPattern13.ts

@@ -0,0 +1,17 @@
+//@target: ES6
+function fun([a, ...b]) { }
+fun(new FooIterator);
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/destructuring/iterableArrayPattern14.ts

@@ -0,0 +1,17 @@
+//@target: ES6
+function fun(...[a, ...b]) { }
+fun(new FooIterator);
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/destructuring/iterableArrayPattern15.ts

@@ -0,0 +1,17 @@
+//@target: ES6
+function fun(...[a, b]: Bar[]) { }
+fun(...new FooIterator);
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/destructuring/iterableArrayPattern16.ts

@@ -0,0 +1,30 @@
+//@target: ES6
+function fun(...[a, b]: [Bar, Bar][]) { }
+fun(...new FooIteratorIterator);
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+class FooIteratorIterator {
+    next() {
+        return {
+            value: new FooIterator,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/destructuring/iterableArrayPattern17.ts

@@ -0,0 +1,17 @@
+//@target: ES6
+function fun(...[a, b]: Bar[]) { }
+fun(new FooIterator);
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/destructuring/iterableArrayPattern18.ts

@@ -0,0 +1,17 @@
+//@target: ES6
+function fun([a, b]: Bar[]) { }
+fun(new FooIterator);
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/destructuring/iterableArrayPattern19.ts

@@ -0,0 +1,17 @@
+//@target: ES6
+function fun([[a], b]: Bar[][]) { }
+fun(new FooArrayIterator);
+class Bar { x }
+class Foo extends Bar { y }
+class FooArrayIterator {
+    next() {
+        return {
+            value: [new Foo],
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/destructuring/iterableArrayPattern2.ts

@@ -0,0 +1,14 @@
+//@target: ES6
+var [a, ...b] = new SymbolIterator;
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/destructuring/iterableArrayPattern20.ts

@@ -0,0 +1,17 @@
+//@target: ES6
+function fun(...[[a = new Foo], b = [new Foo]]: Bar[][]) { }
+fun(...new FooArrayIterator);
+class Bar { x }
+class Foo extends Bar { y }
+class FooArrayIterator {
+    next() {
+        return {
+            value: [new Foo],
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/destructuring/iterableArrayPattern21.ts

@@ -0,0 +1,2 @@
+//@target: ES6
+var [a, b] = { 0: "", 1: true };

tests/cases/conformance/es6/destructuring/iterableArrayPattern22.ts

@@ -0,0 +1,2 @@
+//@target: ES6
+var [...a] = { 0: "", 1: true };

tests/cases/conformance/es6/destructuring/iterableArrayPattern23.ts

@@ -0,0 +1,3 @@
+//@target: ES6
+var a: string, b: boolean;
+[a, b] = { 0: "", 1: true };

tests/cases/conformance/es6/destructuring/iterableArrayPattern24.ts

@@ -0,0 +1,3 @@
+//@target: ES6
+var a: string, b: boolean[];
+[a, ...b] = { 0: "", 1: true };

tests/cases/conformance/es6/destructuring/iterableArrayPattern25.ts

@@ -0,0 +1,3 @@
+//@target: ES6
+function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]) { }
+takeFirstTwoEntries(new Map([["", 0], ["hello", 1]]));

tests/cases/conformance/es6/destructuring/iterableArrayPattern26.ts

@@ -0,0 +1,3 @@
+//@target: ES6
+function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]: [string, number][]) { }
+takeFirstTwoEntries(new Map([["", 0], ["hello", 1]]));

tests/cases/conformance/es6/destructuring/iterableArrayPattern27.ts

@@ -0,0 +1,3 @@
+//@target: ES6
+function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]: [string, number][]) { }
+takeFirstTwoEntries(...new Map([["", 0], ["hello", 1]]));

tests/cases/conformance/es6/destructuring/iterableArrayPattern28.ts

@@ -0,0 +1,3 @@
+//@target: ES6
+function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]: [string, number][]) { }
+takeFirstTwoEntries(...new Map([["", 0], ["hello", true]]));

tests/cases/conformance/es6/destructuring/iterableArrayPattern29.ts

@@ -0,0 +1,3 @@
+//@target: ES6
+function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]: [string, number][]) { }
+takeFirstTwoEntries(...new Map([["", true], ["hello", true]]));

tests/cases/conformance/es6/destructuring/iterableArrayPattern3.ts

@@ -0,0 +1,17 @@
+//@target: ES6
+var a: Bar, b: Bar;
+[a, b] = new FooIterator;
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/destructuring/iterableArrayPattern30.ts

@@ -0,0 +1,2 @@
+//@target: ES6
+const [[k1, v1], [k2, v2]] = new Map([["", true], ["hello", true]])

tests/cases/conformance/es6/destructuring/iterableArrayPattern4.ts

@@ -0,0 +1,17 @@
+//@target: ES6
+var a: Bar, b: Bar[];
+[a, ...b] = new FooIterator;
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/destructuring/iterableArrayPattern5.ts

@@ -0,0 +1,17 @@
+//@target: ES6
+var a: Bar, b: string;
+[a, b] = new FooIterator;
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/destructuring/iterableArrayPattern6.ts

@@ -0,0 +1,17 @@
+//@target: ES6
+var a: Bar, b: string[];
+[a, ...b] = new FooIterator;
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/destructuring/iterableArrayPattern7.ts

@@ -0,0 +1,17 @@
+//@target: ES6
+var a: Bar, b: string[];
+[a, b] = new FooIterator;
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/destructuring/iterableArrayPattern8.ts

@@ -0,0 +1,17 @@
+//@target: ES6
+var a: Bar, b: string;
+[a, ...b] = new FooIterator;
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/destructuring/iterableArrayPattern9.ts

@@ -0,0 +1,16 @@
+//@target: ES6
+function fun([a, b] = new FooIterator) { }
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/for-ofStatements/for-of57.ts

@@ -0,0 +1,3 @@
+//@target: ES6
+var iter: Iterable<number>;
+for (let num of iter) { }

tests/cases/conformance/es6/spread/iteratorSpreadInArray.ts

@@ -0,0 +1,15 @@
+//@target: ES6
+var array = [...new SymbolIterator];
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/spread/iteratorSpreadInArray10.ts

@@ -0,0 +1,8 @@
+//@target: ES6
+var array = [...new SymbolIterator];
+
+class SymbolIterator {
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/spread/iteratorSpreadInArray11.ts

@@ -0,0 +1,3 @@
+//@target: ES6
+var iter: Iterable<number>;
+var array = [...iter];

tests/cases/conformance/es6/spread/iteratorSpreadInArray2.ts

@@ -0,0 +1,28 @@
+//@target: ES6
+var array = [...new NumberIterator, ...new SymbolIterator];
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+class NumberIterator {
+    next() {
+        return {
+            value: 0,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/spread/iteratorSpreadInArray3.ts

@@ -0,0 +1,15 @@
+//@target: ES6
+var array = [...[0, 1], ...new SymbolIterator];
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/spread/iteratorSpreadInArray4.ts

@@ -0,0 +1,15 @@
+//@target: ES6
+var array = [0, 1, ...new SymbolIterator];
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/spread/iteratorSpreadInArray5.ts

@@ -0,0 +1,15 @@
+//@target: ES6
+var array: number[] = [0, 1, ...new SymbolIterator];
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/spread/iteratorSpreadInArray6.ts

@@ -0,0 +1,16 @@
+//@target: ES6
+var array: number[] = [0, 1];
+array.concat([...new SymbolIterator]);
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/spread/iteratorSpreadInArray7.ts

@@ -0,0 +1,16 @@
+//@target: ES6
+var array: symbol[];
+array.concat([...new SymbolIterator]);
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/spread/iteratorSpreadInArray8.ts

@@ -0,0 +1,11 @@
+//@target: ES6
+var array = [...new SymbolIterator];
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+}

tests/cases/conformance/es6/spread/iteratorSpreadInArray9.ts

@@ -0,0 +1,14 @@
+//@target: ES6
+var array = [...new SymbolIterator];
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol()
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/spread/iteratorSpreadInCall.ts

@@ -0,0 +1,16 @@
+//@target: ES6
+foo(...new SymbolIterator);
+
+function foo(s: symbol) { }
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/spread/iteratorSpreadInCall10.ts

@@ -0,0 +1,17 @@
+//@target: ES6
+foo(...new SymbolIterator);
+
+function foo<T>(s: T[]) { return s[0] }
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/spread/iteratorSpreadInCall11.ts

@@ -0,0 +1,17 @@
+//@target: ES6
+foo(...new SymbolIterator);
+
+function foo<T>(...s: T[]) { return s[0] }
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/spread/iteratorSpreadInCall12.ts

@@ -0,0 +1,32 @@
+//@target: ES6
+new Foo(...[...new SymbolIterator, ...[...new StringIterator]]);
+
+class Foo<T> {
+    constructor(...s: T[]) { }
+}
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+class StringIterator {
+    next() {
+        return {
+            value: "",
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/spread/iteratorSpreadInCall2.ts

@@ -0,0 +1,16 @@
+//@target: ES6
+foo(...new SymbolIterator);
+
+function foo(s: symbol[]) { }
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/spread/iteratorSpreadInCall3.ts

@@ -0,0 +1,16 @@
+//@target: ES6
+foo(...new SymbolIterator);
+
+function foo(...s: symbol[]) { }
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/spread/iteratorSpreadInCall4.ts

@@ -0,0 +1,16 @@
+//@target: ES6
+foo(...new SymbolIterator);
+
+function foo(s1: symbol, ...s: symbol[]) { }
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/spread/iteratorSpreadInCall5.ts

@@ -0,0 +1,29 @@
+//@target: ES6
+foo(...new SymbolIterator, ...new StringIterator);
+
+function foo(...s: (symbol | string)[]) { }
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+class StringIterator {
+    next() {
+        return {
+            value: "",
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/spread/iteratorSpreadInCall6.ts

@@ -0,0 +1,29 @@
+//@target: ES6
+foo(...new SymbolIterator, ...new StringIterator);
+
+function foo(...s: (symbol | number)[]) { }
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+class StringIterator {
+    next() {
+        return {
+            value: "",
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/spread/iteratorSpreadInCall7.ts

@@ -0,0 +1,29 @@
+//@target: ES6
+foo(...new SymbolIterator, ...new StringIterator);
+
+function foo<T>(...s: T[]) { return s[0]; }
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+class StringIterator {
+    next() {
+        return {
+            value: "",
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/spread/iteratorSpreadInCall8.ts

@@ -0,0 +1,32 @@
+//@target: ES6
+new Foo(...new SymbolIterator, ...new StringIterator);
+
+class Foo<T> {
+    constructor(...s: T[]) { }
+}
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+class StringIterator {
+    next() {
+        return {
+            value: "",
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/es6/spread/iteratorSpreadInCall9.ts

@@ -0,0 +1,32 @@
+//@target: ES6
+new Foo(...new SymbolIterator, ...[...new StringIterator]);
+
+class Foo<T> {
+    constructor(...s: T[]) { }
+}
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+class StringIterator {
+    next() {
+        return {
+            value: "",
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}

tests/cases/conformance/expressions/functions/arrowFunctionExpressions.ts

@@ -12,6 +12,17 @@ var d = n => c = n;
 var d = (n) => c = n;
 var d: (n: any) => any;
 
+// Binding patterns in arrow functions
+var p1 = ([a]) => { };
+var p2 = ([...a]) => { };
+var p3 = ([, a]) => { };
+var p4 = ([, ...a]) => { };
+var p5 = ([a = 1]) => { };
+var p6 = ({ a }) => { };
+var p7 = ({ a: { b } }) => { };
+var p8 = ({ a = 1 }) => { };
+var p9 = ({ a: { b = 1 } = { b: 1 } }) => { };
+var p10 = ([{ value, done }]) => { };
 
 // Arrow function used in class member initializer
 // Arrow function used in class member function

tests/cases/conformance/parser/ecmascript6/Symbols/parserSymbolProperty4.ts

@@ -1,4 +1,4 @@
 //@target: ES6
 declare class C {
-    [Symbol.isRegExp]: string;
+    [Symbol.toPrimitive]: string;
 }

tests/cases/conformance/parser/ecmascript6/Symbols/parserSymbolProperty5.ts

@@ -1,4 +1,4 @@
 //@target: ES6
 class C {
-    [Symbol.isRegExp]: string;
+    [Symbol.toPrimitive]: string;
 }

tests/cases/fourslash/completionAfterDotDotDot.ts

@@ -0,0 +1,6 @@
+/// <reference path='fourslash.ts'/>
+
+////.../**/
+
+goTo.marker();
+verify.not.completionListIsEmpty();