microsoft
diff --git a/‎src/compiler/checker.ts
Copy file name to clipboard
+24-20Lines changed: 24 additions & 20 deletions b/‎src/compiler/checker.ts
Copy file name to clipboard
+24-20Lines changed: 24 additions & 20 deletions
diff --git a/‎src/compiler/declarationEmitter.ts
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion b/‎src/compiler/declarationEmitter.ts
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion
diff --git a/‎src/compiler/diagnosticMessages.json
Copy file name to clipboard
-4Lines changed: 0 additions & 4 deletions b/‎src/compiler/diagnosticMessages.json
Copy file name to clipboard
-4Lines changed: 0 additions & 4 deletions
diff --git a/‎src/compiler/types.ts
Copy file name to clipboard
+1Lines changed: 1 addition & 0 deletions b/‎src/compiler/types.ts
Copy file name to clipboard
+1Lines changed: 1 addition & 0 deletions
diff --git a/‎src/services/services.ts
Copy file name to clipboard
+6-2Lines changed: 6 additions & 2 deletions b/‎src/services/services.ts
Copy file name to clipboard
+6-2Lines changed: 6 additions & 2 deletions
diff --git a/‎tests/baselines/reference/classWithOptionalParameter.errors.txt
Copy file name to clipboard
-26Lines changed: 0 additions & 26 deletions b/‎tests/baselines/reference/classWithOptionalParameter.errors.txt
Copy file name to clipboard
-26Lines changed: 0 additions & 26 deletions
diff --git a/‎tests/baselines/reference/classWithOptionalParameter.symbols
Copy file name to clipboard
+26Lines changed: 26 additions & 0 deletions b/‎tests/baselines/reference/classWithOptionalParameter.symbols
Copy file name to clipboard
+26Lines changed: 26 additions & 0 deletions
diff --git a/‎tests/baselines/reference/classWithOptionalParameter.types
Copy file name to clipboard
+26Lines changed: 26 additions & 0 deletions b/‎tests/baselines/reference/classWithOptionalParameter.types
Copy file name to clipboard
+26Lines changed: 26 additions & 0 deletions
diff --git a/‎tests/baselines/reference/declFileConstructors.js
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions b/‎tests/baselines/reference/declFileConstructors.js
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions
diff --git a/‎tests/baselines/reference/objectLiteralMemberWithQuestionMark1.errors.txt
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions b/‎tests/baselines/reference/objectLiteralMemberWithQuestionMark1.errors.txt
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions
@@ -79,6 +79,7 @@ namespace ts {
             getIndexTypeOfType,
             getBaseTypes,
             getReturnTypeOfSignature,
+            getNonNullableType,
             getSymbolsInScope,
             getSymbolAtLocation,
             getShorthandAssignmentValueSymbol,
@@ -2884,6 +2885,10 @@ namespace ts {
             return undefined;
         }
 
+        function addOptionality(type: Type, optional: boolean): Type {
+            return strictNullChecks && optional ? addNullableKind(type, TypeFlags.Undefined) : type;
+        }
+
         // Return the inferred type for a variable, parameter, or property declaration
         function getTypeForVariableLikeDeclaration(declaration: VariableLikeDeclaration): Type {
             if (declaration.flags & NodeFlags.JavaScriptFile) {
@@ -2915,8 +2920,7 @@ namespace ts {
 
             // Use type from type annotation if one is present
             if (declaration.type) {
-                const type = getTypeFromTypeNode(declaration.type);
-                return strictNullChecks && declaration.questionToken ? addNullableKind(type, TypeFlags.Undefined) : type;
+                return addOptionality(getTypeFromTypeNode(declaration.type), /*optional*/ !!declaration.questionToken);
             }
 
             if (declaration.kind === SyntaxKind.Parameter) {
@@ -2938,13 +2942,13 @@ namespace ts {
                     ? getContextuallyTypedThisType(func)
                     : getContextuallyTypedParameterType(<ParameterDeclaration>declaration);
                 if (type) {
-                    return strictNullChecks && declaration.questionToken ? addNullableKind(type, TypeFlags.Undefined) : type;
+                    return addOptionality(type, /*optional*/ !!declaration.questionToken);
                 }
             }
 
             // Use the type of the initializer expression if one is present
             if (declaration.initializer) {
-                return checkExpressionCached(declaration.initializer);
+                return addOptionality(checkExpressionCached(declaration.initializer), /*optional*/ !!declaration.questionToken);
             }
 
             // If it is a short-hand property assignment, use the type of the identifier
@@ -3215,7 +3219,9 @@ namespace ts {
         function getTypeOfFuncClassEnumModule(symbol: Symbol): Type {
             const links = getSymbolLinks(symbol);
             if (!links.type) {
-                links.type = createObjectType(TypeFlags.Anonymous, symbol);
+                const type = createObjectType(TypeFlags.Anonymous, symbol);
+                links.type = strictNullChecks && symbol.flags & SymbolFlags.Optional ?
+                    addNullableKind(type, TypeFlags.Undefined) : type;
             }
             return links.type;
         }
@@ -7614,11 +7620,12 @@ namespace ts {
                 getInitialTypeOfBindingElement(<BindingElement>node);
         }
 
-        function getFlowTypeOfReference(reference: Node, declaredType: Type, initialType: Type) {
+        function getFlowTypeOfReference(reference: Node, declaredType: Type, assumeInitialized: boolean) {
             let key: string;
-            if (!reference.flowNode || declaredType === initialType && !(declaredType.flags & TypeFlags.Narrowable)) {
+            if (!reference.flowNode || assumeInitialized && !(declaredType.flags & TypeFlags.Narrowable)) {
                 return declaredType;
             }
+            const initialType = assumeInitialized ? declaredType : addNullableKind(declaredType, TypeFlags.Undefined);
             const visitedFlowStart = visitedFlowCount;
             const result = getTypeAtFlowNode(reference.flowNode);
             visitedFlowCount = visitedFlowStart;
@@ -8092,11 +8099,11 @@ namespace ts {
                 return type;
             }
             const declaration = localOrExportSymbol.valueDeclaration;
-            const defaultsToDeclaredType = !strictNullChecks || type.flags & TypeFlags.Any || !declaration ||
+            const assumeInitialized = !strictNullChecks || (type.flags & TypeFlags.Any) !== 0 || !declaration ||
                 getRootDeclaration(declaration).kind === SyntaxKind.Parameter || isInAmbientContext(declaration) ||
                 getContainingFunctionOrModule(declaration) !== getContainingFunctionOrModule(node);
-            const flowType = getFlowTypeOfReference(node, type, defaultsToDeclaredType ? type : addNullableKind(type, TypeFlags.Undefined));
-            if (strictNullChecks && !(type.flags & TypeFlags.Any) && !(getNullableKind(type) & TypeFlags.Undefined) && getNullableKind(flowType) & TypeFlags.Undefined) {
+            const flowType = getFlowTypeOfReference(node, type, assumeInitialized);
+            if (!assumeInitialized && !(getNullableKind(type) & TypeFlags.Undefined) && getNullableKind(flowType) & TypeFlags.Undefined) {
                 error(node, Diagnostics.Variable_0_is_used_before_being_assigned, symbolToString(symbol));
                 // Return the declared type to reduce follow-on errors
                 return type;
@@ -8344,7 +8351,7 @@ namespace ts {
             if (isClassLike(container.parent)) {
                 const symbol = getSymbolOfNode(container.parent);
                 const type = container.flags & NodeFlags.Static ? getTypeOfSymbol(symbol) : (<InterfaceType>getDeclaredTypeOfSymbol(symbol)).thisType;
-                return getFlowTypeOfReference(node, type, type);
+                return getFlowTypeOfReference(node, type, /*assumeInitialized*/ true);
             }
 
             if (isInJavaScriptFile(node)) {
@@ -9919,7 +9926,8 @@ namespace ts {
             }
 
             const propType = getTypeOfSymbol(prop);
-            if (node.kind !== SyntaxKind.PropertyAccessExpression || !(prop.flags & (SymbolFlags.Variable | SymbolFlags.Property | SymbolFlags.Accessor)) || isAssignmentTarget(node)) {
+            if (node.kind !== SyntaxKind.PropertyAccessExpression || isAssignmentTarget(node) ||
+                !(propType.flags & TypeFlags.Union) && !(prop.flags & (SymbolFlags.Variable | SymbolFlags.Property | SymbolFlags.Accessor))) {
                 return propType;
             }
             const leftmostNode = getLeftmostIdentifierOrThis(node);
@@ -9936,7 +9944,7 @@ namespace ts {
                     return propType;
                 }
             }
-            return getFlowTypeOfReference(node, propType, propType);
+            return getFlowTypeOfReference(node, propType, /*assumeInitialized*/ true);
         }
 
         function isValidPropertyAccess(node: PropertyAccessExpression | QualifiedName, propertyName: string): boolean {
@@ -13400,7 +13408,7 @@ namespace ts {
 
             // Abstract methods can't have an implementation -- in particular, they don't need one.
             if (!isExportSymbolInsideModule && lastSeenNonAmbientDeclaration && !lastSeenNonAmbientDeclaration.body &&
-                !(lastSeenNonAmbientDeclaration.flags & NodeFlags.Abstract)) {
+                !(lastSeenNonAmbientDeclaration.flags & NodeFlags.Abstract) && !lastSeenNonAmbientDeclaration.questionToken) {
                 reportImplementationExpectedError(lastSeenNonAmbientDeclaration);
             }
 
@@ -18290,7 +18298,7 @@ namespace ts {
             }
 
             if (node.parent.kind === SyntaxKind.ObjectLiteralExpression) {
-                if (checkGrammarForInvalidQuestionMark(node, node.questionToken, Diagnostics.A_class_member_cannot_be_declared_optional)) {
+                if (checkGrammarForInvalidQuestionMark(node, node.questionToken, Diagnostics.An_object_member_cannot_be_declared_optional)) {
                     return true;
                 }
                 else if (node.body === undefined) {
@@ -18299,9 +18307,6 @@ namespace ts {
             }
 
             if (isClassLike(node.parent)) {
-                if (checkGrammarForInvalidQuestionMark(node, node.questionToken, Diagnostics.A_class_member_cannot_be_declared_optional)) {
-                    return true;
-                }
                 // Technically, computed properties in ambient contexts is disallowed
                 // for property declarations and accessors too, not just methods.
                 // However, property declarations disallow computed names in general,
@@ -18523,8 +18528,7 @@ namespace ts {
 
         function checkGrammarProperty(node: PropertyDeclaration) {
             if (isClassLike(node.parent)) {
-                if (checkGrammarForInvalidQuestionMark(node, node.questionToken, Diagnostics.A_class_member_cannot_be_declared_optional) ||
-                    checkGrammarForNonSymbolComputedProperty(node.name, Diagnostics.A_computed_property_name_in_a_class_property_declaration_must_directly_refer_to_a_built_in_symbol)) {
+                if (checkGrammarForNonSymbolComputedProperty(node.name, Diagnostics.A_computed_property_name_in_a_class_property_declaration_must_directly_refer_to_a_built_in_symbol)) {
                     return true;
                 }
             }
 
@@ -1129,7 +1129,7 @@ namespace ts {
                     // what we want, namely the name expression enclosed in brackets.
                     writeTextOfNode(currentText, node.name);
                     // If optional property emit ?
-                    if ((node.kind === SyntaxKind.PropertyDeclaration || node.kind === SyntaxKind.PropertySignature) && hasQuestionToken(node)) {
+                    if ((node.kind === SyntaxKind.PropertyDeclaration || node.kind === SyntaxKind.PropertySignature || node.kind === SyntaxKind.Parameter) && hasQuestionToken(node)) {
                         write("?");
                     }
                     if ((node.kind === SyntaxKind.PropertyDeclaration || node.kind === SyntaxKind.PropertySignature) && node.parent.kind === SyntaxKind.TypeLiteral) {
 
@@ -315,10 +315,6 @@
         "category": "Error",
         "code": 1110
     },
-    "A class member cannot be declared optional.": {
-        "category": "Error",
-        "code": 1112
-    },
     "A 'default' clause cannot appear more than once in a 'switch' statement.": {
         "category": "Error",
         "code": 1113
 
@@ -1772,6 +1772,7 @@ namespace ts {
         getIndexTypeOfType(type: Type, kind: IndexKind): Type;
         getBaseTypes(type: InterfaceType): ObjectType[];
         getReturnTypeOfSignature(signature: Signature): Type;
+        getNonNullableType(type: Type): Type;
 
         getSymbolsInScope(location: Node, meaning: SymbolFlags): Symbol[];
         getSymbolAtLocation(node: Node): Symbol;
 
@@ -50,6 +50,7 @@ namespace ts {
         getStringIndexType(): Type;
         getNumberIndexType(): Type;
         getBaseTypes(): ObjectType[];
+        getNonNullableType(): Type;
     }
 
     export interface Signature {
@@ -735,6 +736,9 @@ namespace ts {
                 ? this.checker.getBaseTypes(<InterfaceType><Type>this)
                 : undefined;
         }
+        getNonNullableType(): Type {
+            return this.checker.getNonNullableType(this);
+        }
     }
 
     class SignatureObject implements Signature {
@@ -4366,7 +4370,7 @@ namespace ts {
                         (location.kind === SyntaxKind.ConstructorKeyword && location.parent.kind === SyntaxKind.Constructor)) { // At constructor keyword of constructor declaration
                         // get the signature from the declaration and write it
                         const functionDeclaration = <FunctionLikeDeclaration>location.parent;
-                        const allSignatures = functionDeclaration.kind === SyntaxKind.Constructor ? type.getConstructSignatures() : type.getCallSignatures();
+                        const allSignatures = functionDeclaration.kind === SyntaxKind.Constructor ? type.getNonNullableType().getConstructSignatures() : type.getNonNullableType().getCallSignatures();
                         if (!typeChecker.isImplementationOfOverload(functionDeclaration)) {
                             signature = typeChecker.getSignatureFromDeclaration(functionDeclaration);
                         }
@@ -4564,7 +4568,7 @@ namespace ts {
                             symbolFlags & SymbolFlags.Signature ||
                             symbolFlags & SymbolFlags.Accessor ||
                             symbolKind === ScriptElementKind.memberFunctionElement) {
-                            const allSignatures = type.getCallSignatures();
+                            const allSignatures = type.getNonNullableType().getCallSignatures();
                             addSignatureDisplayParts(allSignatures[0], allSignatures);
                         }
                     }
 
@@ -0,0 +1,26 @@
+=== tests/cases/conformance/types/namedTypes/classWithOptionalParameter.ts ===
+// classes do not permit optional parameters, these are errors
+
+class C {
+>C : Symbol(C, Decl(classWithOptionalParameter.ts, 0, 0))
+
+    x?: string;
+>x : Symbol(C.x, Decl(classWithOptionalParameter.ts, 2, 9))
+
+    f?() {}
+>f : Symbol(C.f, Decl(classWithOptionalParameter.ts, 3, 15))
+}
+
+class C2<T> {
+>C2 : Symbol(C2, Decl(classWithOptionalParameter.ts, 5, 1))
+>T : Symbol(T, Decl(classWithOptionalParameter.ts, 7, 9))
+
+    x?: T;
+>x : Symbol(C2.x, Decl(classWithOptionalParameter.ts, 7, 13))
+>T : Symbol(T, Decl(classWithOptionalParameter.ts, 7, 9))
+
+    f?(x: T) {}
+>f : Symbol(C2.f, Decl(classWithOptionalParameter.ts, 8, 10))
+>x : Symbol(x, Decl(classWithOptionalParameter.ts, 9, 7))
+>T : Symbol(T, Decl(classWithOptionalParameter.ts, 7, 9))
+}
@@ -0,0 +1,26 @@
+=== tests/cases/conformance/types/namedTypes/classWithOptionalParameter.ts ===
+// classes do not permit optional parameters, these are errors
+
+class C {
+>C : C
+
+    x?: string;
+>x : string
+
+    f?() {}
+>f : () => void
+}
+
+class C2<T> {
+>C2 : C2<T>
+>T : T
+
+    x?: T;
+>x : T
+>T : T
+
+    f?(x: T) {}
+>f : (x: T) => void
+>x : T
+>T : T
+}
@@ -247,7 +247,7 @@ export declare class ConstructorWithPrivateParameterProperty {
     constructor(x: string);
 }
 export declare class ConstructorWithOptionalParameterProperty {
-    x: string;
+    x?: string;
     constructor(x?: string);
 }
 export declare class ConstructorWithParameterInitializer {
@@ -281,7 +281,7 @@ declare class GlobalConstructorWithPrivateParameterProperty {
     constructor(x: string);
 }
 declare class GlobalConstructorWithOptionalParameterProperty {
-    x: string;
+    x?: string;
     constructor(x?: string);
 }
 declare class GlobalConstructorWithParameterInitializer {
 
@@ -1,7 +1,7 @@
-tests/cases/compiler/objectLiteralMemberWithQuestionMark1.ts(1,14): error TS1112: A class member cannot be declared optional.
+tests/cases/compiler/objectLiteralMemberWithQuestionMark1.ts(1,14): error TS1162: An object member cannot be declared optional.
 
 
 ==== tests/cases/compiler/objectLiteralMemberWithQuestionMark1.ts (1 errors) ====
     var v = { foo?() { } }
                  ~
-!!! error TS1112: A class member cannot be declared optional.
+!!! error TS1162: An object member cannot be declared optional.
Original file line number	Diff line number	Diff line change
`@@ -1129,7 +1129,7 @@ namespace ts {`
`1129`	`1129`	`// what we want, namely the name expression enclosed in brackets.`
`1130`	`1130`	`writeTextOfNode(currentText, node.name);`
`1131`	`1131`	`// If optional property emit ?`
`1132`		`- if ((node.kind === SyntaxKind.PropertyDeclaration \|\| node.kind === SyntaxKind.PropertySignature) && hasQuestionToken(node)) {`
	`1132`	`+ if ((node.kind === SyntaxKind.PropertyDeclaration \|\| node.kind === SyntaxKind.PropertySignature \|\| node.kind === SyntaxKind.Parameter) && hasQuestionToken(node)) {`
`1133`	`1133`	`write("?");`
`1134`	`1134`	`}`
`1135`	`1135`	`if ((node.kind === SyntaxKind.PropertyDeclaration \|\| node.kind === SyntaxKind.PropertySignature) && node.parent.kind === SyntaxKind.TypeLiteral) {`
Original file line number	Diff line number	Diff line change
`@@ -50,6 +50,7 @@ namespace ts {`
`50`	`50`	`getStringIndexType(): Type;`
`51`	`51`	`getNumberIndexType(): Type;`
`52`	`52`	`getBaseTypes(): ObjectType[];`
	`53`	`+ getNonNullableType(): Type;`
`53`	`54`	`}`
`54`	`55`
`55`	`56`	`export interface Signature {`
`@@ -735,6 +736,9 @@ namespace ts {`
`735`	`736`	`? this.checker.getBaseTypes(<InterfaceType><Type>this)`
`736`	`737`	`: undefined;`
`737`	`738`	`}`
	`739`	`+ getNonNullableType(): Type {`
	`740`	`+ return this.checker.getNonNullableType(this);`
	`741`	`+ }`
`738`	`742`	`}`
`739`	`743`
`740`	`744`	`class SignatureObject implements Signature {`
`@@ -4366,7 +4370,7 @@ namespace ts {`
`4366`	`4370`	`(location.kind === SyntaxKind.ConstructorKeyword && location.parent.kind === SyntaxKind.Constructor)) { // At constructor keyword of constructor declaration`
`4367`	`4371`	`// get the signature from the declaration and write it`
`4368`	`4372`	`const functionDeclaration = <FunctionLikeDeclaration>location.parent;`
`4369`		`- const allSignatures = functionDeclaration.kind === SyntaxKind.Constructor ? type.getConstructSignatures() : type.getCallSignatures();`
	`4373`	`+ const allSignatures = functionDeclaration.kind === SyntaxKind.Constructor ? type.getNonNullableType().getConstructSignatures() : type.getNonNullableType().getCallSignatures();`
`4370`	`4374`	`if (!typeChecker.isImplementationOfOverload(functionDeclaration)) {`
`4371`	`4375`	`signature = typeChecker.getSignatureFromDeclaration(functionDeclaration);`
`4372`	`4376`	`}`
`@@ -4564,7 +4568,7 @@ namespace ts {`
`4564`	`4568`	`symbolFlags & SymbolFlags.Signature \|\|`
`4565`	`4569`	`symbolFlags & SymbolFlags.Accessor \|\|`
`4566`	`4570`	`symbolKind === ScriptElementKind.memberFunctionElement) {`
`4567`		`- const allSignatures = type.getCallSignatures();`
	`4571`	`+ const allSignatures = type.getNonNullableType().getCallSignatures();`
`4568`	`4572`	`addSignatureDisplayParts(allSignatures[0], allSignatures);`
`4569`	`4573`	`}`
`4570`	`4574`	`}`
Original file line number	Diff line number	Diff line change
`@@ -247,7 +247,7 @@ export declare class ConstructorWithPrivateParameterProperty {`
`247`	`247`	`constructor(x: string);`
`248`	`248`	`}`
`249`	`249`	`export declare class ConstructorWithOptionalParameterProperty {`
`250`		`- x: string;`
	`250`	`+ x?: string;`
`251`	`251`	`constructor(x?: string);`
`252`	`252`	`}`
`253`	`253`	`export declare class ConstructorWithParameterInitializer {`
`@@ -281,7 +281,7 @@ declare class GlobalConstructorWithPrivateParameterProperty {`
`281`	`281`	`constructor(x: string);`
`282`	`282`	`}`
`283`	`283`	`declare class GlobalConstructorWithOptionalParameterProperty {`
`284`		`- x: string;`
	`284`	`+ x?: string;`
`285`	`285`	`constructor(x?: string);`
`286`	`286`	`}`
`287`	`287`	`declare class GlobalConstructorWithParameterInitializer {`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`		`-tests/cases/compiler/objectLiteralMemberWithQuestionMark1.ts(1,14): error TS1112: A class member cannot be declared optional.`
	`1`	`+tests/cases/compiler/objectLiteralMemberWithQuestionMark1.ts(1,14): error TS1162: An object member cannot be declared optional.`
`2`	`2`
`3`	`3`
`4`	`4`	`==== tests/cases/compiler/objectLiteralMemberWithQuestionMark1.ts (1 errors) ====`
`5`	`5`	`var v = { foo?() { } }`
`6`	`6`	`~`
`7`		`-!!! error TS1112: A class member cannot be declared optional.`
	`7`	`+!!! error TS1162: An object member cannot be declared optional.`