Contextually type implemented properties #6118
There are no files selected for viewing
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
|
|
@@ -2595,7 +2595,14 @@ namespace ts { | |
|
|
||
| // Use the type of the initializer expression if one is present | ||
| if (declaration.initializer) { | ||
| let mapper: TypeMapper; | ||
| if (declaration.kind === SyntaxKind.PropertyDeclaration) { | ||
| const type = getTypeOfBasePropertyDeclaration(<PropertyDeclaration>declaration); | ||
| if (type) { | ||
| mapper = createTypeMapper([undefinedType, nullType], [type, type]); | ||
| } | ||
| } | ||
| return checkExpressionCached(declaration.initializer, mapper); | ||
|
There was a problem hiding this comment. The |
||
| } | ||
|
|
||
| // If it is a short-hand property assignment, use the type of the identifier | ||
|
|
@@ -2895,6 +2902,40 @@ namespace ts { | |
| return unknownType; | ||
| } | ||
|
|
||
| function getTypeOfBasePropertyDeclaration(declaration: PropertyDeclaration) { | ||
| if (declaration.parent.kind === SyntaxKind.ClassDeclaration) { | ||
| const property = getPropertyOfBaseTypeDeclaration(<ClassLikeDeclaration>declaration.parent, declaration.symbol.name); | ||
| if (property) { | ||
| return getTypeOfSymbol(property); | ||
| } | ||
| } | ||
|
There was a problem hiding this comment. Can you use an explicit return? |
||
| } | ||
|
|
||
| function getPropertyOfBaseTypeDeclaration(declaration: ClassLikeDeclaration, propertyName: string): Symbol { | ||
| const property = getFirstPropertyOfTypes(getBaseTypes(<InterfaceType>getTypeOfSymbol(getSymbolOfNode(declaration))), propertyName); | ||
| if (property) { | ||
| return property; | ||
| } | ||
| const implementedTypeNodes = getClassImplementsHeritageClauseElements(declaration); | ||
| if (implementedTypeNodes) { | ||
| return getFirstPropertyOfTypes(map(implementedTypeNodes, getTypeFromTypeReference), propertyName); | ||
| } | ||
|
There was a problem hiding this comment. Same here and below; explicit return |
||
| } | ||
|
|
||
| function getFirstPropertyOfTypes(types: Type[], propertyName: string) { | ||
| for (const t of types) { | ||
| if (t !== unknownType) { | ||
| const property = getPropertyOfType(t, propertyName); | ||
| if (!property || property.valueDeclaration.flags & NodeFlags.Private) { | ||
| continue; | ||
| } | ||
| if (property.name === propertyName) { | ||
| return property; | ||
| } | ||
| } | ||
| } | ||
| } | ||
|
|
||
| function getTargetType(type: ObjectType): Type { | ||
| return type.flags & TypeFlags.Reference ? (<TypeReference>type).target : type; | ||
| } | ||
|
|
@@ -4933,7 +4974,7 @@ namespace ts { | |
| // Returns true if the given expression contains (at any level of nesting) a function or arrow expression | ||
| // that is subject to contextual typing. | ||
| function isContextSensitive(node: Expression | MethodDeclaration | ObjectLiteralElement): boolean { | ||
| Debug.assert(node.kind !== SyntaxKind.MethodDeclaration || isMethod(node)); | ||
| switch (node.kind) { | ||
| case SyntaxKind.FunctionExpression: | ||
| case SyntaxKind.ArrowFunction: | ||
|
|
@@ -6894,7 +6935,7 @@ namespace ts { | |
| return expression; | ||
| } | ||
|
|
||
| function checkIdentifier(node: Identifier, contextualMapper?: TypeMapper): Type { | ||
| const symbol = getResolvedSymbol(node); | ||
|
|
||
| // As noted in ECMAScript 6 language spec, arrow functions never have an arguments objects. | ||
|
|
@@ -6925,7 +6966,11 @@ namespace ts { | |
| checkCollisionWithCapturedThisVariable(node, node); | ||
| checkBlockScopedBindingCapturedInLoop(node, symbol); | ||
|
|
||
| const type = getNarrowedTypeOfSymbol(getExportSymbolOfValueSymbolIfExported(symbol), node); | ||
| if (type === undefinedType || type == nullType) { | ||
|
There was a problem hiding this comment. This checks for the undefined type instead of the symbol with the name "undefined". I think this is wrong, so I changed it to |
||
| return (contextualMapper || identityMapper)(type); | ||
|
There was a problem hiding this comment. The There was a problem hiding this comment. @ahejlsberg can correct me, but I think the contextualMapper is just for inferential typing. |
||
| } | ||
| return type; | ||
| } | ||
|
|
||
| function isInsideFunction(node: Node, threshold: Node): boolean { | ||
|
|
@@ -7170,10 +7215,14 @@ namespace ts { | |
| } | ||
| } | ||
|
|
||
| function checkNullKeyword(nullNode: Node, contextualMapper: TypeMapper) { | ||
| return (contextualMapper || identityMapper)(nullType); | ||
| } | ||
|
|
||
| // Return contextual type of parameter or undefined if no contextual type is available | ||
| function getContextuallyTypedParameterType(parameter: ParameterDeclaration): Type { | ||
| const func = parameter.parent; | ||
| if (isFunctionExpressionOrArrowFunction(func) || isMethod(func)) { | ||
| if (isContextSensitive(func)) { | ||
| const contextualSignature = getContextualSignature(func); | ||
| if (contextualSignature) { | ||
|
|
@@ -7214,6 +7263,12 @@ namespace ts { | |
| return type; | ||
| } | ||
| } | ||
| if (declaration.kind === SyntaxKind.PropertyDeclaration) { | ||
| const type = getTypeOfBasePropertyDeclaration(<PropertyDeclaration>declaration); | ||
| if (type) { | ||
| return type; | ||
| } | ||
| } | ||
| if (isBindingPattern(declaration.name)) { | ||
| return getTypeFromBindingPattern(<BindingPattern>declaration.name, /*includePatternInType*/ true); | ||
| } | ||
|
|
@@ -7544,10 +7599,18 @@ namespace ts { | |
| // all identical ignoring their return type, the result is same signature but with return type as | ||
| // union type of return types from these signatures | ||
| function getContextualSignature(node: FunctionExpression | MethodDeclaration): Signature { | ||
| Debug.assert(node.kind !== SyntaxKind.MethodDeclaration || isMethod(node)); | ||
| let type: Type; | ||
| if (isFunctionExpressionOrArrowFunction(node)) { | ||
| type = getApparentTypeOfContextualType(node); | ||
| } | ||
| else if (isObjectLiteralMethod(node)) { | ||
| type = getContextualTypeForObjectLiteralMethod(node); | ||
| } | ||
| else if (isMethod(node)) { | ||
| type = getTypeOfBasePropertyDeclaration(node); | ||
| } | ||
|
|
||
| if (!type) { | ||
| return undefined; | ||
| } | ||
|
|
@@ -7640,7 +7703,7 @@ namespace ts { | |
| function checkArrayLiteral(node: ArrayLiteralExpression, contextualMapper?: TypeMapper): Type { | ||
| const elements = node.elements; | ||
| let hasSpreadElement = false; | ||
| let elementTypes: Type[] = []; | ||
| const inDestructuringPattern = isAssignmentTarget(node); | ||
| for (const e of elements) { | ||
| if (inDestructuringPattern && e.kind === SyntaxKind.SpreadElementExpression) { | ||
|
|
@@ -7702,7 +7765,15 @@ namespace ts { | |
| } | ||
| } | ||
| } | ||
| if (!elementTypes.length) { | ||
| const mapper = contextualMapper || identityMapper; | ||
| const mappedType = mapper(undefinedType); | ||
| if (mappedType === undefinedType) { | ||
| return createArrayType(undefinedType); | ||
| } | ||
| elementTypes = (<TypeReference>mappedType).typeArguments; | ||
| } | ||
| return createArrayType(getUnionType(elementTypes)); | ||
| } | ||
|
|
||
| function isNumericName(name: DeclarationName): boolean { | ||
|
|
@@ -7762,7 +7833,7 @@ namespace ts { | |
| return links.resolvedType; | ||
| } | ||
|
|
||
| function checkObjectLiteral(node: ObjectLiteralExpression, contextualMapper: TypeMapper): Type { | ||
| const inDestructuringPattern = isAssignmentTarget(node); | ||
| // Grammar checking | ||
| checkGrammarObjectLiteralExpression(node, inDestructuringPattern); | ||
|
|
@@ -7885,7 +7956,21 @@ namespace ts { | |
| } | ||
| } | ||
| } | ||
| let result: Type; | ||
| if (!propTypes.length) { | ||
| const mapper = contextualMapper || identityMapper; | ||
| const mappedType = mapper(undefinedType); | ||
| if (mappedType === undefinedType) { | ||
| result = undefinedType; | ||
| } | ||
| else { | ||
| const resolvedType = <ResolvedType>mappedType; | ||
| result = kind === IndexKind.String ? resolvedType.stringIndexType : resolvedType.numberIndexType; | ||
| } | ||
| } | ||
| else { | ||
| result = getUnionType(propTypes); | ||
| } | ||
| typeFlags |= result.flags; | ||
| return result; | ||
| } | ||
|
|
@@ -10862,7 +10947,7 @@ namespace ts { | |
| return checkExpression((<PropertyAssignment>node).initializer, contextualMapper); | ||
| } | ||
|
|
||
| function checkObjectLiteralMethod(node: MethodDeclaration, contextualMapper: TypeMapper): Type { | ||
| // Grammar checking | ||
| checkGrammarMethod(node); | ||
|
|
||
|
|
@@ -10937,13 +11022,13 @@ namespace ts { | |
| function checkExpressionWorker(node: Expression, contextualMapper: TypeMapper): Type { | ||
| switch (node.kind) { | ||
| case SyntaxKind.Identifier: | ||
| return checkIdentifier(<Identifier>node, contextualMapper); | ||
| case SyntaxKind.ThisKeyword: | ||
| return checkThisExpression(node); | ||
| case SyntaxKind.SuperKeyword: | ||
| return checkSuperExpression(node); | ||
| case SyntaxKind.NullKeyword: | ||
| return checkNullKeyword(node, contextualMapper); | ||
| case SyntaxKind.TrueKeyword: | ||
| case SyntaxKind.FalseKeyword: | ||
| return booleanType; | ||
|
|
||
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,49 @@ | ||
| tests/cases/conformance/expressions/contextualTyping/implementedPropertyContextualTyping1.ts(21,3): error TS2322: Type 'number' is not assignable to type 'string'. | ||
| tests/cases/conformance/expressions/contextualTyping/implementedPropertyContextualTyping1.ts(24,3): error TS2322: Type 'number' is not assignable to type 'string'. | ||
| tests/cases/conformance/expressions/contextualTyping/implementedPropertyContextualTyping1.ts(28,3): error TS2322: Type 'number' is not assignable to type 'string'. | ||
| tests/cases/conformance/expressions/contextualTyping/implementedPropertyContextualTyping1.ts(31,3): error TS2322: Type 'number' is not assignable to type 'string'. | ||
|
|
||
|
|
||
| ==== tests/cases/conformance/expressions/contextualTyping/implementedPropertyContextualTyping1.ts (4 errors) ==== | ||
| interface Event { | ||
| time: number; | ||
| } | ||
| interface Base { | ||
| superHandle: (e: Event) => number; | ||
| } | ||
| interface Listener extends Base { | ||
| handle: (e: Event) => void; | ||
| } | ||
| interface Ringer { | ||
| ring: (times: number) => void; | ||
| } | ||
|
|
||
| abstract class Watcher { | ||
| abstract watch(e: Event): number; | ||
| } | ||
|
|
||
| class Alarm extends Watcher implements Listener, Ringer { | ||
| str: string; | ||
| handle = e => { | ||
| this.str = e.time; // error | ||
| ~~~~~~~~ | ||
| !!! error TS2322: Type 'number' is not assignable to type 'string'. | ||
| } | ||
| superHandle = e => { | ||
| this.str = e.time; // error | ||
| ~~~~~~~~ | ||
| !!! error TS2322: Type 'number' is not assignable to type 'string'. | ||
| return e.time; | ||
| } | ||
| ring(times) { | ||
| this.str = times; // error | ||
| ~~~~~~~~ | ||
| !!! error TS2322: Type 'number' is not assignable to type 'string'. | ||
| } | ||
| watch(e) { | ||
| this.str = e.time; // error | ||
| ~~~~~~~~ | ||
| !!! error TS2322: Type 'number' is not assignable to type 'string'. | ||
| return e.time; | ||
| } | ||
| } |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,69 @@ | ||
| //// [implementedPropertyContextualTyping1.ts] | ||
| interface Event { | ||
| time: number; | ||
| } | ||
| interface Base { | ||
| superHandle: (e: Event) => number; | ||
| } | ||
| interface Listener extends Base { | ||
| handle: (e: Event) => void; | ||
| } | ||
| interface Ringer { | ||
| ring: (times: number) => void; | ||
| } | ||
|
|
||
| abstract class Watcher { | ||
| abstract watch(e: Event): number; | ||
| } | ||
|
|
||
| class Alarm extends Watcher implements Listener, Ringer { | ||
| str: string; | ||
| handle = e => { | ||
| this.str = e.time; // error | ||
| } | ||
| superHandle = e => { | ||
| this.str = e.time; // error | ||
| return e.time; | ||
| } | ||
| ring(times) { | ||
| this.str = times; // error | ||
| } | ||
| watch(e) { | ||
| this.str = e.time; // error | ||
| return e.time; | ||
| } | ||
| } | ||
|
|
||
| //// [implementedPropertyContextualTyping1.js] | ||
| var __extends = (this && this.__extends) || function (d, b) { | ||
| for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; | ||
| function __() { this.constructor = d; } | ||
| d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); | ||
| }; | ||
| var Watcher = (function () { | ||
| function Watcher() { | ||
| } | ||
| return Watcher; | ||
| }()); | ||
| var Alarm = (function (_super) { | ||
| __extends(Alarm, _super); | ||
| function Alarm() { | ||
| var _this = this; | ||
| _super.apply(this, arguments); | ||
| this.handle = function (e) { | ||
| _this.str = e.time; // error | ||
| }; | ||
| this.superHandle = function (e) { | ||
| _this.str = e.time; // error | ||
| return e.time; | ||
| }; | ||
| } | ||
| Alarm.prototype.ring = function (times) { | ||
| this.str = times; // error | ||
| }; | ||
| Alarm.prototype.watch = function (e) { | ||
| this.str = e.time; // error | ||
| return e.time; | ||
| }; | ||
| return Alarm; | ||
| }(Watcher)); |
Oops, something went wrong.
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Since the first argument never changes, you could factor it out to a constant.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
I'm not so sure this works - doesn't this map all undefined and null types in the expression? So if I have
won't
xinDerivedget the type(x: string) => voidmeaningawill have the type(x: (x: string) => void) => void.Maybe I misunderstood.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
+1
Also, I think the TypeMappers are supposed to be for generics.