From b345a781d75cc6c06f94d19a2ee0ae46296630c3 Mon Sep 17 00:00:00 2001 From: Sheetal Nandi Date: Fri, 13 Jan 2017 12:41:27 -0800 Subject: [PATCH 1/3] Add test for class from external module is used in union --- .../reference/metadataOfClassFromAlias.js | 49 +++++++++++++++++++ .../metadataOfClassFromAlias.symbols | 28 +++++++++++ .../reference/metadataOfClassFromAlias.types | 31 ++++++++++++ .../compiler/metadataOfClassFromAlias.ts | 18 +++++++ 4 files changed, 126 insertions(+) create mode 100644 tests/baselines/reference/metadataOfClassFromAlias.js create mode 100644 tests/baselines/reference/metadataOfClassFromAlias.symbols create mode 100644 tests/baselines/reference/metadataOfClassFromAlias.types create mode 100644 tests/cases/compiler/metadataOfClassFromAlias.ts diff --git a/tests/baselines/reference/metadataOfClassFromAlias.js b/tests/baselines/reference/metadataOfClassFromAlias.js new file mode 100644 index 00000000000..9e229c2ca38 --- /dev/null +++ b/tests/baselines/reference/metadataOfClassFromAlias.js @@ -0,0 +1,49 @@ +//// [tests/cases/compiler/metadataOfClassFromAlias.ts] //// + +//// [auxiliry.ts] + +export class SomeClass { + field: string; +} + +//// [test.ts] +import { SomeClass } from './auxiliry'; +function annotation(): PropertyDecorator { + return (target: any): void => { }; +} +export class ClassA { + @annotation() array: SomeClass | null; +} + +//// [auxiliry.js] +"use strict"; +var SomeClass = (function () { + function SomeClass() { + } + return SomeClass; +}()); +exports.SomeClass = SomeClass; +//// [test.js] +"use strict"; +var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; +}; +var __metadata = (this && this.__metadata) || function (k, v) { + if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v); +}; +function annotation() { + return function (target) { }; +} +var ClassA = (function () { + function ClassA() { + } + return ClassA; +}()); +__decorate([ + annotation(), + __metadata("design:type", auxiliry_1.SomeClass) +], ClassA.prototype, "array", void 0); +exports.ClassA = ClassA; diff --git a/tests/baselines/reference/metadataOfClassFromAlias.symbols b/tests/baselines/reference/metadataOfClassFromAlias.symbols new file mode 100644 index 00000000000..2cf6ca18393 --- /dev/null +++ b/tests/baselines/reference/metadataOfClassFromAlias.symbols @@ -0,0 +1,28 @@ +=== 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)) +} + +=== tests/cases/compiler/test.ts === +import { SomeClass } from './auxiliry'; +>SomeClass : Symbol(SomeClass, Decl(test.ts, 0, 8)) + +function annotation(): PropertyDecorator { +>annotation : Symbol(annotation, Decl(test.ts, 0, 39)) +>PropertyDecorator : Symbol(PropertyDecorator, Decl(lib.d.ts, --, --)) + + return (target: any): void => { }; +>target : Symbol(target, Decl(test.ts, 2, 12)) +} +export class ClassA { +>ClassA : Symbol(ClassA, Decl(test.ts, 3, 1)) + + @annotation() array: SomeClass | null; +>annotation : Symbol(annotation, Decl(test.ts, 0, 39)) +>array : Symbol(ClassA.array, Decl(test.ts, 4, 21)) +>SomeClass : Symbol(SomeClass, Decl(test.ts, 0, 8)) +} diff --git a/tests/baselines/reference/metadataOfClassFromAlias.types b/tests/baselines/reference/metadataOfClassFromAlias.types new file mode 100644 index 00000000000..1381ab7afac --- /dev/null +++ b/tests/baselines/reference/metadataOfClassFromAlias.types @@ -0,0 +1,31 @@ +=== tests/cases/compiler/auxiliry.ts === + +export class SomeClass { +>SomeClass : SomeClass + + field: string; +>field : string +} + +=== tests/cases/compiler/test.ts === +import { SomeClass } from './auxiliry'; +>SomeClass : typeof SomeClass + +function annotation(): PropertyDecorator { +>annotation : () => PropertyDecorator +>PropertyDecorator : PropertyDecorator + + return (target: any): void => { }; +>(target: any): void => { } : (target: any) => void +>target : any +} +export class ClassA { +>ClassA : ClassA + + @annotation() array: SomeClass | null; +>annotation() : PropertyDecorator +>annotation : () => PropertyDecorator +>array : SomeClass +>SomeClass : SomeClass +>null : null +} diff --git a/tests/cases/compiler/metadataOfClassFromAlias.ts b/tests/cases/compiler/metadataOfClassFromAlias.ts new file mode 100644 index 00000000000..c7407c8d766 --- /dev/null +++ b/tests/cases/compiler/metadataOfClassFromAlias.ts @@ -0,0 +1,18 @@ +// @experimentalDecorators: true +// @emitDecoratorMetadata: true +// @target: es5 +// @module: commonjs + +// @filename: auxiliry.ts +export class SomeClass { + field: string; +} + +//@filename: test.ts +import { SomeClass } from './auxiliry'; +function annotation(): PropertyDecorator { + return (target: any): void => { }; +} +export class ClassA { + @annotation() array: SomeClass | null; +} \ No newline at end of file From 839dde3cf293aab280c9680ef60f54bd0cd8525f Mon Sep 17 00:00:00 2001 From: Sheetal Nandi Date: Tue, 17 Jan 2017 11:20:50 -0800 Subject: [PATCH 2/3] Mark as referenced aliases in Union that will get emitted as part of decorator metadaa Fixes #13449 --- src/compiler/checker.ts | 74 +++++++++++++++++-- src/compiler/transformers/ts.ts | 2 + .../reference/metadataOfClassFromAlias.js | 1 + .../reference/metadataOfClassFromAlias2.js | 49 ++++++++++++ .../metadataOfClassFromAlias2.symbols | 28 +++++++ .../reference/metadataOfClassFromAlias2.types | 31 ++++++++ .../compiler/metadataOfClassFromAlias2.ts | 18 +++++ 7 files changed, 197 insertions(+), 6 deletions(-) create mode 100644 tests/baselines/reference/metadataOfClassFromAlias2.js create mode 100644 tests/baselines/reference/metadataOfClassFromAlias2.symbols create mode 100644 tests/baselines/reference/metadataOfClassFromAlias2.types create mode 100644 tests/cases/compiler/metadataOfClassFromAlias2.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index b4f8fdfeab5..eed762a9036 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -16732,7 +16732,10 @@ namespace ts { * marked as referenced to prevent import elision. */ function markTypeNodeAsReferenced(node: TypeNode) { - const typeName = node && getEntityNameFromTypeNode(node); + markEntityNameOrEntityExpressionAsReference(node && getEntityNameFromTypeNode(node)); + } + + function markEntityNameOrEntityExpressionAsReference(typeName: EntityNameOrEntityNameExpression) { const rootName = typeName && getFirstIdentifier(typeName); const rootSymbol = rootName && resolveName(rootName, rootName.text, (typeName.kind === SyntaxKind.Identifier ? SymbolFlags.Type : SymbolFlags.Namespace) | SymbolFlags.Alias, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined); if (rootSymbol @@ -16743,6 +16746,65 @@ namespace ts { } } + function markDecoratorMedataDataTypeNodeAsReferenced(node: TypeNode): void { + const entityNameOrToken = getEntityNameForDecoratoryMetadata(node); + if (entityNameOrToken && isEntityName(entityNameOrToken)) { + markEntityNameOrEntityExpressionAsReference(entityNameOrToken); + } + } + + type voidUndefinedNullOrNeverTypeNode = Token; + + function getEntityNameForDecoratoryMetadata(node: TypeNode): EntityName | voidUndefinedNullOrNeverTypeNode { + if (node) { + switch (node.kind) { + case SyntaxKind.IntersectionType: + case SyntaxKind.UnionType: + let commonEntityName: EntityName | voidUndefinedNullOrNeverTypeNode; + for (const typeNode of (node).types) { + const individualEntityName = getEntityNameForDecoratoryMetadata(typeNode); + if (!individualEntityName) { + // 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) { + // 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 + // return undefined if they dont match because we would emit object + if (!isIdentifier(commonEntityName) || + !isIdentifier(individualEntityName) || + commonEntityName.text !== individualEntityName.text) { + return undefined; + } + } + else if (!isCommonEntityName) { + commonEntityName = individualEntityName; + } + } + return commonEntityName; + + case SyntaxKind.ParenthesizedType: + return getEntityNameForDecoratoryMetadata((node).type); + + case SyntaxKind.TypeReference: + return (node).typeName; + + case SyntaxKind.VoidKeyword: + case SyntaxKind.UndefinedKeyword: + case SyntaxKind.NullKeyword: + case SyntaxKind.NeverKeyword: + return node; + + } + } + } + function getParameterTypeNodeForDecoratorCheck(node: ParameterDeclaration): TypeNode { return node.dotDotDotToken ? getRestParameterElementType(node.type) : node.type; } @@ -16778,7 +16840,7 @@ namespace ts { const constructor = getFirstConstructorWithBody(node); if (constructor) { for (const parameter of constructor.parameters) { - markTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter)); + markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter)); } } break; @@ -16787,17 +16849,17 @@ namespace ts { case SyntaxKind.GetAccessor: case SyntaxKind.SetAccessor: for (const parameter of (node).parameters) { - markTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter)); + markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter)); } - markTypeNodeAsReferenced((node).type); + markDecoratorMedataDataTypeNodeAsReferenced((node).type); break; case SyntaxKind.PropertyDeclaration: - markTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(node)); + markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(node)); break; case SyntaxKind.Parameter: - markTypeNodeAsReferenced((node).type); + markDecoratorMedataDataTypeNodeAsReferenced((node).type); break; } } diff --git a/src/compiler/transformers/ts.ts b/src/compiler/transformers/ts.ts index e2b8b8fe2ec..a27b9921a4e 100644 --- a/src/compiler/transformers/ts.ts +++ b/src/compiler/transformers/ts.ts @@ -1739,6 +1739,8 @@ namespace ts { } function serializeUnionOrIntersectionType(node: UnionOrIntersectionTypeNode): SerializedTypeNode { + // Note when updating logic here also update getEntityNameForDecoratoryMetadata + // so that aliases can be marked as referenced let serializedUnion: SerializedTypeNode; for (const typeNode of node.types) { const serializedIndividual = serializeTypeNode(typeNode); diff --git a/tests/baselines/reference/metadataOfClassFromAlias.js b/tests/baselines/reference/metadataOfClassFromAlias.js index 9e229c2ca38..bf3d8bf860f 100644 --- a/tests/baselines/reference/metadataOfClassFromAlias.js +++ b/tests/baselines/reference/metadataOfClassFromAlias.js @@ -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); }; +var auxiliry_1 = require("./auxiliry"); function annotation() { return function (target) { }; } diff --git a/tests/baselines/reference/metadataOfClassFromAlias2.js b/tests/baselines/reference/metadataOfClassFromAlias2.js new file mode 100644 index 00000000000..70488af2b7e --- /dev/null +++ b/tests/baselines/reference/metadataOfClassFromAlias2.js @@ -0,0 +1,49 @@ +//// [tests/cases/compiler/metadataOfClassFromAlias2.ts] //// + +//// [auxiliry.ts] + +export class SomeClass { + field: string; +} + +//// [test.ts] +import { SomeClass } from './auxiliry'; +function annotation(): PropertyDecorator { + return (target: any): void => { }; +} +export class ClassA { + @annotation() array: SomeClass | null | string; +} + +//// [auxiliry.js] +"use strict"; +var SomeClass = (function () { + function SomeClass() { + } + return SomeClass; +}()); +exports.SomeClass = SomeClass; +//// [test.js] +"use strict"; +var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; +}; +var __metadata = (this && this.__metadata) || function (k, v) { + if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v); +}; +function annotation() { + return function (target) { }; +} +var ClassA = (function () { + function ClassA() { + } + return ClassA; +}()); +__decorate([ + annotation(), + __metadata("design:type", Object) +], ClassA.prototype, "array", void 0); +exports.ClassA = ClassA; diff --git a/tests/baselines/reference/metadataOfClassFromAlias2.symbols b/tests/baselines/reference/metadataOfClassFromAlias2.symbols new file mode 100644 index 00000000000..ab183452f20 --- /dev/null +++ b/tests/baselines/reference/metadataOfClassFromAlias2.symbols @@ -0,0 +1,28 @@ +=== 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)) +} + +=== tests/cases/compiler/test.ts === +import { SomeClass } from './auxiliry'; +>SomeClass : Symbol(SomeClass, Decl(test.ts, 0, 8)) + +function annotation(): PropertyDecorator { +>annotation : Symbol(annotation, Decl(test.ts, 0, 39)) +>PropertyDecorator : Symbol(PropertyDecorator, Decl(lib.d.ts, --, --)) + + return (target: any): void => { }; +>target : Symbol(target, Decl(test.ts, 2, 12)) +} +export class ClassA { +>ClassA : Symbol(ClassA, Decl(test.ts, 3, 1)) + + @annotation() array: SomeClass | null | string; +>annotation : Symbol(annotation, Decl(test.ts, 0, 39)) +>array : Symbol(ClassA.array, Decl(test.ts, 4, 21)) +>SomeClass : Symbol(SomeClass, Decl(test.ts, 0, 8)) +} diff --git a/tests/baselines/reference/metadataOfClassFromAlias2.types b/tests/baselines/reference/metadataOfClassFromAlias2.types new file mode 100644 index 00000000000..75807845d1a --- /dev/null +++ b/tests/baselines/reference/metadataOfClassFromAlias2.types @@ -0,0 +1,31 @@ +=== tests/cases/compiler/auxiliry.ts === + +export class SomeClass { +>SomeClass : SomeClass + + field: string; +>field : string +} + +=== tests/cases/compiler/test.ts === +import { SomeClass } from './auxiliry'; +>SomeClass : typeof SomeClass + +function annotation(): PropertyDecorator { +>annotation : () => PropertyDecorator +>PropertyDecorator : PropertyDecorator + + return (target: any): void => { }; +>(target: any): void => { } : (target: any) => void +>target : any +} +export class ClassA { +>ClassA : ClassA + + @annotation() array: SomeClass | null | string; +>annotation() : PropertyDecorator +>annotation : () => PropertyDecorator +>array : string | SomeClass +>SomeClass : SomeClass +>null : null +} diff --git a/tests/cases/compiler/metadataOfClassFromAlias2.ts b/tests/cases/compiler/metadataOfClassFromAlias2.ts new file mode 100644 index 00000000000..05c44d9c677 --- /dev/null +++ b/tests/cases/compiler/metadataOfClassFromAlias2.ts @@ -0,0 +1,18 @@ +// @experimentalDecorators: true +// @emitDecoratorMetadata: true +// @target: es5 +// @module: commonjs + +// @filename: auxiliry.ts +export class SomeClass { + field: string; +} + +//@filename: test.ts +import { SomeClass } from './auxiliry'; +function annotation(): PropertyDecorator { + return (target: any): void => { }; +} +export class ClassA { + @annotation() array: SomeClass | null | string; +} \ No newline at end of file From 0eaa8eb3ab9ad1db8cf95c51d8e02c9d65ee40cf Mon Sep 17 00:00:00 2001 From: Sheetal Nandi Date: Fri, 14 Apr 2017 11:08:05 -0700 Subject: [PATCH 3/3] 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");