Allow class properties and methods to be declared optional using '?'

ahejlsberg · ahejlsberg · commit b90761cf43ce · 2016-05-14T13:34:00.000-07:00
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -3216,7 +3216,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;
         }
@@ -9921,7 +9923,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);
@@ -13396,7 +13399,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 +18293,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 +18302,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 +18523,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;
                 }
             }
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
@@ -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

Original file line number	Diff line number	Diff line change
`@@ -3216,7 +3216,9 @@ namespace ts {`
`3216`	`3216`	`function getTypeOfFuncClassEnumModule(symbol: Symbol): Type {`
`3217`	`3217`	`const links = getSymbolLinks(symbol);`
`3218`	`3218`	`if (!links.type) {`
`3219`		`- links.type = createObjectType(TypeFlags.Anonymous, symbol);`
	`3219`	`+ const type = createObjectType(TypeFlags.Anonymous, symbol);`
	`3220`	`+ links.type = strictNullChecks && symbol.flags & SymbolFlags.Optional ?`
	`3221`	`+ addNullableKind(type, TypeFlags.Undefined) : type;`
`3220`	`3222`	`}`
`3221`	`3223`	`return links.type;`
`3222`	`3224`	`}`
`@@ -9921,7 +9923,8 @@ namespace ts {`
`9921`	`9923`	`}`
`9922`	`9924`
`9923`	`9925`	`const propType = getTypeOfSymbol(prop);`
`9924`		`- if (node.kind !== SyntaxKind.PropertyAccessExpression \|\| !(prop.flags & (SymbolFlags.Variable \| SymbolFlags.Property \| SymbolFlags.Accessor)) \|\| isAssignmentTarget(node)) {`
	`9926`	`+ if (node.kind !== SyntaxKind.PropertyAccessExpression \|\| isAssignmentTarget(node) \|\|`
	`9927`	`+ !(propType.flags & TypeFlags.Union) && !(prop.flags & (SymbolFlags.Variable \| SymbolFlags.Property \| SymbolFlags.Accessor))) {`
`9925`	`9928`	`return propType;`
`9926`	`9929`	`}`
`9927`	`9930`	`const leftmostNode = getLeftmostIdentifierOrThis(node);`
`@@ -13396,7 +13399,7 @@ namespace ts {`
`13396`	`13399`
`13397`	`13400`	`// Abstract methods can't have an implementation -- in particular, they don't need one.`
`13398`	`13401`	`if (!isExportSymbolInsideModule && lastSeenNonAmbientDeclaration && !lastSeenNonAmbientDeclaration.body &&`
`13399`		`- !(lastSeenNonAmbientDeclaration.flags & NodeFlags.Abstract)) {`
	`13402`	`+ !(lastSeenNonAmbientDeclaration.flags & NodeFlags.Abstract) && !lastSeenNonAmbientDeclaration.questionToken) {`
`13400`	`13403`	`reportImplementationExpectedError(lastSeenNonAmbientDeclaration);`
`13401`	`13404`	`}`
`13402`	`13405`
`@@ -18290,7 +18293,7 @@ namespace ts {`
`18290`	`18293`	`}`
`18291`	`18294`
`18292`	`18295`	`if (node.parent.kind === SyntaxKind.ObjectLiteralExpression) {`
`18293`		`- if (checkGrammarForInvalidQuestionMark(node, node.questionToken, Diagnostics.A_class_member_cannot_be_declared_optional)) {`
	`18296`	`+ if (checkGrammarForInvalidQuestionMark(node, node.questionToken, Diagnostics.An_object_member_cannot_be_declared_optional)) {`
`18294`	`18297`	`return true;`
`18295`	`18298`	`}`
`18296`	`18299`	`else if (node.body === undefined) {`
`@@ -18299,9 +18302,6 @@ namespace ts {`
`18299`	`18302`	`}`
`18300`	`18303`
`18301`	`18304`	`if (isClassLike(node.parent)) {`
`18302`		`- if (checkGrammarForInvalidQuestionMark(node, node.questionToken, Diagnostics.A_class_member_cannot_be_declared_optional)) {`
`18303`		`- return true;`
`18304`		`- }`
`18305`	`18305`	`// Technically, computed properties in ambient contexts is disallowed`
`18306`	`18306`	`// for property declarations and accessors too, not just methods.`
`18307`	`18307`	`// However, property declarations disallow computed names in general,`
`@@ -18523,8 +18523,7 @@ namespace ts {`
`18523`	`18523`
`18524`	`18524`	`function checkGrammarProperty(node: PropertyDeclaration) {`
`18525`	`18525`	`if (isClassLike(node.parent)) {`
`18526`		`- if (checkGrammarForInvalidQuestionMark(node, node.questionToken, Diagnostics.A_class_member_cannot_be_declared_optional) \|\|`
`18527`		`- checkGrammarForNonSymbolComputedProperty(node.name, Diagnostics.A_computed_property_name_in_a_class_property_declaration_must_directly_refer_to_a_built_in_symbol)) {`
	`18526`	`+ if (checkGrammarForNonSymbolComputedProperty(node.name, Diagnostics.A_computed_property_name_in_a_class_property_declaration_must_directly_refer_to_a_built_in_symbol)) {`
`18528`	`18527`	`return true;`
`18529`	`18528`	`}`
`18530`	`18529`	`}`