Fix: Remove definite assignment assertions from class property declaration files

internal/transformers/declarations/transform.go

@@ -727,11 +727,18 @@
 	if ast.IsPrivateIdentifier(input.Name()) {
 		return nil
 	}
+	// Remove definite assignment assertion (!) in declaration files
+	var postfixToken *ast.TokenNode
+	if input.PostfixToken != nil && input.PostfixToken.Kind == ast.KindExclamationToken {
+		postfixToken = nil
+	} else {
+		postfixToken = input.PostfixToken
+	}
 	return tx.Factory().UpdatePropertySignatureDeclaration(
 		input,
 		tx.ensureModifiers(input.AsNode()),
 		input.Name(),
-		input.PostfixToken,
+		postfixToken,
 		tx.ensureType(input.AsNode(), false),
 		tx.ensureNoInitializer(input.AsNode()), // TODO: possible strada bug (fixed here) - const property signatures never initialized
 	)
@@ -741,11 +748,18 @@
 	if ast.IsPrivateIdentifier(input.Name()) {
 		return nil
 	}
+	// Remove definite assignment assertion (!) in declaration files
+	var postfixToken *ast.TokenNode
+	if input.PostfixToken != nil && input.PostfixToken.Kind == ast.KindExclamationToken {
+		postfixToken = nil
+	} else {
+		postfixToken = input.PostfixToken
+	}
 	return tx.Factory().UpdatePropertyDeclaration(
 		input,
 		tx.ensureModifiers(input.AsNode()),
 		input.Name(),
-		input.PostfixToken,
+		postfixToken,
 		tx.ensureType(input.AsNode(), false),
 		tx.ensureNoInitializer(input.AsNode()),
 	)

testdata/baselines/reference/compiler/definiteAssignmentAssertionInDeclaration.js

@@ -0,0 +1,21 @@
+//// [tests/cases/compiler/definiteAssignmentAssertionInDeclaration.ts] ////
+
+//// [definiteAssignmentAssertionInDeclaration.ts]
+export class DbObject {
+    id!: string;
+}
+
+//// [definiteAssignmentAssertionInDeclaration.js]
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbObject = void 0;
+class DbObject {
+    id;
+}
+exports.DbObject = DbObject;
+
+
+//// [definiteAssignmentAssertionInDeclaration.d.ts]
+export declare class DbObject {
+    id: string;
+}

testdata/baselines/reference/compiler/definiteAssignmentAssertionInDeclaration.symbols

@@ -0,0 +1,9 @@
+//// [tests/cases/compiler/definiteAssignmentAssertionInDeclaration.ts] ////
+
+=== definiteAssignmentAssertionInDeclaration.ts ===
+export class DbObject {
+>DbObject : Symbol(DbObject, Decl(definiteAssignmentAssertionInDeclaration.ts, 0, 0))
+
+    id!: string;
+>id : Symbol(DbObject.id, Decl(definiteAssignmentAssertionInDeclaration.ts, 0, 23))
+}

testdata/baselines/reference/compiler/definiteAssignmentAssertionInDeclaration.types

@@ -0,0 +1,9 @@
+//// [tests/cases/compiler/definiteAssignmentAssertionInDeclaration.ts] ////
+
+=== definiteAssignmentAssertionInDeclaration.ts ===
+export class DbObject {
+>DbObject : DbObject
+
+    id!: string;
+>id : string
+}

testdata/baselines/reference/compiler/definiteAssignmentAssertionInDeclarationExtended.errors.txt

@@ -0,0 +1,19 @@
+definiteAssignmentAssertionInDeclarationExtended.ts(7,18): error TS1255: A definite assignment assertion '!' is not permitted in this context.
+
+
+==== definiteAssignmentAssertionInDeclarationExtended.ts (1 errors) ====
+    export class DbObject {
+        id!: string;
+        name?: string;
+        count: number = 0;
+        private secret!: string;
+        protected value!: number;
+        static config!: boolean;
+                     ~
+!!! error TS1255: A definite assignment assertion '!' is not permitted in this context.
+    }
+
+    export interface IConfig {
+        setting?: boolean; 
+        optionalSetting?: string;
+    }

testdata/baselines/reference/compiler/definiteAssignmentAssertionInDeclarationExtended.js

