Synchronize getEntityNameForDecoratorMetadata and serializeUnionOrIntersectionType (microsoft#19879)

Author: weswigham

src/compiler/checker.ts

@@ -20191,7 +20191,16 @@ namespace ts {
                     case SyntaxKind.IntersectionType:
                     case SyntaxKind.UnionType:
                         let commonEntityName: EntityName;
-                        for (const typeNode of (<UnionOrIntersectionTypeNode>node).types) {
+                        for (let typeNode of (<UnionOrIntersectionTypeNode>node).types) {
+                            while (typeNode.kind === SyntaxKind.ParenthesizedType) {
+                                typeNode = (typeNode as ParenthesizedTypeNode).type; // Skip parens if need be
+                            }
+                            if (typeNode.kind === SyntaxKind.NeverKeyword) {
+                                continue; // Always elide `never` from the union/intersection if possible
+                            }
+                            if (!strictNullChecks && (typeNode.kind === SyntaxKind.NullKeyword || typeNode.kind === SyntaxKind.UndefinedKeyword)) {
+                                continue; // Elide null and undefined from unions for metadata, just like what we did prior to the implementation of strict null checks
+                            }
                             const individualEntityName = getEntityNameForDecoratorMetadata(typeNode);
                             if (!individualEntityName) {
                                 // Individual is something like string number

tests/baselines/reference/metadataOfClassFromAlias.js

@@ -35,6 +35,7 @@ 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 });
+var auxiliry_1 = require("./auxiliry");
 function annotation() {
     return function (target) { };
 }

tests/baselines/reference/metadataReferencedWithinFilteredUnion.js

@@ -0,0 +1,60 @@
+//// [tests/cases/compiler/metadataReferencedWithinFilteredUnion.ts] ////
+
+//// [Class1.ts]
+export class Class1 {
+}
+//// [Class2.ts]
+import { Class1 } from './Class1';
+
+function decorate(target: any, propertyKey: string) {
+}
+
+export class Class2 {
+    @decorate
+    get prop(): Class1 | undefined {
+        return undefined;
+    }
+}
+
+//// [Class1.js]
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var Class1 = /** @class */ (function () {
+    function Class1() {
+    }
+    return Class1;
+}());
+exports.Class1 = Class1;
+//// [Class2.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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var Class1_1 = require("./Class1");
+function decorate(target, propertyKey) {
+}
+var Class2 = /** @class */ (function () {
+    function Class2() {
+    }
+    Object.defineProperty(Class2.prototype, "prop", {
+        get: function () {
+            return undefined;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    __decorate([
+        decorate,
+        __metadata("design:type", Class1_1.Class1),
+        __metadata("design:paramtypes", [])
+    ], Class2.prototype, "prop", null);
+    return Class2;
+}());
+exports.Class2 = Class2;

tests/baselines/reference/metadataReferencedWithinFilteredUnion.symbols

@@ -0,0 +1,28 @@
+=== tests/cases/compiler/Class1.ts ===
+export class Class1 {
+>Class1 : Symbol(Class1, Decl(Class1.ts, 0, 0))
+}
+=== tests/cases/compiler/Class2.ts ===
+import { Class1 } from './Class1';
+>Class1 : Symbol(Class1, Decl(Class2.ts, 0, 8))
+
+function decorate(target: any, propertyKey: string) {
+>decorate : Symbol(decorate, Decl(Class2.ts, 0, 34))
+>target : Symbol(target, Decl(Class2.ts, 2, 18))
+>propertyKey : Symbol(propertyKey, Decl(Class2.ts, 2, 30))
+}
+
+export class Class2 {
+>Class2 : Symbol(Class2, Decl(Class2.ts, 3, 1))
+
+    @decorate
+>decorate : Symbol(decorate, Decl(Class2.ts, 0, 34))
+
+    get prop(): Class1 | undefined {
+>prop : Symbol(Class2.prop, Decl(Class2.ts, 5, 21))
+>Class1 : Symbol(Class1, Decl(Class2.ts, 0, 8))
+
+        return undefined;
+>undefined : Symbol(undefined)
+    }
+}

tests/baselines/reference/metadataReferencedWithinFilteredUnion.types

@@ -0,0 +1,28 @@
+=== tests/cases/compiler/Class1.ts ===
+export class Class1 {
+>Class1 : Class1
+}
+=== tests/cases/compiler/Class2.ts ===
+import { Class1 } from './Class1';
+>Class1 : typeof Class1
+
+function decorate(target: any, propertyKey: string) {
+>decorate : (target: any, propertyKey: string) => void
+>target : any
+>propertyKey : string
+}
+
+export class Class2 {
+>Class2 : Class2
+
+    @decorate
+>decorate : (target: any, propertyKey: string) => void
+
+    get prop(): Class1 | undefined {
+>prop : Class1
+>Class1 : Class1
+
+        return undefined;
+>undefined : undefined
+    }
+}

tests/cases/compiler/metadataReferencedWithinFilteredUnion.ts

@@ -0,0 +1,18 @@
+// @experimentalDecorators: true
+// @emitDecoratorMetadata: true
+// @target: es5
+// @filename: Class1.ts
+export class Class1 {
+}
+// @filename: Class2.ts
+import { Class1 } from './Class1';
+
+function decorate(target: any, propertyKey: string) {
+}
+
+export class Class2 {
+    @decorate
+    get prop(): Class1 | undefined {
+        return undefined;
+    }
+}