microsoft · sandersn · Oct 8, 2019
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -31642,7 +31642,8 @@ namespace ts {
                         if (basePropertyFlags !== SymbolFlags.Property && derivedPropertyFlags === SymbolFlags.Property) {
                             errorMessage = Diagnostics.Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_property;
                         }
-                        else if (basePropertyFlags === SymbolFlags.Property && derivedPropertyFlags !== SymbolFlags.Property) {
+                        else if (basePropertyFlags === SymbolFlags.Property && derivedPropertyFlags !== SymbolFlags.Property
+                                 && !(base.valueDeclaration && base.valueDeclaration.flags & NodeFlags.Ambient && getJSDocTags(base.valueDeclaration).find(tag => tag.tagName.escapedText === "accessor"))) {
                             errorMessage = Diagnostics.Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_accessor;
                         }
                         else {

diff --git a/src/compiler/transformers/declarations.ts b/src/compiler/transformers/declarations.ts
@@ -83,6 +83,7 @@ namespace ts {
         let emittedImports: readonly AnyImportSyntax[] | undefined; // must be declared in container so it can be `undefined` while transformer's first pass
         const resolver = context.getEmitResolver();
         const options = context.getCompilerOptions();
+        const newLine = getNewLineCharacter(options);
         const { noResolve, stripInternal } = options;
         return transformRoot;
 
@@ -864,25 +865,35 @@ namespace ts {
                         return cleanup(sig);
                     }
                     case SyntaxKind.GetAccessor: {
-                        const isPrivate = hasModifier(input, ModifierFlags.Private);
-                        const accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, resolver.getAllAccessorDeclarations(input));
-                        return cleanup(updateGetAccessor(
-                            input,
-                            /*decorators*/ undefined,
-                            ensureModifiers(input),
-                            input.name,
-                            updateAccessorParamsList(input, isPrivate),
-                            !isPrivate ? ensureType(input, accessorType) : undefined,
-                            /*body*/ undefined));
+                        if (options.useDefineForClassFields) {
+                            const isPrivate = hasModifier(input, ModifierFlags.Private);
+                            const accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, resolver.getAllAccessorDeclarations(input));
+                            return cleanup(updateGetAccessor(
+                                input,
+                                /*decorators*/ undefined,
+                                ensureModifiers(input),
+                                input.name,
+                                updateAccessorParamsList(input, isPrivate),
+                                !isPrivate ? ensureType(input, accessorType) : undefined,
+                                /*body*/ undefined));
+                        }
+                        else {
+                            return cleanup(ensureAccessor(input));
+                        }
                     }
                     case SyntaxKind.SetAccessor: {
-                        return cleanup(updateSetAccessor(
-                            input,
-                            /*decorators*/ undefined,
-                            ensureModifiers(input),
-                            input.name,
-                            updateAccessorParamsList(input, hasModifier(input, ModifierFlags.Private)),
-                            /*body*/ undefined));
+                        if (options.useDefineForClassFields) {
+                            return cleanup(updateSetAccessor(
+                                input,
+                                /*decorators*/ undefined,
+                                ensureModifiers(input),
+                                input.name,
+                                updateAccessorParamsList(input, hasModifier(input, ModifierFlags.Private)),
+                                /*body*/ undefined));
+                        }
+                        else {
+                            return cleanup(ensureAccessor(input));
+                        }
                     }
                     case SyntaxKind.PropertyDeclaration:
                         return cleanup(updateProperty(
@@ -1455,6 +1466,42 @@ namespace ts {
             return accessorType;
         }
 
+        function ensureAccessor(node: AccessorDeclaration): PropertyDeclaration | undefined {
+            const accessors = resolver.getAllAccessorDeclarations(node);
+            if (node.kind !== accessors.firstAccessor.kind) {
+                return;
+            }
+            const accessorType = getTypeAnnotationFromAllAccessorDeclarations(node, accessors);
+            const prop = createProperty(/*decorators*/ undefined, maskModifiers(node, /*mask*/ undefined, (!accessors.setAccessor) ? ModifierFlags.Readonly : ModifierFlags.None), node.name, node.questionToken, ensureType(node, accessorType), /*initializer*/ undefined);
+            const leadingsSyntheticCommentRanges = accessors.secondAccessor && getLeadingCommentRangesOfNode(accessors.secondAccessor, currentSourceFile);
+            if (leadingsSyntheticCommentRanges) {
+                for (const range of leadingsSyntheticCommentRanges) {
+                    if (range.kind === SyntaxKind.MultiLineCommentTrivia) {
+                        let text = currentSourceFile.text.slice(range.pos + 2, range.end - 2);
+                        const lines = text.split(/\r\n?|\n/g);
+                        if (lines.length > 1) {
+                            const lastLines = lines.slice(1);
+                            const indentation = guessIndentation(lastLines);
+                            text = [lines[0], ...map(lastLines, l => l.slice(indentation))].join(newLine);
+                        }
+                        addSyntheticLeadingComment(
+                            prop,
+                            range.kind,
+                            text,
+                            range.hasTrailingNewLine
+                        );
+                    }
+                }
+            }
+            addSyntheticLeadingComment(
+                prop,
+                SyntaxKind.MultiLineCommentTrivia,
+                "*@accessor",
+                /*hasTrailingNewLine*/ false
+            );
+            return prop;
+        }
+
         function transformHeritageClauses(nodes: NodeArray<HeritageClause> | undefined) {
             return createNodeArray(filter(map(nodes, clause => updateHeritageClause(clause, visitNodes(createNodeArray(filter(clause.types, t => {
                 return isEntityNameExpression(t.expression) || (clause.token === SyntaxKind.ExtendsKeyword && t.expression.kind === SyntaxKind.NullKeyword);

diff --git a/tests/baselines/reference/accessorDeclarationEmitVisibilityErrors.errors.txt b/tests/baselines/reference/accessorDeclarationEmitVisibilityErrors.errors.txt
@@ -1,5 +1,5 @@
 tests/cases/compiler/accessorDeclarationEmitVisibilityErrors.ts(2,18): error TS2304: Cannot find name 'DoesNotExist'.
-tests/cases/compiler/accessorDeclarationEmitVisibilityErrors.ts(2,18): error TS4106: Parameter 'arg' of accessor has or is using private name 'DoesNotExist'.
+tests/cases/compiler/accessorDeclarationEmitVisibilityErrors.ts(2,18): error TS4037: Parameter type of public setter 'bet' from exported class has or is using private name 'DoesNotExist'.
 
 
 ==== tests/cases/compiler/accessorDeclarationEmitVisibilityErrors.ts (2 errors) ====
@@ -8,5 +8,5 @@ tests/cases/compiler/accessorDeclarationEmitVisibilityErrors.ts(2,18): error TS4
                      ~~~~~~~~~~~~
 !!! error TS2304: Cannot find name 'DoesNotExist'.
                      ~~~~~~~~~~~~
-!!! error TS4106: Parameter 'arg' of accessor has or is using private name 'DoesNotExist'.
+!!! error TS4037: Parameter type of public setter 'bet' from exported class has or is using private name 'DoesNotExist'.
     }
diff --git a/tests/baselines/reference/accessorWithES5.js b/tests/baselines/reference/accessorWithES5.js
@@ -10,13 +10,21 @@ class D {
     }
 }
 
+class E {
+    // comment 1
+    get x() { return 2; }
+    // comment 2
+    set x(v) { }
+}
+
 var x = {
     get a() { return 1 }
 }
 
 var y = {
     set b(v) { }
-}
+}
+
 
 //// [accessorWithES5.js]
 var C = /** @class */ (function () {
@@ -42,9 +50,40 @@ var D = /** @class */ (function () {
     });
     return D;
 }());
+var E = /** @class */ (function () {
+    function E() {
+    }
+    Object.defineProperty(E.prototype, "x", {
+        // comment 1
+        get: function () { return 2; },
+        // comment 2
+        set: function (v) { },
+        enumerable: true,
+        configurable: true
+    });
+    return E;
+}());
 var x = {
     get a() { return 1; }
 };
 var y = {
     set b(v) { }
 };
+
+
+//// [accessorWithES5.d.ts]
+declare class C {
+    /**@accessor*/ readonly x: number;
+}
+declare class D {
+    /**@accessor*/ x: any;
+}
+declare class E {
+    /**@accessor*/ x: number;
+}
+declare var x: {
+    readonly a: number;
+};
+declare var y: {
+    b: any;
+};
diff --git a/tests/baselines/reference/accessorWithES5.symbols b/tests/baselines/reference/accessorWithES5.symbols
@@ -18,17 +18,31 @@ class D {
     }
 }
 
+class E {
+>E : Symbol(E, Decl(accessorWithES5.ts, 9, 1))
+
+    // comment 1
+    get x() { return 2; }
+>x : Symbol(E.x, Decl(accessorWithES5.ts, 11, 9), Decl(accessorWithES5.ts, 13, 25))
+
+    // comment 2
+    set x(v) { }
+>x : Symbol(E.x, Decl(accessorWithES5.ts, 11, 9), Decl(accessorWithES5.ts, 13, 25))
+>v : Symbol(v, Decl(accessorWithES5.ts, 15, 10))
+}
+
 var x = {
->x : Symbol(x, Decl(accessorWithES5.ts, 11, 3))
+>x : Symbol(x, Decl(accessorWithES5.ts, 18, 3))
 
     get a() { return 1 }
->a : Symbol(a, Decl(accessorWithES5.ts, 11, 9))
+>a : Symbol(a, Decl(accessorWithES5.ts, 18, 9))
 }
 
 var y = {
->y : Symbol(y, Decl(accessorWithES5.ts, 15, 3))
+>y : Symbol(y, Decl(accessorWithES5.ts, 22, 3))
 
     set b(v) { }
->b : Symbol(b, Decl(accessorWithES5.ts, 15, 9))
->v : Symbol(v, Decl(accessorWithES5.ts, 16, 10))
+>b : Symbol(b, Decl(accessorWithES5.ts, 22, 9))
+>v : Symbol(v, Decl(accessorWithES5.ts, 23, 10))
 }
+
diff --git a/tests/baselines/reference/accessorWithES5.types b/tests/baselines/reference/accessorWithES5.types
@@ -19,6 +19,20 @@ class D {
     }
 }
 
+class E {
+>E : E
+
+    // comment 1
+    get x() { return 2; }
+>x : number
+>2 : 2
+
+    // comment 2
+    set x(v) { }
+>x : number
+>v : number
+}
+
 var x = {
 >x : { readonly a: number; }
 >{    get a() { return 1 }} : { readonly a: number; }
@@ -36,3 +50,4 @@ var y = {
 >b : any
 >v : any
 }
+
diff --git a/tests/baselines/reference/ambientAccessors(target=es3).js b/tests/baselines/reference/ambientAccessors(target=es3).js
@@ -19,12 +19,8 @@ declare class C {
 
 //// [ambientAccessors.d.ts]
 declare class C {
-    static get a(): string;
-    static set a(value: string);
-    private static get b();
-    private static set b(value);
-    get x(): string;
-    set x(value: string);
-    private get y();
-    private set y(value);
+    /**@accessor*/ static a: string;
+    /**@accessor*/ private static b;
+    /**@accessor*/ x: string;
+    /**@accessor*/ private y;
 }
diff --git a/tests/baselines/reference/ambientAccessors(target=es5).js b/tests/baselines/reference/ambientAccessors(target=es5).js
@@ -19,12 +19,8 @@ declare class C {
 
 //// [ambientAccessors.d.ts]
 declare class C {
-    static get a(): string;
-    static set a(value: string);
-    private static get b();
-    private static set b(value);
-    get x(): string;
-    set x(value: string);
-    private get y();
-    private set y(value);
+    /**@accessor*/ static a: string;
+    /**@accessor*/ private static b;
+    /**@accessor*/ x: string;
+    /**@accessor*/ private y;
 }
diff --git a/tests/baselines/reference/assertionTypePredicates1.js b/tests/baselines/reference/assertionTypePredicates1.js
@@ -303,9 +303,7 @@ declare let Q1: new (x: unknown) => x is string;
 declare let Q2: new (x: boolean) => asserts x;
 declare let Q3: new (x: unknown) => asserts x is string;
 declare class Wat {
-    get p1(): this is string;
-    set p1(x: this is string);
-    get p2(): asserts this is string;
-    set p2(x: asserts this is string);
+    /**@accessor*/ p1: this is string;
+    /**@accessor*/ p2: asserts this is string;
 }
 declare function f20(x: unknown): void;
diff --git a/tests/baselines/reference/classdecl.js b/tests/baselines/reference/classdecl.js
@@ -218,14 +218,13 @@ declare class a {
     constructor(s: string);
     pgF(): void;
     pv: any;
-    get d(): number;
-    set d(a: number);
-    static get p2(): {
+    /**@accessor*/ d: number;
+    /**@accessor*/ static readonly p2: {
         x: number;
         y: number;
     };
     private static d2;
-    private static get p3();
+    /**@accessor*/ private static readonly p3;
     private pv3;
     private foo;
 }

diff --git a/tests/baselines/reference/commentsdoNotEmitComments.js b/tests/baselines/reference/commentsdoNotEmitComments.js
@@ -144,8 +144,7 @@ declare class c {
     constructor();
     b: number;
     myFoo(): number;
-    get prop1(): number;
-    set prop1(val: number);
+    prop1: number;
     foo1(a: number): string;
     foo1(b: string): string;
 }

diff --git a/tests/baselines/reference/commentsemitComments.js b/tests/baselines/reference/commentsemitComments.js
@@ -160,9 +160,8 @@ declare class c {
     /** function comment */
     myFoo(): number;
     /** getter comment*/
-    get prop1(): number;
     /** setter comment*/
-    set prop1(val: number);
+    /**@accessor*/ prop1: number;
     /** overload signature1*/
     foo1(a: number): string;
     /** Overload signature 2*/