@@ -0,0 +1,45 @@
+//// [tests/cases/compiler/definiteAssignmentAssertionInDeclarationExtended.ts] ////
+
+//// [definiteAssignmentAssertionInDeclarationExtended.ts]
+export class DbObject {
+    id!: string;
+    name?: string;
+    count: number = 0;
+    private secret!: string;
+    protected value!: number;
+    static config!: boolean;
+}
+
+export interface IConfig {
+    setting?: boolean; 
+    optionalSetting?: string;
+}
+
+//// [definiteAssignmentAssertionInDeclarationExtended.js]
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbObject = void 0;
+class DbObject {
+    id;
+    name;
+    count = 0;
+    secret;
+    value;
+    static config;
+}
+exports.DbObject = DbObject;
+
+
+//// [definiteAssignmentAssertionInDeclarationExtended.d.ts]
+export declare class DbObject {
+    id: string;
+    name?: string;
+    count: number;
+    private secret;
+    protected value: number;
+    static config: boolean;
+}
+export interface IConfig {
+    setting?: boolean;
+    optionalSetting?: string;
+}

testdata/baselines/reference/compiler/definiteAssignmentAssertionInDeclarationExtended.symbols

@@ -0,0 +1,34 @@
+//// [tests/cases/compiler/definiteAssignmentAssertionInDeclarationExtended.ts] ////
+
+=== definiteAssignmentAssertionInDeclarationExtended.ts ===
+export class DbObject {
+>DbObject : Symbol(DbObject, Decl(definiteAssignmentAssertionInDeclarationExtended.ts, 0, 0))
+
+    id!: string;
+>id : Symbol(DbObject.id, Decl(definiteAssignmentAssertionInDeclarationExtended.ts, 0, 23))
+
+    name?: string;
+>name : Symbol(DbObject.name, Decl(definiteAssignmentAssertionInDeclarationExtended.ts, 1, 16))
+
+    count: number = 0;
+>count : Symbol(DbObject.count, Decl(definiteAssignmentAssertionInDeclarationExtended.ts, 2, 18))
+
+    private secret!: string;
+>secret : Symbol(DbObject.secret, Decl(definiteAssignmentAssertionInDeclarationExtended.ts, 3, 22))
+
+    protected value!: number;
+>value : Symbol(DbObject.value, Decl(definiteAssignmentAssertionInDeclarationExtended.ts, 4, 28))
+
+    static config!: boolean;
+>config : Symbol(DbObject.config, Decl(definiteAssignmentAssertionInDeclarationExtended.ts, 5, 29))
+}
+
+export interface IConfig {
+>IConfig : Symbol(IConfig, Decl(definiteAssignmentAssertionInDeclarationExtended.ts, 7, 1))
+
+    setting?: boolean; 
+>setting : Symbol(IConfig.setting, Decl(definiteAssignmentAssertionInDeclarationExtended.ts, 9, 26))
+
+    optionalSetting?: string;
+>optionalSetting : Symbol(IConfig.optionalSetting, Decl(definiteAssignmentAssertionInDeclarationExtended.ts, 10, 22))
+}

testdata/baselines/reference/compiler/definiteAssignmentAssertionInDeclarationExtended.types

@@ -0,0 +1,33 @@
+//// [tests/cases/compiler/definiteAssignmentAssertionInDeclarationExtended.ts] ////
+
+=== definiteAssignmentAssertionInDeclarationExtended.ts ===
+export class DbObject {
+>DbObject : DbObject
+
+    id!: string;
+>id : string
+
+    name?: string;
+>name : string | undefined
+
+    count: number = 0;
+>count : number
+>0 : 0
+
+    private secret!: string;
+>secret : string
+
+    protected value!: number;
+>value : number
+
+    static config!: boolean;
+>config : boolean
+}
+
+export interface IConfig {
+    setting?: boolean; 
+>setting : boolean | undefined
+
+    optionalSetting?: string;
+>optionalSetting : string | undefined
+}

testdata/baselines/reference/submodule/compiler/declarationEmitTypeofThisInClass.js

