Merge branch 'master' into release-2.0

mhegazy · mhegazy · commit 78f259340a44 · 2016-08-18T16:17:18.000-07:00
diff --git a/lib/tsserver.js b/lib/tsserver.js
@@ -46785,6 +46785,7 @@ var ts;
                 if (objectLikeContainer.kind === 171) {
                     isNewIdentifierLocation = true;
                     typeForObject = typeChecker.getContextualType(objectLikeContainer);
+                    typeForObject = typeForObject && typeForObject.getNonNullableType();
                     existingMembers = objectLikeContainer.properties;
                 }
                 else if (objectLikeContainer.kind === 167) {
diff --git a/lib/tsserverlibrary.js b/lib/tsserverlibrary.js
@@ -46785,6 +46785,7 @@ var ts;
                 if (objectLikeContainer.kind === 171) {
                     isNewIdentifierLocation = true;
                     typeForObject = typeChecker.getContextualType(objectLikeContainer);
+                    typeForObject = typeForObject && typeForObject.getNonNullableType();
                     existingMembers = objectLikeContainer.properties;
                 }
                 else if (objectLikeContainer.kind === 167) {
diff --git a/lib/typescript.js b/lib/typescript.js
@@ -41058,6 +41058,21 @@ var ts;
                         emitSignatureParameters(ctor);
                     }
                     else {
+                        // The ES2015 spec specifies in 14.5.14. Runtime Semantics: ClassDefinitionEvaluation:
+                        // If constructor is empty, then
+                        //     If ClassHeritag_eopt is present and protoParent is not null, then
+                        //          Let constructor be the result of parsing the source text
+                        //              constructor(...args) { super (...args);}
+                        //          using the syntactic grammar with the goal symbol MethodDefinition[~Yield].
+                        //      Else,
+                        //           Let constructor be the result of parsing the source text
+                        //               constructor( ){ }
+                        //           using the syntactic grammar with the goal symbol MethodDefinition[~Yield].
+                        //
+                        // While we could emit the '...args' rest parameter, certain later tools in the pipeline might
+                        // downlevel the '...args' portion less efficiently by naively copying the contents of 'arguments' to an array.
+                        // Instead, we'll avoid using a rest parameter and spread into the super call as
+                        // 'super(...arguments)' instead of 'super(...args)', as you can see below.
                         write("()");
                     }
                 }
@@ -41092,6 +41107,7 @@ var ts;
                             write("_super.apply(this, arguments);");
                         }
                         else {
+                            // See comment above on using '...arguments' instead of '...args'.
                             write("super(...arguments);");
                         }
                         emitEnd(baseTypeElement);
@@ -55629,7 +55645,10 @@ var ts;
                     // We are completing on contextual types, but may also include properties
                     // other than those within the declared type.
                     isNewIdentifierLocation = true;
+                    // If the object literal is being assigned to something of type 'null | { hello: string }',
+                    // it clearly isn't trying to satisfy the 'null' type. So we grab the non-nullable type if possible.
                     typeForObject = typeChecker.getContextualType(objectLikeContainer);
