Plumb through TokenFlagsSingleQuote; use for auto import quote detection (#1937)

Author: andrewbranch

internal/checker/nodebuilderimpl.go

@@ -532,7 +532,7 @@ func (b *nodeBuilderImpl) symbolToTypeNode(symbol *ast.Symbol, mask ast.SymbolFl
 				specifier = b.getSpecifierForModuleSymbol(chain[0], core.ModuleKindESNext)
 				attributes = b.f.NewImportAttributes(
 					ast.KindWithKeyword,
-					b.f.NewNodeList([]*ast.Node{b.f.NewImportAttribute(b.f.NewStringLiteral("resolution-mode"), b.f.NewStringLiteral("import"))}),
+					b.f.NewNodeList([]*ast.Node{b.f.NewImportAttribute(b.newStringLiteral("resolution-mode"), b.newStringLiteral("import"))}),
 					false,
 				)
 			}
@@ -561,7 +561,7 @@ func (b *nodeBuilderImpl) symbolToTypeNode(symbol *ast.Symbol, mask ast.SymbolFl
 					}
 					attributes = b.f.NewImportAttributes(
 						ast.KindWithKeyword,
-						b.f.NewNodeList([]*ast.Node{b.f.NewImportAttribute(b.f.NewStringLiteral("resolution-mode"), b.f.NewStringLiteral(modeStr))}),
+						b.f.NewNodeList([]*ast.Node{b.f.NewImportAttribute(b.newStringLiteral("resolution-mode"), b.newStringLiteral(modeStr))}),
 						false,
 					)
 				}
@@ -575,7 +575,7 @@ func (b *nodeBuilderImpl) symbolToTypeNode(symbol *ast.Symbol, mask ast.SymbolFl
 			}
 		}
 
