For union or intersection types use constituent serialized type if it…

…s same for all of the constituent types Fixes #10809
microsoft · Oct 5, 2016 · 40c2a53 · 40c2a53 · wizarrc · Dec 5, 2016
1 parent c40234f
commit 40c2a53
Show file tree

Hide file tree

Showing 2 changed files with 34 additions and 3 deletions.
diff --git a/src/compiler/transformers/ts.ts b/src/compiler/transformers/ts.ts
@@ -1801,10 +1801,41 @@ namespace ts {
                 case SyntaxKind.TypeReference:
                     return serializeTypeReferenceNode(<TypeReferenceNode>node);
 
+                case SyntaxKind.IntersectionType:
+                case SyntaxKind.UnionType:
+                    {
+                        const unionOrIntersection = <UnionOrIntersectionTypeNode>node;
+                        let serializedUnion: Identifier;
+                        for (const typeNode of unionOrIntersection.types) {
+                            const serializedIndividual = serializeTypeNode(typeNode) as Identifier;
+                            // Non identifier
+                            if (serializedIndividual.kind !== SyntaxKind.Identifier) {
+                                serializedUnion = undefined;
+                                break;
+                            }
+
+                            // One of the individual is global object, return immediately
+                            if (serializedIndividual.text === "Object") {
+                                return serializedIndividual;
+                            }
+
+                            // Different types
+                            if (serializedUnion && serializedUnion.text !== serializedIndividual.text) {
+                                serializedUnion = undefined;
+                                break;
+                            }
+
+                            serializedUnion = serializedIndividual;
+                        }
+
+                        // If we were able to find common type
+                        if (serializedUnion) {
+                            return serializedUnion;
+                        }
+                    }
+                    // Fallthrough
                 case SyntaxKind.TypeQuery:
                 case SyntaxKind.TypeLiteral:
-                case SyntaxKind.UnionType:
-                case SyntaxKind.IntersectionType:
                 case SyntaxKind.AnyKeyword:
                 case SyntaxKind.ThisType:
                     break;

diff --git a/tests/baselines/reference/metadataOfStringLiteral.js b/tests/baselines/reference/metadataOfStringLiteral.js
@@ -24,5 +24,5 @@ var Foo = (function () {
 }());
 __decorate([
     PropDeco,
-    __metadata("design:type", Object)
+    __metadata("design:type", String)
 ], Foo.prototype, "foo");