+                    typeForObject = typeForObject && typeForObject.getNonNullableType();
                     existingMembers = objectLikeContainer.properties;
                 }
                 else if (objectLikeContainer.kind === 167 /* ObjectBindingPattern */) {
@@ -55640,7 +55659,7 @@ var ts;
                         // We don't want to complete using the type acquired by the shape
                         // of the binding pattern; we are only interested in types acquired
                         // through type declaration or inference.
-                        // Also proceed if rootDeclaration is parameter and if its containing function expression\arrow function is contextually typed -
+                        // Also proceed if rootDeclaration is a parameter and if its containing function expression/arrow function is contextually typed -
                         // type of parameter will flow in from the contextual type of the function
                         var canGetType = !!(rootDeclaration.initializer || rootDeclaration.type);
                         if (!canGetType && rootDeclaration.kind === 142 /* Parameter */) {
diff --git a/lib/typescriptServices.js b/lib/typescriptServices.js
@@ -41058,6 +41058,21 @@ var ts;
                         emitSignatureParameters(ctor);
                     }
                     else {
+                        // The ES2015 spec specifies in 14.5.14. Runtime Semantics: ClassDefinitionEvaluation:
+                        // If constructor is empty, then
+                        //     If ClassHeritag_eopt is present and protoParent is not null, then
+                        //          Let constructor be the result of parsing the source text
+                        //              constructor(...args) { super (...args);}
+                        //          using the syntactic grammar with the goal symbol MethodDefinition[~Yield].
+                        //      Else,
+                        //           Let constructor be the result of parsing the source text
+                        //               constructor( ){ }
+                        //           using the syntactic grammar with the goal symbol MethodDefinition[~Yield].
+                        //
+                        // While we could emit the '...args' rest parameter, certain later tools in the pipeline might
+                        // downlevel the '...args' portion less efficiently by naively copying the contents of 'arguments' to an array.
+                        // Instead, we'll avoid using a rest parameter and spread into the super call as
+                        // 'super(...arguments)' instead of 'super(...args)', as you can see below.
                         write("()");
                     }
                 }
@@ -41092,6 +41107,7 @@ var ts;
                             write("_super.apply(this, arguments);");
                         }
                         else {
+                            // See comment above on using '...arguments' instead of '...args'.
                             write("super(...arguments);");
                         }
                         emitEnd(baseTypeElement);
@@ -55629,7 +55645,10 @@ var ts;
                     // We are completing on contextual types, but may also include properties
                     // other than those within the declared type.
                     isNewIdentifierLocation = true;
+                    // If the object literal is being assigned to something of type 'null | { hello: string }',
+                    // it clearly isn't trying to satisfy the 'null' type. So we grab the non-nullable type if possible.
                     typeForObject = typeChecker.getContextualType(objectLikeContainer);
+                    typeForObject = typeForObject && typeForObject.getNonNullableType();
                     existingMembers = objectLikeContainer.properties;
                 }
                 else if (objectLikeContainer.kind === 167 /* ObjectBindingPattern */) {
@@ -55640,7 +55659,7 @@ var ts;
                         // We don't want to complete using the type acquired by the shape
                         // of the binding pattern; we are only interested in types acquired
                         // through type declaration or inference.
-                        // Also proceed if rootDeclaration is parameter and if its containing function expression\arrow function is contextually typed -
+                        // Also proceed if rootDeclaration is a parameter and if its containing function expression/arrow function is contextually typed -
                         // type of parameter will flow in from the contextual type of the function
                         var canGetType = !!(rootDeclaration.initializer || rootDeclaration.type);
                         if (!canGetType && rootDeclaration.kind === 142 /* Parameter */) {
diff --git a/scripts/ior.ts b/scripts/ior.ts
@@ -1,4 +1,4 @@
-/// <reference path="../src/harness/external/node.d.ts" />
+/// <reference types="node"/>
 
 import fs = require('fs');
 import path = require('path');
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
@@ -5311,6 +5311,21 @@ const _super = (function (geti, seti) {
                         emitSignatureParameters(ctor);
                     }
                     else {
+                        // The ES2015 spec specifies in 14.5.14. Runtime Semantics: ClassDefinitionEvaluation:
+                        // If constructor is empty, then
+                        //     If ClassHeritag_eopt is present and protoParent is not null, then
+                        //          Let constructor be the result of parsing the source text
+                        //              constructor(...args) { super (...args);}
+                        //          using the syntactic grammar with the goal symbol MethodDefinition[~Yield].
+                        //      Else,
+                        //           Let constructor be the result of parsing the source text
+                        //               constructor( ){ }
+                        //           using the syntactic grammar with the goal symbol MethodDefinition[~Yield].
+                        //
+                        // While we could emit the '...args' rest parameter, certain later tools in the pipeline might
+                        // downlevel the '...args' portion less efficiently by naively copying the contents of 'arguments' to an array.
+                        // Instead, we'll avoid using a rest parameter and spread into the super call as
+                        // 'super(...arguments)' instead of 'super(...args)', as you can see below.
                         write("()");
                     }
                 }
@@ -5349,6 +5364,7 @@ const _super = (function (geti, seti) {
                             write("_super.apply(this, arguments);");
                         }
                         else {
+                            // See comment above on using '...arguments' instead of '...args'.
                             write("super(...arguments);");
                         }
                         emitEnd(baseTypeElement);
diff --git a/src/compiler/program.ts b/src/compiler/program.ts
@@ -4,6 +4,7 @@
 
 namespace ts {
     /** The version of the TypeScript compiler release */
+
     export const version = "2.0.2";
 
     const emptyArray: any[] = [];
diff --git a/src/harness/rwcRunner.ts b/src/harness/rwcRunner.ts
@@ -198,7 +198,8 @@ namespace RWC {
                     }
                     // Do not include the library in the baselines to avoid noise
                     const baselineFiles = inputFiles.concat(otherFiles).filter(f => !Harness.isDefaultLibraryFile(f.unitName));
-                    return Harness.Compiler.getErrorBaseline(baselineFiles, compilerResult.errors);
+                    const errors = compilerResult.errors.filter(e => !Harness.isDefaultLibraryFile(e.file.fileName));
+                    return Harness.Compiler.getErrorBaseline(baselineFiles, errors);
                 }, false, baselineOpts);
             });
 