-		lit := b.f.NewLiteralTypeNode(b.f.NewStringLiteral(specifier))
+		lit := b.f.NewLiteralTypeNode(b.newStringLiteral(specifier))
 		b.ctx.approximateLength += len(specifier) + 10 // specifier + import("")
 		if nonRootParts == nil || ast.IsEntityName(nonRootParts) {
 			if nonRootParts != nil {
@@ -692,12 +692,12 @@ func (b *nodeBuilderImpl) createAccessFromSymbolChain(chain []*ast.Symbol, index
 		if ast.IsIndexedAccessTypeNode(lhs) {
 			return b.f.NewIndexedAccessTypeNode(
 				lhs,
-				b.f.NewLiteralTypeNode(b.f.NewStringLiteral(symbolName)),
+				b.f.NewLiteralTypeNode(b.newStringLiteral(symbolName)),
 			)
 		}
 		return b.f.NewIndexedAccessTypeNode(
 			b.f.NewTypeReferenceNode(lhs, typeParameterNodes),
-			b.f.NewLiteralTypeNode(b.f.NewStringLiteral(symbolName)),
+			b.f.NewLiteralTypeNode(b.newStringLiteral(symbolName)),
 		)
 	}
 
@@ -736,7 +736,7 @@ func (b *nodeBuilderImpl) createExpressionFromSymbolChain(chain []*ast.Symbol, i
 	}
 
 	if startsWithSingleOrDoubleQuote(symbolName) && core.Some(symbol.Declarations, hasNonGlobalAugmentationExternalModuleSymbol) {
-		return b.f.NewStringLiteral(b.getSpecifierForModuleSymbol(symbol, core.ResolutionModeNone))
+		return b.newStringLiteral(b.getSpecifierForModuleSymbol(symbol, core.ResolutionModeNone))
 	}
 
 	if index == 0 || canUsePropertyAccess(symbolName) {
@@ -757,7 +757,7 @@ func (b *nodeBuilderImpl) createExpressionFromSymbolChain(chain []*ast.Symbol, i
 
 	var expression *ast.Expression
 	if startsWithSingleOrDoubleQuote(symbolName) && symbol.Flags&ast.SymbolFlagsEnumMember == 0 {
-		expression = b.f.NewStringLiteral(stringutil.UnquoteString(symbolName))
+		expression = b.newStringLiteral(stringutil.UnquoteString(symbolName))
 	} else if jsnum.FromString(symbolName).String() == symbolName {
 		// TODO: the follwing in strada would assert if the number is negative, but no such assertion exists here
 		// Moreover, what's even guaranteeing the name *isn't* -1 here anyway? Needs double-checking.
@@ -2089,7 +2089,7 @@ func (b *nodeBuilderImpl) trackComputedName(accessExpression *ast.Node, enclosin
 	}
 }
 
-func (b *nodeBuilderImpl) createPropertyNameNodeForIdentifierOrLiteral(name string, _singleQuote bool, stringNamed bool, isMethod bool) *ast.Node {
+func (b *nodeBuilderImpl) createPropertyNameNodeForIdentifierOrLiteral(name string, singleQuote bool, stringNamed bool, isMethod bool) *ast.Node {
 	isMethodNamedNew := isMethod && name == "new"
 	if !isMethodNamedNew && scanner.IsIdentifierText(name, core.LanguageVariantStandard) {
 		return b.f.NewIdentifier(name)
@@ -2098,7 +2098,9 @@ func (b *nodeBuilderImpl) createPropertyNameNodeForIdentifierOrLiteral(name stri
 		return b.f.NewNumericLiteral(name)
 	}
 	result := b.f.NewStringLiteral(name)
-	// !!! TODO: set singleQuote
+	if singleQuote {
+		result.AsStringLiteral().TokenFlags |= ast.TokenFlagsSingleQuote
+	}
 	return result
 }
 
@@ -2119,10 +2121,8 @@ func (b *nodeBuilderImpl) isStringNamed(d *ast.Declaration) bool {
 }
 
 func (b *nodeBuilderImpl) isSingleQuotedStringNamed(d *ast.Declaration) bool {
-	return false // !!!
-	// TODO: actually support single-quote-style-maintenance
-	// name := ast.GetNameOfDeclaration(d)
-	// return name != nil && ast.IsStringLiteral(name) && (name.AsStringLiteral().SingleQuote || !nodeIsSynthesized(name) && startsWith(getTextOfNode(name, false /*includeTrivia*/), "'"))
+	name := ast.GetNameOfDeclaration(d)
+	return name != nil && ast.IsStringLiteral(name) && name.AsStringLiteral().TokenFlags&ast.TokenFlagsSingleQuote != 0
 }
 
 func (b *nodeBuilderImpl) getPropertyNameNodeForSymbol(symbol *ast.Symbol) *ast.Node {
@@ -2164,8 +2164,11 @@ func (b *nodeBuilderImpl) getPropertyNameNodeForSymbolFromNameType(symbol *ast.S
 			name = nameType.AsLiteralType().value.(string)
 		}
 		if !scanner.IsIdentifierText(name, core.LanguageVariantStandard) && (stringNamed || !isNumericLiteralName(name)) {
-			// !!! TODO: set singleQuote
-			return b.f.NewStringLiteral(name)
+			node := b.f.NewStringLiteral(name)
+			if singleQuote {
+				node.AsStringLiteral().TokenFlags |= ast.TokenFlagsSingleQuote
+			}
+			return node
 		}
 		if isNumericLiteralName(name) && name[0] == '-' {
 			return b.f.NewComputedPropertyName(b.f.NewPrefixUnaryExpression(ast.KindMinusToken, b.f.NewNumericLiteral(name[1:])))
@@ -2881,9 +2884,9 @@ func (b *nodeBuilderImpl) typeToTypeNode(t *Type) *ast.TypeNode {
 			if ast.IsImportTypeNode(parentName) {
 				parentName.AsImportTypeNode().IsTypeOf = true
 				// mutably update, node is freshly manufactured anyhow
-				return b.f.NewIndexedAccessTypeNode(parentName, b.f.NewLiteralTypeNode(b.f.NewStringLiteral(memberName)))
+				return b.f.NewIndexedAccessTypeNode(parentName, b.f.NewLiteralTypeNode(b.newStringLiteral(memberName)))
 			} else if ast.IsTypeReferenceNode(parentName) {
-				return b.f.NewIndexedAccessTypeNode(b.f.NewTypeQueryNode(parentName.AsTypeReferenceNode().TypeName, nil), b.f.NewLiteralTypeNode(b.f.NewStringLiteral(memberName)))
+				return b.f.NewIndexedAccessTypeNode(b.f.NewTypeQueryNode(parentName.AsTypeReferenceNode().TypeName, nil), b.f.NewLiteralTypeNode(b.newStringLiteral(memberName)))
 			} else {
 				panic("Unhandled type node kind returned from `symbolToTypeNode`.")
 			}
@@ -2892,7 +2895,7 @@ func (b *nodeBuilderImpl) typeToTypeNode(t *Type) *ast.TypeNode {
 	}
 	if t.flags&TypeFlagsStringLiteral != 0 {
 		b.ctx.approximateLength += len(t.AsLiteralType().value.(string)) + 2
-		lit := b.f.NewStringLiteral(t.AsLiteralType().value.(string) /*, b.flags&nodebuilder.FlagsUseSingleQuotesForStringLiteralType != 0*/)
+		lit := b.newStringLiteral(t.AsLiteralType().value.(string))
 		b.e.AddEmitFlags(lit, printer.EFNoAsciiEscaping)
 		return b.f.NewLiteralTypeNode(lit)
 	}
@@ -3105,6 +3108,14 @@ func (b *nodeBuilderImpl) typeToTypeNode(t *Type) *ast.TypeNode {
 	panic("Should be unreachable.")
 }
 
+func (b *nodeBuilderImpl) newStringLiteral(text string) *ast.Node {
+	node := b.f.NewStringLiteral(text)
+	if b.ctx.flags&nodebuilder.FlagsUseSingleQuotesForStringLiteralType != 0 {
+		node.AsStringLiteral().TokenFlags |= ast.TokenFlagsSingleQuote
+	}
+	return node
+}
+
 // Direct serialization core functions for types, type aliases, and symbols
 
 func (t *TypeAlias) ToTypeReferenceNode(b *nodeBuilderImpl) *ast.Node {

internal/fourslash/tests/autoImportQuoteDetection_test.go

@@ -0,0 +1,33 @@
+package fourslash_test
+
+import (
+	"testing"
+
+	"github.com/microsoft/typescript-go/internal/fourslash"
+	. "github.com/microsoft/typescript-go/internal/fourslash/tests/util"
+	"github.com/microsoft/typescript-go/internal/testutil"
+)
+
+func TestAutoImportQuoteDetection(t *testing.T) {
+	t.Parallel()
+
+	defer testutil.RecoverAndFail(t, "Panic on fourslash test")
+	const content = `// @module: esnext
+// @Filename: /a.ts
+export const foo = 0;
+// @Filename: /b.ts
+import {} from 'node:path';
+
+fo/**/`
+	f := fourslash.NewFourslash(t, nil /*capabilities*/, content)
+	f.GoToMarker(t, "")
+	f.VerifyApplyCodeActionFromCompletion(t, PtrTo(""), &fourslash.ApplyCodeActionFromCompletionOptions{
+		Name:        "foo",
+		Source:      "./a",
+		Description: "Add import from \"./a\"",
+		NewFileContent: PtrTo(`import {} from 'node:path';
+import { foo } from './a';
+
+fo`),
+	})
+}

internal/ls/autoimportfixes.go

@@ -265,13 +265,16 @@ func (ct *changeTracker) makeImport(defaultImport *ast.IdentifierNode, namedImpo
 
 func (ct *changeTracker) getNewImports(
 	moduleSpecifier string,
-	// quotePreference quotePreference, // !!! quotePreference
+	quotePreference quotePreference,
 	defaultImport *Import,
 	namedImports []*Import,
 	namespaceLikeImport *Import, // { importKind: ImportKind.CommonJS | ImportKind.Namespace; }
 	compilerOptions *core.CompilerOptions,
 ) []*ast.Statement {
 	moduleSpecifierStringLiteral := ct.NodeFactory.NewStringLiteral(moduleSpecifier)
+	if quotePreference == quotePreferenceSingle {
+		moduleSpecifierStringLiteral.AsStringLiteral().TokenFlags |= ast.TokenFlagsSingleQuote
+	}
 	var statements []*ast.Statement // []AnyImportSyntax
 	if defaultImport != nil || len(namedImports) > 0 {
 		// `verbatimModuleSyntax` should prefer top-level `import type` -

internal/ls/autoimports.go

@@ -1412,7 +1412,7 @@ func (l *LanguageService) codeActionForFixWorker(
 		if fix.useRequire {
 			declarations = changeTracker.getNewRequires(fix.moduleSpecifier, defaultImport, namedImports, namespaceLikeImport, l.GetProgram().Options())
 		} else {
-			declarations = changeTracker.getNewImports(fix.moduleSpecifier, defaultImport, namedImports, namespaceLikeImport, l.GetProgram().Options())
+			declarations = changeTracker.getNewImports(fix.moduleSpecifier, getQuotePreference(sourceFile, l.UserPreferences()), defaultImport, namedImports, namespaceLikeImport, l.GetProgram().Options())
 		}
 
 		changeTracker.insertImports(

internal/ls/utilities.go

@@ -468,8 +468,27 @@ const (
 	quotePreferenceDouble
 )
 
-// !!!
-func getQuotePreference(file *ast.SourceFile, preferences *UserPreferences) quotePreference {
+func quotePreferenceFromString(str *ast.StringLiteral) quotePreference {
+	if str.TokenFlags&ast.TokenFlagsSingleQuote != 0 {
+		return quotePreferenceSingle
+	}
+	return quotePreferenceDouble
+}
+
+func getQuotePreference(sourceFile *ast.SourceFile, preferences *UserPreferences) quotePreference {
+	if preferences.QuotePreference != "" && preferences.QuotePreference != "auto" {
+		if preferences.QuotePreference == "single" {
+			return quotePreferenceSingle
+		}
+		return quotePreferenceDouble
+	}
+	// ignore synthetic import added when importHelpers: true
+	firstModuleSpecifier := core.Find(sourceFile.Imports(), func(n *ast.Node) bool {
+		return ast.IsStringLiteral(n) && !ast.NodeIsSynthesized(n.Parent)
+	})
+	if firstModuleSpecifier != nil {
+		return quotePreferenceFromString(firstModuleSpecifier.AsStringLiteral())
+	}
 	return quotePreferenceDouble
 }
 

internal/scanner/scanner.go

@@ -1455,6 +1455,9 @@ func (s *Scanner) scanIdentifierParts() string {
 
 func (s *Scanner) scanString(jsxAttributeString bool) string {
 	quote := s.char()
+	if quote == '\'' {
+		s.tokenFlags |= ast.TokenFlagsSingleQuote
+	}
 	s.pos++
 	// Fast path for simple strings without escape sequences.
 	strLen := strings.IndexRune(s.text[s.pos:], quote)

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

@@ -12,5 +12,5 @@ exports.f = ((arg) => arg)({ '0': 0 }); // Original prop uses string syntax
 
 //// [declarationEmitMappedTypePropertyFromNumericStringKey.d.ts]
 export declare const f: {
-    "0": string | number;
+    '0': string | number;
 };

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

@@ -2,13 +2,13 @@
 
 === declarationEmitMappedTypePropertyFromNumericStringKey.ts ===
 export const f = (<T>(arg: {[K in keyof T]: T[K] | string}) => arg)({'0': 0}); // Original prop uses string syntax
->f : { "0": string | number; }
->(<T>(arg: {[K in keyof T]: T[K] | string}) => arg)({'0': 0}) : { "0": string | number; }
+>f : { '0': string | number; }
+>(<T>(arg: {[K in keyof T]: T[K] | string}) => arg)({'0': 0}) : { '0': string | number; }
 >(<T>(arg: {[K in keyof T]: T[K] | string}) => arg) : <T>(arg: { [K in keyof T]: string | T[K]; }) => { [K in keyof T]: string | T[K]; }
 ><T>(arg: {[K in keyof T]: T[K] | string}) => arg : <T>(arg: { [K in keyof T]: string | T[K]; }) => { [K in keyof T]: string | T[K]; }
 >arg : { [K in keyof T]: string | T[K]; }
 >arg : { [K in keyof T]: string | T[K]; }
->{'0': 0} : { "0": number; }
+>{'0': 0} : { '0': number; }
 >'0' : number
 >0 : 0
 

testdata/baselines/reference/submodule/compiler/declarationEmitMappedTypePropertyFromNumericStringKey.types

@@ -1,22 +1,13 @@
 --- old.declarationEmitMappedTypePropertyFromNumericStringKey.types
 +++ new.declarationEmitMappedTypePropertyFromNumericStringKey.types
-@@= skipped -1, +1 lines =@@
-
- === declarationEmitMappedTypePropertyFromNumericStringKey.ts ===
+@@= skipped -3, +3 lines =@@
  export const f = (<T>(arg: {[K in keyof T]: T[K] | string}) => arg)({'0': 0}); // Original prop uses string syntax
-->f : { '0': string | number; }
-->(<T>(arg: {[K in keyof T]: T[K] | string}) => arg)({'0': 0}) : { '0': string | number; }
+ >f : { '0': string | number; }
+ >(<T>(arg: {[K in keyof T]: T[K] | string}) => arg)({'0': 0}) : { '0': string | number; }
 ->(<T>(arg: {[K in keyof T]: T[K] | string}) => arg) : <T>(arg: { [K in keyof T]: T[K] | string; }) => { [K in keyof T]: string | T[K]; }
 -><T>(arg: {[K in keyof T]: T[K] | string}) => arg : <T>(arg: { [K in keyof T]: T[K] | string; }) => { [K in keyof T]: string | T[K]; }
-->arg : { [K in keyof T]: string | T[K]; }
-->arg : { [K in keyof T]: string | T[K]; }
-->{'0': 0} : { '0': number; }
-+>f : { "0": string | number; }
-+>(<T>(arg: {[K in keyof T]: T[K] | string}) => arg)({'0': 0}) : { "0": string | number; }
 +>(<T>(arg: {[K in keyof T]: T[K] | string}) => arg) : <T>(arg: { [K in keyof T]: string | T[K]; }) => { [K in keyof T]: string | T[K]; }
 +><T>(arg: {[K in keyof T]: T[K] | string}) => arg : <T>(arg: { [K in keyof T]: string | T[K]; }) => { [K in keyof T]: string | T[K]; }
-+>arg : { [K in keyof T]: string | T[K]; }
-+>arg : { [K in keyof T]: string | T[K]; }
-+>{'0': 0} : { "0": number; }
- >'0' : number
- >0 : 0
+ >arg : { [K in keyof T]: string | T[K]; }
+ >arg : { [K in keyof T]: string | T[K]; }
+ >{'0': 0} : { '0': number; }