Evaluation tests and bug fixes

Author: rbuckton

src/compiler/checker.ts

@@ -1263,10 +1263,11 @@ namespace ts {
             return addDeprecatedSuggestionWorker(declaration, diagnostic);
         }
 
-        function createSymbol(flags: SymbolFlags, name: __String, checkFlags?: CheckFlags) {
+        function createSymbol(flags: SymbolFlags, name: __String, checkFlags?: CheckFlags, type?: Type) {
             symbolCount++;
             const symbol = (new Symbol(flags | SymbolFlags.Transient, name) as TransientSymbol);
             symbol.checkFlags = checkFlags || 0;
+            if (type) symbol.type = type;
             return symbol;
         }
 
@@ -37371,6 +37372,30 @@ namespace ts {
                     break;
 
                 case SyntaxKind.PropertyDeclaration:
+                    if (!legacyDecorators) {
+                        headMessage = Diagnostics.Decorator_function_return_type_0_is_not_assignable_to_type_1;
+                        const expectedType = getTypeOfNode(node.parent);
+                        const param = createSymbol(SymbolFlags.FunctionScopedVariable, "value" as __String, /*checkFlags*/ undefined, expectedType);
+                        const initializerSignatureType = createFunctionType(/*typeParameters*/ undefined, /*thisParameter*/ undefined, [param], expectedType);
+                        if (hasAccessorModifier(node.parent)) {
+                            const getSignatureType = createFunctionType(/*typeParameters*/ undefined, /*thisParameter*/ undefined, emptyArray, expectedType);
+                            const setSignatureType = createFunctionType(/*typeParameters*/ undefined, /*thisParameter*/ undefined, [param], voidType);
+                            const members = createSymbolTable([
+                                createSymbol(SymbolFlags.Property | SymbolFlags.Optional, "get" as __String, /*checkFlags*/ undefined, getSignatureType),
+                                createSymbol(SymbolFlags.Property | SymbolFlags.Optional, "set" as __String, /*checkFlags*/ undefined, setSignatureType),
+                                createSymbol(SymbolFlags.Property | SymbolFlags.Optional, "init" as __String, /*checkFlags*/ undefined, initializerSignatureType)
+                            ]);
+
+                            const descriptorType = createAnonymousType(/*symbol*/ undefined, members, emptyArray, emptyArray, emptyArray);
+                            expectedReturnType = getUnionType([descriptorType, voidType]);
+                        }
+                        else {
+                            expectedReturnType = getUnionType([initializerSignatureType, voidType]);
+                        }
+                        break;
+                    }
+                    // falls through
+
                 case SyntaxKind.Parameter:
                     headMessage = Diagnostics.Decorator_function_return_type_is_0_but_is_expected_to_be_void_or_any;
                     expectedReturnType = voidType;
@@ -37380,22 +37405,31 @@ namespace ts {
                 case SyntaxKind.GetAccessor:
                 case SyntaxKind.SetAccessor:
                     headMessage = Diagnostics.Decorator_function_return_type_0_is_not_assignable_to_type_1;
-                    const methodType = getTypeOfNode(node.parent);
-                    expectedReturnType = getUnionType([
-                        legacyDecorators ? createTypedPropertyDescriptorType(methodType) : methodType,
-                        voidType
-                    ]);
+                    const expectedType = legacyDecorators ?
+                        createTypedPropertyDescriptorType(getTypeOfNode(node.parent)) :
+                        getOrCreateTypeFromSignature(getSignatureFromDeclaration(node.parent as MethodDeclaration | GetAccessorDeclaration | SetAccessorDeclaration));
+                    expectedReturnType = getUnionType([expectedType, voidType]);
                     break;
 
                 default:
                     return Debug.failBadSyntaxKind(node.parent);
             }
 
-            checkTypeAssignableTo(
-                returnType,
-                expectedReturnType,
-                node,
-                headMessage);
+            checkTypeAssignableTo(returnType, expectedReturnType, node, headMessage);
+        }
+
+        function createFunctionType(
+            typeParameters: readonly TypeParameter[] | undefined,
+            thisParameter: Symbol | undefined,
+            parameters: readonly Symbol[],
+            returnType: Type,
+            typePredicate?: TypePredicate,
+            minArgumentCount: number = parameters.length,
+            flags: SignatureFlags = SignatureFlags.None
+        ) {
+            const decl = factory.createFunctionTypeNode(/*typeParameters*/ undefined, emptyArray, factory.createKeywordTypeNode(SyntaxKind.AnyKeyword));
+            const signature = createSignature(decl, typeParameters, thisParameter, parameters, returnType, typePredicate, minArgumentCount, flags);
+            return getOrCreateTypeFromSignature(signature);
         }
 
         /**

src/compiler/factory/emitHelpers.ts

@@ -646,19 +646,20 @@ namespace ts {
         priority: 2,
         text: `
             var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
-                function accept(f) { if (f && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+                function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
                 var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
                 var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
                 var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
-                var _;
+                var _, done = false;
                 for (var i = decorators.length - 1; i >= 0; i--) {
                     var context = {};
                     for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
                     for (var p in contextIn.access) context.access[p] = contextIn.access[p];
-                    context.addInitializer = function (f) { extraInitializers.push(f); };
+                    context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
                     var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
                     if (kind === "accessor") {
-                        if (!result) continue;
+                        if (result === void 0) continue;
+                        if (result === null || typeof result !== "object") throw new TypeError("Object expected");
                         if (_ = accept(result.get)) descriptor.get = _;
                         if (_ = accept(result.set)) descriptor.set = _;
                         if (_ = accept(result.init)) initializers.push(_);
@@ -668,7 +669,8 @@ namespace ts {
                         else descriptor[key] = _;
                     }
                 }
-                if (target) Object.defineProperty(target, contextIn.key, descriptor);
+                if (target) Object.defineProperty(target, contextIn.name, descriptor);
+                done = true;
             };`
     };
 

src/compiler/transformers/esDecorators.ts

@@ -704,9 +704,10 @@ namespace ts {
                 const classExpression = factory.createClassExpression(/*modifiers*/ undefined, /*name*/ undefined, /*typeParameters*/ undefined, heritageClauses, members);
                 const classReferenceDeclaration = factory.createVariableDeclaration(classReference, /*exclamationToken*/ undefined, /*type*/ undefined, classExpression);
                 const classReferenceVarDeclList = factory.createVariableDeclarationList([classReferenceDeclaration]);
