Do not print typeof operator for Symbol types

external-declarations/fixer-test/expected/function_signatures_objects.ts

@@ -4,12 +4,12 @@ function foo() {
 export const a = {
     value: 0,
     array: [1, 2, 3],
-    fn(value: string): number { return 0; }
+    fn(value: string): number { return 0; },
 } as const;
 const b = {
     value: 0,
     array: [1, 2, 3],
-    fn(value: string): number { return 0; }
+    fn(value: string): number { return 0; },
 } as const;
 export const c: {
     value: number;
@@ -18,12 +18,12 @@ export const c: {
 } = {
     value: 0,
     array: [1, 2, 3],
-    fn(value: string): number { return 0; }
+    fn(value: string): number { return 0; },
 };
 const d = {
     value: 0,
     array: [1, 2, 3],
-    fn(value: string): number { return 0; }
+    fn(value: string): number { return 0; },
 };
 export const e: {
     readonly value: number;
@@ -32,12 +32,12 @@ export const e: {
 } = {
     value: foo(),
     array: [1, 2, 3],
-    fn(value: string): number { return 0; }
+    fn(value: string): number { return 0; },
 } as const;
 const f = {
     value: foo(),
     array: [1, 2, 3],
-    fn(value: string): number { return 0; }
+    fn(value: string): number { return 0; },
 } as const;
 export const g: {
     value: number;
@@ -46,10 +46,10 @@ export const g: {
 } = {
     value: foo(),
     array: [1, 2, 3],
-    fn(value: string): number { return 0; }
+    fn(value: string): number { return 0; },
 };
 const h = {
     value: foo(),
     array: [1, 2, 3],
-    fn(value: string): number { return 0; }
+    fn(value: string): number { return 0; },
 };

external-declarations/fixer-test/expected/object_literals.ts

@@ -1,19 +1,19 @@
 export const a = {
     value: 0,
-    array: [1, 2, 3]
+    array: [1, 2, 3],
 } as const;
 const b = {
     value: 0,
-    array: [1, 2, 3]
+    array: [1, 2, 3],
 } as const;
 export const c: {
     value: number;
     array: number[];
 } = {
     value: 0,
-    array: [1, 2, 3]
+    array: [1, 2, 3],
 };
 const d = {
     value: 0,
-    array: [1, 2, 3]
+    array: [1, 2, 3],
 };

external-declarations/fixer-test/expected/symbols.ts

@@ -0,0 +1,14 @@
+export const a: unique symbol = Symbol();
+export function foo(): symbol {
+    return Symbol();
+}
+export const z: {
+    z: symbol;
+} = {
+    z: Symbol(),
+};
+export const z2: {
+    readonly z: symbol;
+} = {
+    z: Symbol()
+} as const;

external-declarations/fixer-test/source/symbols.ts

@@ -0,0 +1,14 @@
+
+export const a = Symbol();
+
+export function foo() {
+    return Symbol();
+}
+
+export const z = {
+    z: Symbol(),
+};
+
+export const z2 = {
+    z: Symbol()
+} as const;

external-declarations/src/code-mod/code-transform.ts

@@ -2,14 +2,14 @@ import * as ts from "typescript";
 
 import { SymbolTracker } from "../compiler/types";
 
-const declarationEmitNodeBuilderFlags =
-    ts.NodeBuilderFlags.MultilineObjectLiterals |
-    ts.NodeBuilderFlags.WriteClassExpressionAsTypeLiteral |
-    ts.NodeBuilderFlags.UseTypeOfFunction |
-    ts.NodeBuilderFlags.UseStructuralFallback |
-    ts.NodeBuilderFlags.AllowEmptyTuple |
-    ts.NodeBuilderFlags.GenerateNamesForShadowedTypeParams |
-    ts.NodeBuilderFlags.NoTruncation;
+const declarationEmitNodeBuilderFlags = ts.NodeBuilderFlags.MultilineObjectLiterals
+    | ts.NodeBuilderFlags.WriteClassExpressionAsTypeLiteral
+    | ts.NodeBuilderFlags.UseTypeOfFunction
+    | ts.NodeBuilderFlags.UseStructuralFallback
+    | ts.NodeBuilderFlags.AllowEmptyTuple
+    | ts.NodeBuilderFlags.GenerateNamesForShadowedTypeParams
+    | ts.NodeBuilderFlags.NoTruncation
+    | ts.NodeBuilderFlags.AllowUniqueESSymbolType;
 
 function tryGetReturnType(typeChecker: ts.TypeChecker, node: ts.SignatureDeclaration): ts.Type | undefined {
     const signature = typeChecker.getSignatureFromDeclaration(node);

external-declarations/src/code-mod/fixer-test.ts

@@ -84,7 +84,7 @@ async function main() {
         const testFile = normalizePath(allTests[count].file);
         const caseData = await loadTestCase(testFile);
 
-        const settings: ts.CompilerOptions = {};
+        const settings: ts.CompilerOptions = { target: ts.ScriptTarget.ES2019 };
         setCompilerOptionsFromHarnessSetting(caseData.settings, settings);
 
         function createHarnessTestFile(lastUnit: TestUnitData): TestFile {

src/services/codefixes/fixMissingTypeAnnotationOnExports.ts

@@ -63,14 +63,14 @@ const canHaveExplicitTypeAnnotation = new Set<SyntaxKind>([
     SyntaxKind.ArrayBindingPattern,
 ]);
 
-const declarationEmitNodeBuilderFlags =
-    NodeBuilderFlags.MultilineObjectLiterals |
-    NodeBuilderFlags.WriteClassExpressionAsTypeLiteral |
-    NodeBuilderFlags.UseTypeOfFunction |
-    NodeBuilderFlags.UseStructuralFallback |
-    NodeBuilderFlags.AllowEmptyTuple |
-    NodeBuilderFlags.GenerateNamesForShadowedTypeParams |
-    NodeBuilderFlags.NoTruncation;
+const declarationEmitNodeBuilderFlags = NodeBuilderFlags.MultilineObjectLiterals
+    | NodeBuilderFlags.WriteClassExpressionAsTypeLiteral
+    | NodeBuilderFlags.UseTypeOfFunction
+    | NodeBuilderFlags.UseStructuralFallback
+    | NodeBuilderFlags.AllowEmptyTuple
+    | NodeBuilderFlags.GenerateNamesForShadowedTypeParams
+    | NodeBuilderFlags.NoTruncation
+    | NodeBuilderFlags.AllowUniqueESSymbolType;
 
 registerCodeFix({
     errorCodes,

tests/cases/fourslash/codeFixMissingTypeAnnotationOnExports18.ts

@@ -10,10 +10,9 @@ verify.codeFixAvailable([
     { description: ts.Diagnostics.Declaration_emit_for_this_file_requires_type_resolution_An_explicit_type_annotation_may_unblock_declaration_emit.message }
 ]);
 
-// TODO: the typeof operator here is wrong.
 verify.codeFix({
     description: ts.Diagnostics.Declaration_emit_for_this_file_requires_type_resolution_An_explicit_type_annotation_may_unblock_declaration_emit.message,
     index: 0,
     newFileContent:
-`export const a: typeof a = Symbol();`
+`export const a: unique symbol = Symbol();`
 });

tests/cases/fourslash/codeFixMissingTypeAnnotationOnExports21.ts

@@ -0,0 +1,23 @@
+/// <reference path='fourslash.ts'/>
+
+// @isolatedDeclarations: true
+// @declaration: true
+// @lib: es2019
+//// export const a = {
+////    z: Symbol()
+//// } as const;
+
+verify.codeFixAvailable([
+    { description: ts.Diagnostics.Declaration_emit_for_this_file_requires_type_resolution_An_explicit_type_annotation_may_unblock_declaration_emit.message }
+]);
+
+verify.codeFix({
+    description: ts.Diagnostics.Declaration_emit_for_this_file_requires_type_resolution_An_explicit_type_annotation_may_unblock_declaration_emit.message,
+    index: 0,
+    newFileContent:
+`export const a: {
+        readonly z: symbol;
+    } = {
+        z: Symbol()
+    } as const;`
+});

tests/cases/fourslash/codeFixMissingTypeAnnotationOnExports22.ts

@@ -0,0 +1,21 @@
+/// <reference path='fourslash.ts'/>
+
+// @isolatedDeclarations: true
+// @declaration: true
+// @lib: es2019
+//// export function foo () {
+////     return Symbol();
+//// }
+
+verify.codeFixAvailable([
+    { description: ts.Diagnostics.Declaration_emit_for_this_file_requires_type_resolution_An_explicit_type_annotation_may_unblock_declaration_emit.message }
+]);
+
+verify.codeFix({
+    description: ts.Diagnostics.Declaration_emit_for_this_file_requires_type_resolution_An_explicit_type_annotation_may_unblock_declaration_emit.message,
+    index: 0,
+    newFileContent:
+`export function foo(): symbol {
+    return Symbol();
+}`
+});