@@ -15,25 +15,6 @@ class Foo {
 
 //// [declarationEmitTypeofThisInClass.d.ts]
 declare class Foo {
-    foo!: string;
-    bar!: typeof this.foo; //Public property 'bar' of exported class has or is using private name 'this'.(4031)
+    foo: string;
+    bar: typeof this.foo; //Public property 'bar' of exported class has or is using private name 'this'.(4031)
 }
-
-
-//// [DtsFileErrors]
-
-
-declarationEmitTypeofThisInClass.d.ts(2,8): error TS1255: A definite assignment assertion '!' is not permitted in this context.
-declarationEmitTypeofThisInClass.d.ts(3,8): error TS1255: A definite assignment assertion '!' is not permitted in this context.
-
-
-==== declarationEmitTypeofThisInClass.d.ts (2 errors) ====
-    declare class Foo {
-        foo!: string;
-           ~
-!!! error TS1255: A definite assignment assertion '!' is not permitted in this context.
-        bar!: typeof this.foo; //Public property 'bar' of exported class has or is using private name 'this'.(4031)
-           ~
-!!! error TS1255: A definite assignment assertion '!' is not permitted in this context.
-    }
-

testdata/baselines/reference/submodule/compiler/declarationEmitTypeofThisInClass.js.diff

@@ -13,27 +13,7 @@
 
  //// [declarationEmitTypeofThisInClass.d.ts]
  declare class Foo {
--    foo: string;
+     foo: string;
 -    bar: typeof this.foo;
-+    foo!: string;
-+    bar!: typeof this.foo; //Public property 'bar' of exported class has or is using private name 'this'.(4031)
- }
-+
-+
-+//// [DtsFileErrors]
-+
-+
-+declarationEmitTypeofThisInClass.d.ts(2,8): error TS1255: A definite assignment assertion '!' is not permitted in this context.
-+declarationEmitTypeofThisInClass.d.ts(3,8): error TS1255: A definite assignment assertion '!' is not permitted in this context.
-+
-+
-+==== declarationEmitTypeofThisInClass.d.ts (2 errors) ====
-+    declare class Foo {
-+        foo!: string;
-+           ~
-+!!! error TS1255: A definite assignment assertion '!' is not permitted in this context.
-+        bar!: typeof this.foo; //Public property 'bar' of exported class has or is using private name 'this'.(4031)
-+           ~
-+!!! error TS1255: A definite assignment assertion '!' is not permitted in this context.
-+    }
-+    
++    bar: typeof this.foo; //Public property 'bar' of exported class has or is using private name 'this'.(4031)
+ }

testdata/baselines/reference/submodule/compiler/initializerWithThisPropertyAccess.js

@@ -77,7 +77,7 @@ declare class B extends A {
     x: number;
 }
 declare class C {
-    a!: number;
+    a: number;
     b: number;
 }
 // Repro from #37979

testdata/baselines/reference/submodule/compiler/initializerWithThisPropertyAccess.js.diff

@@ -56,12 +56,8 @@
      c: () => number;
      d: number;
      constructor();
-@@= skipped -46, +41 lines =@@
-     x: number;
- }
- declare class C {
--    a: number;
-+    a!: number;
+@@= skipped -49, +44 lines =@@
+     a: number;
      b: number;
  }
 +// Repro from #37979

testdata/baselines/reference/submodule/conformance/definiteAssignmentAssertions.js

@@ -143,28 +143,28 @@ function f4() {
 //// [definiteAssignmentAssertions.d.ts]
 // Suppress strict property initialization check
 declare class C1 {
-    a!: number;
+    a: number;
     b: string; // Error
 }
 // Suppress definite assignment check in constructor
 declare class C2 {
-    a!: number;
+    a: number;
     constructor();
 }
 // Definite assignment assertion requires type annotation, no initializer, no static modifier
 declare class C3 {
-    a!: number;
-    b!: number;
-    static c!: number;
-    d!: any;
+    a: number;
+    b: number;
+    static c: number;
+    d: any;
 }
 // Definite assignment assertion not permitted in ambient context
 declare class C4 {
-    a!: number;
+    a: number;
 }
 // Definite assignment assertion not permitted on abstract property
 declare abstract class C5 {
-    abstract a!: number;
+    abstract a: number;
 }
 // Suppress definite assignment check for variable
 declare function f1(): void;

testdata/baselines/reference/submodule/conformance/definiteAssignmentAssertions.js.diff

@@ -40,37 +40,29 @@
  //// [definiteAssignmentAssertions.d.ts]
 +// Suppress strict property initialization check
  declare class C1 {
--    a: number;
+     a: number;
 -    b: string;
-+    a!: number;
 +    b: string; // Error
  }
 +// Suppress definite assignment check in constructor
  declare class C2 {
--    a: number;
-+    a!: number;
+     a: number;
      constructor();
  }
 +// Definite assignment assertion requires type annotation, no initializer, no static modifier
  declare class C3 {
--    a: number;
--    b: number;
--    static c: number;
--    d: any;
-+    a!: number;
-+    b!: number;
-+    static c!: number;
-+    d!: any;
+     a: number;
+     b: number;
+     static c: number;
+     d: any;
  }
 +// Definite assignment assertion not permitted in ambient context
  declare class C4 {
--    a: number;
-+    a!: number;
+     a: number;
  }
 +// Definite assignment assertion not permitted on abstract property
  declare abstract class C5 {
--    abstract a: number;
-+    abstract a!: number;
+     abstract a: number;
  }
 +// Suppress definite assignment check for variable
  declare function f1(): void;

testdata/baselines/reference/submodule/conformance/importEqualsDeclaration.js

@@ -40,7 +40,7 @@ void type; // Ok
 
 //// [a.d.ts]
 declare class A {
-    a!: string;
+    a: string;
 }
 export = A;
 //// [b.d.ts]