diff --git a/src/services/services.ts b/src/services/services.ts
@@ -3789,7 +3789,11 @@ namespace ts {
                     // other than those within the declared type.
                     isNewIdentifierLocation = true;
 
+                    // If the object literal is being assigned to something of type 'null | { hello: string }',
+                    // it clearly isn't trying to satisfy the 'null' type. So we grab the non-nullable type if possible.
                     typeForObject = typeChecker.getContextualType(<ObjectLiteralExpression>objectLikeContainer);
+                    typeForObject = typeForObject && typeForObject.getNonNullableType();
+
                     existingMembers = (<ObjectLiteralExpression>objectLikeContainer).properties;
                 }
                 else if (objectLikeContainer.kind === SyntaxKind.ObjectBindingPattern) {
@@ -3801,7 +3805,7 @@ namespace ts {
                         // We don't want to complete using the type acquired by the shape
                         // of the binding pattern; we are only interested in types acquired
                         // through type declaration or inference.
-                        // Also proceed if rootDeclaration is parameter and if its containing function expression\arrow function is contextually typed -
+                        // Also proceed if rootDeclaration is a parameter and if its containing function expression/arrow function is contextually typed -
                         // type of parameter will flow in from the contextual type of the function
                         let canGetType = !!(rootDeclaration.initializer || rootDeclaration.type);
                         if (!canGetType && rootDeclaration.kind === SyntaxKind.Parameter) {
diff --git a/tests/cases/fourslash/completionListInObjectLiteral4.ts b/tests/cases/fourslash/completionListInObjectLiteral4.ts
@@ -0,0 +1,28 @@
+/// <reference path='fourslash.ts'/>
+
+// @strictNullChecks: true
+////interface Thing {
+////    hello: number;
+////    world: string;
+////}
+////
+////declare function funcA(x : Thing): void;
+////declare function funcB(x?: Thing): void;
+////declare function funcC(x : Thing | null): void;
+////declare function funcD(x : Thing | undefined): void;
+////declare function funcE(x : Thing | null | undefined): void;
+////declare function funcF(x?: Thing | null | undefined): void;
+////
+////funcA({ /*A*/ });
+////funcB({ /*B*/ });
+////funcC({ /*C*/ });
+////funcD({ /*D*/ });
+////funcE({ /*E*/ });
+////funcF({ /*F*/ });
+
+
+for (const marker of test.markers()) {
+    goTo.position(marker.position);
+    verify.completionListContains("hello");
+    verify.completionListContains("world");
+}

Original file line number	Diff line number	Diff line change
`@@ -46785,6 +46785,7 @@ var ts;`
`46785`	`46785`	`if (objectLikeContainer.kind === 171) {`
`46786`	`46786`	`isNewIdentifierLocation = true;`
`46787`	`46787`	`typeForObject = typeChecker.getContextualType(objectLikeContainer);`
	`46788`	`+ typeForObject = typeForObject && typeForObject.getNonNullableType();`
`46788`	`46789`	`existingMembers = objectLikeContainer.properties;`
`46789`	`46790`	`}`
`46790`	`46791`	`else if (objectLikeContainer.kind === 167) {`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-/// <reference path="../src/harness/external/node.d.ts" />`
	`1`	`+/// <reference types="node"/>`
`2`	`2`
`3`	`3`	`import fs = require('fs');`
`4`	`4`	`import path = require('path');`
Original file line number	Diff line number	Diff line change
`@@ -5311,6 +5311,21 @@ const _super = (function (geti, seti) {`
`5311`	`5311`	`emitSignatureParameters(ctor);`
`5312`	`5312`	`}`
`5313`	`5313`	`else {`
	`5314`	`+ // The ES2015 spec specifies in 14.5.14. Runtime Semantics: ClassDefinitionEvaluation:`
	`5315`	`+ // If constructor is empty, then`
	`5316`	`+ // If ClassHeritag_eopt is present and protoParent is not null, then`
	`5317`	`+ // Let constructor be the result of parsing the source text`
	`5318`	`+ // constructor(...args) { super (...args);}`
	`5319`	`+ // using the syntactic grammar with the goal symbol MethodDefinition[~Yield].`
	`5320`	`+ // Else,`
	`5321`	`+ // Let constructor be the result of parsing the source text`
	`5322`	`+ // constructor( ){ }`
	`5323`	`+ // using the syntactic grammar with the goal symbol MethodDefinition[~Yield].`
	`5324`	`+ //`
	`5325`	`+ // While we could emit the '...args' rest parameter, certain later tools in the pipeline might`
	`5326`	`+ // downlevel the '...args' portion less efficiently by naively copying the contents of 'arguments' to an array.`
	`5327`	`+ // Instead, we'll avoid using a rest parameter and spread into the super call as`
	`5328`	`+ // 'super(...arguments)' instead of 'super(...args)', as you can see below.`
`5314`	`5329`	`write("()");`
`5315`	`5330`	`}`
`5316`	`5331`	`}`
`@@ -5349,6 +5364,7 @@ const _super = (function (geti, seti) {`
`5349`	`5364`	`write("_super.apply(this, arguments);");`
`5350`	`5365`	`}`
`5351`	`5366`	`else {`
	`5367`	`+ // See comment above on using '...arguments' instead of '...args'.`
`5352`	`5368`	`write("super(...arguments);");`
`5353`	`5369`	`}`
`5354`	`5370`	`emitEnd(baseTypeElement);`
Original file line number	Diff line number	Diff line change
`@@ -198,7 +198,8 @@ namespace RWC {`
`198`	`198`	`}`
`199`	`199`	`// Do not include the library in the baselines to avoid noise`
`200`	`200`	`const baselineFiles = inputFiles.concat(otherFiles).filter(f => !Harness.isDefaultLibraryFile(f.unitName));`
`201`		`- return Harness.Compiler.getErrorBaseline(baselineFiles, compilerResult.errors);`
	`201`	`+ const errors = compilerResult.errors.filter(e => !Harness.isDefaultLibraryFile(e.file.fileName));`
	`202`	`+ return Harness.Compiler.getErrorBaseline(baselineFiles, errors);`
`202`	`203`	`}, false, baselineOpts);`
`203`	`204`	`});`
`204`	`205`