+                const returnExpr = classInfo.classThis ? factory.createAssignment(classReference, classInfo.classThis) : classReference;
                 classDefinitionStatements.push(
                     factory.createVariableStatement(/*modifiers*/ undefined, classReferenceVarDeclList),
-                    factory.createReturnStatement(classReference),
+                    factory.createReturnStatement(returnExpr),
                 );
             }
             else {
@@ -928,12 +929,12 @@ namespace ts {
                     propertyName = { computed: false, name: member.name };
                 }
                 else if (isPropertyNameLiteral(member.name)) {
-                    propertyName = { computed: true, name: member.name };
+                    propertyName = { computed: true, name: factory.createStringLiteralFromNode(member.name) };
                 }
                 else {
                     const expression = member.name.expression;
                     if (isPropertyNameLiteral(expression) && !isIdentifier(expression)) {
-                        propertyName = { computed: true, name: expression };
+                        propertyName = { computed: true, name: factory.createStringLiteralFromNode(expression) };
                     }
                     else {
                         enterName();

src/testRunner/tsconfig.json

@@ -92,6 +92,7 @@
         "unittests/evaluation/autoAccessors.ts",
         "unittests/evaluation/awaiter.ts",
         "unittests/evaluation/destructuring.ts",
+        "unittests/evaluation/esDecorators.ts",
         "unittests/evaluation/externalModules.ts",
         "unittests/evaluation/forAwaitOf.ts",
         "unittests/evaluation/forOf.ts",