From 0eaa8eb3ab9ad1db8cf95c51d8e02c9d65ee40cf Mon Sep 17 00:00:00 2001 From: Sheetal Nandi Date: Fri, 14 Apr 2017 11:08:05 -0700 Subject: [PATCH] Updating PR as per feedback. OneType|null is again treated as object instead of simplifying it --- src/compiler/checker.ts | 40 +++++++++---------- src/compiler/transformers/ts.ts | 12 ++---- src/compiler/utilities.ts | 4 -- .../reference/metadataOfClassFromAlias.js | 6 +-- .../metadataOfClassFromAlias.symbols | 3 +- .../reference/metadataOfClassFromAlias.types | 1 - .../reference/metadataOfClassFromAlias2.js | 3 +- .../metadataOfClassFromAlias2.symbols | 3 +- .../reference/metadataOfClassFromAlias2.types | 1 - .../reference/metadataOfUnionWithNull.js | 16 ++++---- 10 files changed, 36 insertions(+), 53 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index f118fdbba1e..c0d3cd17fdb 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -18625,33 +18625,36 @@ namespace ts { } } + /** + * This function marks the type used for metadata decorator as referenced if it is import + * from external module. + * This is different from markTypeNodeAsReferenced because it tries to simplify type nodes in + * union and intersection type + * @param node + */ function markDecoratorMedataDataTypeNodeAsReferenced(node: TypeNode): void { - const entityNameOrToken = getEntityNameForDecoratoryMetadata(node); - if (entityNameOrToken && isEntityName(entityNameOrToken)) { - markEntityNameOrEntityExpressionAsReference(entityNameOrToken); + const entityName = getEntityNameForDecoratorMetadata(node); + if (entityName && isEntityName(entityName)) { + markEntityNameOrEntityExpressionAsReference(entityName); } } - type voidUndefinedNullOrNeverTypeNode = Token; - - function getEntityNameForDecoratoryMetadata(node: TypeNode): EntityName | voidUndefinedNullOrNeverTypeNode { + function getEntityNameForDecoratorMetadata(node: TypeNode): EntityName { if (node) { switch (node.kind) { case SyntaxKind.IntersectionType: case SyntaxKind.UnionType: - let commonEntityName: EntityName | voidUndefinedNullOrNeverTypeNode; + let commonEntityName: EntityName; for (const typeNode of (node).types) { - const individualEntityName = getEntityNameForDecoratoryMetadata(typeNode); + const individualEntityName = getEntityNameForDecoratorMetadata(typeNode); if (!individualEntityName) { - // Individual is something like string number - // So it would be serialized to either that type or object + // Individual is something like string number + // So it would be serialized to either that type or object // Safe to return here return undefined; } - const isCommonEntityName = commonEntityName && isEntityName(commonEntityName); - const isIndividualEntityName = isEntityName(individualEntityName); - if (isCommonEntityName && isIndividualEntityName) { + if (commonEntityName) { // Note this is in sync with the transformation that happens for type node. // Keep this in sync with serializeUnionOrIntersectionType // Verify if they refer to same entity and is identifier @@ -18662,24 +18665,17 @@ namespace ts { return undefined; } } - else if (!isCommonEntityName) { + else { commonEntityName = individualEntityName; } } return commonEntityName; case SyntaxKind.ParenthesizedType: - return getEntityNameForDecoratoryMetadata((node).type); + return getEntityNameForDecoratorMetadata((node).type); case SyntaxKind.TypeReference: return (node).typeName; - - case SyntaxKind.VoidKeyword: - case SyntaxKind.UndefinedKeyword: - case SyntaxKind.NullKeyword: - case SyntaxKind.NeverKeyword: - return node; - } } } diff --git a/src/compiler/transformers/ts.ts b/src/compiler/transformers/ts.ts index 06bd3fef032..68bba667058 100644 --- a/src/compiler/transformers/ts.ts +++ b/src/compiler/transformers/ts.ts @@ -1761,25 +1761,19 @@ namespace ts { } function serializeUnionOrIntersectionType(node: UnionOrIntersectionTypeNode): SerializedTypeNode { - // Note when updating logic here also update getEntityNameForDecoratoryMetadata + // Note when updating logic here also update getEntityNameForDecoratorMetadata // so that aliases can be marked as referenced let serializedUnion: SerializedTypeNode; for (const typeNode of node.types) { const serializedIndividual = serializeTypeNode(typeNode); - if (isVoidExpression(serializedIndividual)) { - // If we dont have any other type already set, set the initial type - if (!serializedUnion) { - serializedUnion = serializedIndividual; - } - } - else if (isIdentifier(serializedIndividual) && serializedIndividual.text === "Object") { + if (isIdentifier(serializedIndividual) && serializedIndividual.text === "Object") { // One of the individual is global object, return immediately return serializedIndividual; } // If there exists union that is not void 0 expression, check if the the common type is identifier. // anything more complex and we will just default to Object - else if (serializedUnion && !isVoidExpression(serializedUnion)) { + else if (serializedUnion) { // Different types if (!isIdentifier(serializedUnion) || !isIdentifier(serializedIndividual) || diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 3b4b87c956f..c6328324bbb 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -3566,10 +3566,6 @@ namespace ts { return node.kind === SyntaxKind.Identifier; } - export function isVoidExpression(node: Node): node is VoidExpression { - return node.kind === SyntaxKind.VoidExpression; - } - export function isGeneratedIdentifier(node: Node): node is GeneratedIdentifier { // Using `>` here catches both `GeneratedIdentifierKind.None` and `undefined`. return isIdentifier(node) && node.autoGenerateKind > GeneratedIdentifierKind.None; diff --git a/tests/baselines/reference/metadataOfClassFromAlias.js b/tests/baselines/reference/metadataOfClassFromAlias.js index bf3d8bf860f..c99f7cc2e23 100644 --- a/tests/baselines/reference/metadataOfClassFromAlias.js +++ b/tests/baselines/reference/metadataOfClassFromAlias.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/metadataOfClassFromAlias.ts] //// //// [auxiliry.ts] - export class SomeClass { field: string; } @@ -17,6 +16,7 @@ export class ClassA { //// [auxiliry.js] "use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); var SomeClass = (function () { function SomeClass() { } @@ -34,7 +34,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key, var __metadata = (this && this.__metadata) || function (k, v) { if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v); }; -var auxiliry_1 = require("./auxiliry"); +Object.defineProperty(exports, "__esModule", { value: true }); function annotation() { return function (target) { }; } @@ -45,6 +45,6 @@ var ClassA = (function () { }()); __decorate([ annotation(), - __metadata("design:type", auxiliry_1.SomeClass) + __metadata("design:type", Object) ], ClassA.prototype, "array", void 0); exports.ClassA = ClassA; diff --git a/tests/baselines/reference/metadataOfClassFromAlias.symbols b/tests/baselines/reference/metadataOfClassFromAlias.symbols index 2cf6ca18393..b4d20403275 100644 --- a/tests/baselines/reference/metadataOfClassFromAlias.symbols +++ b/tests/baselines/reference/metadataOfClassFromAlias.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/auxiliry.ts === - export class SomeClass { >SomeClass : Symbol(SomeClass, Decl(auxiliry.ts, 0, 0)) field: string; ->field : Symbol(SomeClass.field, Decl(auxiliry.ts, 1, 24)) +>field : Symbol(SomeClass.field, Decl(auxiliry.ts, 0, 24)) } === tests/cases/compiler/test.ts === diff --git a/tests/baselines/reference/metadataOfClassFromAlias.types b/tests/baselines/reference/metadataOfClassFromAlias.types index 1381ab7afac..a14f72ee619 100644 --- a/tests/baselines/reference/metadataOfClassFromAlias.types +++ b/tests/baselines/reference/metadataOfClassFromAlias.types @@ -1,5 +1,4 @@ === tests/cases/compiler/auxiliry.ts === - export class SomeClass { >SomeClass : SomeClass diff --git a/tests/baselines/reference/metadataOfClassFromAlias2.js b/tests/baselines/reference/metadataOfClassFromAlias2.js index 70488af2b7e..bcdbb34ac50 100644 --- a/tests/baselines/reference/metadataOfClassFromAlias2.js +++ b/tests/baselines/reference/metadataOfClassFromAlias2.js @@ -1,7 +1,6 @@ //// [tests/cases/compiler/metadataOfClassFromAlias2.ts] //// //// [auxiliry.ts] - export class SomeClass { field: string; } @@ -17,6 +16,7 @@ export class ClassA { //// [auxiliry.js] "use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); var SomeClass = (function () { function SomeClass() { } @@ -34,6 +34,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key, var __metadata = (this && this.__metadata) || function (k, v) { if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v); }; +Object.defineProperty(exports, "__esModule", { value: true }); function annotation() { return function (target) { }; } diff --git a/tests/baselines/reference/metadataOfClassFromAlias2.symbols b/tests/baselines/reference/metadataOfClassFromAlias2.symbols index ab183452f20..a20296c76af 100644 --- a/tests/baselines/reference/metadataOfClassFromAlias2.symbols +++ b/tests/baselines/reference/metadataOfClassFromAlias2.symbols @@ -1,10 +1,9 @@ === tests/cases/compiler/auxiliry.ts === - export class SomeClass { >SomeClass : Symbol(SomeClass, Decl(auxiliry.ts, 0, 0)) field: string; ->field : Symbol(SomeClass.field, Decl(auxiliry.ts, 1, 24)) +>field : Symbol(SomeClass.field, Decl(auxiliry.ts, 0, 24)) } === tests/cases/compiler/test.ts === diff --git a/tests/baselines/reference/metadataOfClassFromAlias2.types b/tests/baselines/reference/metadataOfClassFromAlias2.types index 75807845d1a..20979a5c77d 100644 --- a/tests/baselines/reference/metadataOfClassFromAlias2.types +++ b/tests/baselines/reference/metadataOfClassFromAlias2.types @@ -1,5 +1,4 @@ === tests/cases/compiler/auxiliry.ts === - export class SomeClass { >SomeClass : SomeClass diff --git a/tests/baselines/reference/metadataOfUnionWithNull.js b/tests/baselines/reference/metadataOfUnionWithNull.js index cc594ae326d..0c834be9687 100644 --- a/tests/baselines/reference/metadataOfUnionWithNull.js +++ b/tests/baselines/reference/metadataOfUnionWithNull.js @@ -65,15 +65,15 @@ var B = (function () { }()); __decorate([ PropDeco, - __metadata("design:type", String) + __metadata("design:type", Object) ], B.prototype, "x"); __decorate([ PropDeco, - __metadata("design:type", Boolean) + __metadata("design:type", Object) ], B.prototype, "y"); __decorate([ PropDeco, - __metadata("design:type", String) + __metadata("design:type", Object) ], B.prototype, "z"); __decorate([ PropDeco, @@ -89,11 +89,11 @@ __decorate([ ], B.prototype, "c"); __decorate([ PropDeco, - __metadata("design:type", void 0) + __metadata("design:type", Object) ], B.prototype, "d"); __decorate([ PropDeco, - __metadata("design:type", typeof Symbol === "function" ? Symbol : Object) + __metadata("design:type", Object) ], B.prototype, "e"); __decorate([ PropDeco, @@ -101,13 +101,13 @@ __decorate([ ], B.prototype, "f"); __decorate([ PropDeco, - __metadata("design:type", A) + __metadata("design:type", Object) ], B.prototype, "g"); __decorate([ PropDeco, - __metadata("design:type", B) + __metadata("design:type", Object) ], B.prototype, "h"); __decorate([ PropDeco, - __metadata("design:type", typeof Symbol === "function" ? Symbol : Object) + __metadata("design:type", Object) ], B.prototype, "j");