egor3f/kittenipc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

remove unused packages

Browse Source
This commit is contained in:
Egor Aristov 2025-10-15 19:27:23 +03:00
parent 2c8c81a24b
commit 02d5c2ae60
Signed by: egor3f
GPG Key ID: 40482A264AAEC85F
13 changed files with 0 additions and 4285 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
kitcom/internal/tsgo/format/README.md
View File

@ -1,26 +0,0 @@
# How does TypeScript formatting work?
To format code you need to have a formatting context and a `SourceFile`. The formatting context contains
all user settings like tab size, newline character, etc.
The end result of formatting is represented by TextChange objects which hold the new string content, and
the text to replace it with.
## Internals
Most of the exposed APIs internally are `Format*` and they all set up and configure `FormatSpan` which could be considered the root call for formatting. Span in this case refers to the range of
the sourcefile which should be formatted.
The formatSpan then uses a scanner (either with or without JSX support) which starts at the highest
node the covers the span of text and recurses down through the node's children.
As it recurses, `processNode` is called on the children setting the indentation is decided and passed
through into each of that node's children.
The meat of formatting decisions is made via `processPair`, the pair here being the current node and the previous node. `processPair` which mutates the formatting context to represent the current place in the scanner and requests a set of rules which can be applied to the items via `createRulesMap`.
There are a lot of rules, which you can find in [rules.ts](./rules.ts) each one has a left and right reference to nodes or token ranges and note of what action should be applied by the formatter.
### Where is this used?
The formatter is used mainly from any language service operation that inserts or modifies code. The formatter is not exported publicly, and so all usage can only come through the language server.

185
kitcom/internal/tsgo/format/api.go
View File

@ -1,185 +0,0 @@
package format
import (
"context"
"unicode/utf8"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/ast"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/core"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/scanner"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/stringutil"
)
type FormatRequestKind int
const (
FormatRequestKindFormatDocument FormatRequestKind = iota
FormatRequestKindFormatSelection
FormatRequestKindFormatOnEnter
FormatRequestKindFormatOnSemicolon
FormatRequestKindFormatOnOpeningCurlyBrace
FormatRequestKindFormatOnClosingCurlyBrace
)
type formatContextKey int
const (
formatOptionsKey formatContextKey = iota
formatNewlineKey
)
func WithFormatCodeSettings(ctx context.Context, options *FormatCodeSettings, newLine string) context.Context {
ctx = context.WithValue(ctx, formatOptionsKey, options)
ctx = context.WithValue(ctx, formatNewlineKey, newLine)
// In strada, the rules map was both globally cached *and* cached into the context, for some reason. We skip that here and just use the global one.
return ctx
}
func GetFormatCodeSettingsFromContext(ctx context.Context) *FormatCodeSettings {
opt := ctx.Value(formatOptionsKey).(*FormatCodeSettings)
return opt
}
func GetNewLineOrDefaultFromContext(ctx context.Context) string { // TODO: Move into broader LS - more than just the formatter uses the newline editor setting/host new line
opt := GetFormatCodeSettingsFromContext(ctx)
if opt != nil && len(opt.NewLineCharacter) > 0 {
return opt.NewLineCharacter
}
host := ctx.Value(formatNewlineKey).(string)
if len(host) > 0 {
return host
}
return "\n"
}
func FormatSpan(ctx context.Context, span core.TextRange, file *ast.SourceFile, kind FormatRequestKind) []core.TextChange {
// find the smallest node that fully wraps the range and compute the initial indentation for the node
enclosingNode := findEnclosingNode(span, file)
opts := GetFormatCodeSettingsFromContext(ctx)
return newFormattingScanner(
file.Text(),
file.LanguageVariant,
getScanStartPosition(enclosingNode, span, file),
span.End(),
newFormatSpanWorker(
ctx,
span,
enclosingNode,
GetIndentationForNode(enclosingNode, &span, file, opts),
getOwnOrInheritedDelta(enclosingNode, opts, file),
kind,
prepareRangeContainsErrorFunction(file.Diagnostics(), span),
file,
),
)
}
func FormatNodeGivenIndentation(ctx context.Context, node *ast.Node, file *ast.SourceFile, languageVariant core.LanguageVariant, initialIndentation int, delta int) []core.TextChange {
textRange := core.NewTextRange(node.Pos(), node.End())
return newFormattingScanner(
file.Text(),
languageVariant,
textRange.Pos(),
textRange.End(),
newFormatSpanWorker(
ctx,
textRange,
node,
initialIndentation,
delta,
FormatRequestKindFormatSelection,
func(core.TextRange) bool { return false }, // assume that node does not have any errors
file,
))
}
func formatNodeLines(ctx context.Context, sourceFile *ast.SourceFile, node *ast.Node, requestKind FormatRequestKind) []core.TextChange {
if node == nil {
return nil
}
tokenStart := scanner.GetTokenPosOfNode(node, sourceFile, false)
lineStart := GetLineStartPositionForPosition(tokenStart, sourceFile)
span := core.NewTextRange(lineStart, node.End())
return FormatSpan(ctx, span, sourceFile, requestKind)
}
func FormatDocument(ctx context.Context, sourceFile *ast.SourceFile) []core.TextChange {
return FormatSpan(ctx, core.NewTextRange(0, sourceFile.End()), sourceFile, FormatRequestKindFormatDocument)
}
func FormatSelection(ctx context.Context, sourceFile *ast.SourceFile, start int, end int) []core.TextChange {
return FormatSpan(ctx, core.NewTextRange(GetLineStartPositionForPosition(start, sourceFile), end), sourceFile, FormatRequestKindFormatSelection)
}
func FormatOnOpeningCurly(ctx context.Context, sourceFile *ast.SourceFile, position int) []core.TextChange {
openingCurly := findImmediatelyPrecedingTokenOfKind(position, ast.KindOpenBraceToken, sourceFile)
if openingCurly == nil {
return nil
}
curlyBraceRange := openingCurly.Parent
outermostNode := findOutermostNodeWithinListLevel(curlyBraceRange)
/**
* We limit the span to end at the opening curly to handle the case where
* the brace matched to that just typed will be incorrect after further edits.
* For example, we could type the opening curly for the following method
* body without brace-matching activated:
* ```
* class C {
* foo()
* }
* ```
* and we wouldn't want to move the closing brace.
*/
textRange := core.NewTextRange(GetLineStartPositionForPosition(scanner.GetTokenPosOfNode(outermostNode, sourceFile, false), sourceFile), position)
return FormatSpan(ctx, textRange, sourceFile, FormatRequestKindFormatOnOpeningCurlyBrace)
}
func FormatOnClosingCurly(ctx context.Context, sourceFile *ast.SourceFile, position int) []core.TextChange {
precedingToken := findImmediatelyPrecedingTokenOfKind(position, ast.KindCloseBraceToken, sourceFile)
return formatNodeLines(ctx, sourceFile, findOutermostNodeWithinListLevel(precedingToken), FormatRequestKindFormatOnClosingCurlyBrace)
}
func FormatOnSemicolon(ctx context.Context, sourceFile *ast.SourceFile, position int) []core.TextChange {
semicolon := findImmediatelyPrecedingTokenOfKind(position, ast.KindSemicolonToken, sourceFile)
return formatNodeLines(ctx, sourceFile, findOutermostNodeWithinListLevel(semicolon), FormatRequestKindFormatOnSemicolon)
}
func FormatOnEnter(ctx context.Context, sourceFile *ast.SourceFile, position int) []core.TextChange {
line, _ := scanner.GetECMALineAndCharacterOfPosition(sourceFile, position)
if line == 0 {
return nil
}
// get start position for the previous line
startPos := int(scanner.GetECMALineStarts(sourceFile)[line-1])
// After the enter key, the cursor is now at a new line. The new line may or may not contain non-whitespace characters.
// If the new line has only whitespaces, we won't want to format this line, because that would remove the indentation as
// trailing whitespaces. So the end of the formatting span should be the later one between:
// 1. the end of the previous line
// 2. the last non-whitespace character in the current line
endOfFormatSpan := scanner.GetECMAEndLinePosition(sourceFile, line)
for endOfFormatSpan > startPos {
ch, s := utf8.DecodeRuneInString(sourceFile.Text()[endOfFormatSpan:])
if s == 0 || stringutil.IsWhiteSpaceSingleLine(ch) { // on multibyte character keep backing up
endOfFormatSpan--
continue
}
break
}
// if the character at the end of the span is a line break, we shouldn't include it, because it indicates we don't want to
// touch the current line at all. Also, on some OSes the line break consists of two characters (\r\n), we should test if the
// previous character before the end of format span is line break character as well.
ch, _ := utf8.DecodeRuneInString(sourceFile.Text()[endOfFormatSpan:])
if stringutil.IsLineBreak(ch) {
endOfFormatSpan--
}
span := core.NewTextRange(
startPos,
// end value is exclusive so add 1 to the result
endOfFormatSpan+1,
)
return FormatSpan(ctx, span, sourceFile, FormatRequestKindFormatOnEnter)
}

114
kitcom/internal/tsgo/format/api_test.go
View File

@ -1,114 +0,0 @@
package format_test
import (
"os"
"path/filepath"
"strings"
"testing"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/ast"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/core"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/format"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/parser"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/printer"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/repo"
"gotest.tools/v3/assert"
)
func applyBulkEdits(text string, edits []core.TextChange) string {
b := strings.Builder{}
b.Grow(len(text))
lastEnd := 0
for _, e := range edits {
start := e.TextRange.Pos()
if start != lastEnd {
b.WriteString(text[lastEnd:e.TextRange.Pos()])
}
b.WriteString(e.NewText)
lastEnd = e.TextRange.End()
}
b.WriteString(text[lastEnd:])
return b.String()
}
func TestFormat(t *testing.T) {
t.Parallel()
t.Run("format checker.ts", func(t *testing.T) {
t.Parallel()
ctx := format.WithFormatCodeSettings(t.Context(), &format.FormatCodeSettings{
EditorSettings: format.EditorSettings{
TabSize: 4,
IndentSize: 4,
BaseIndentSize: 4,
NewLineCharacter: "\n",
ConvertTabsToSpaces: true,
IndentStyle: format.IndentStyleSmart,
TrimTrailingWhitespace: true,
},
InsertSpaceBeforeTypeAnnotation: core.TSTrue,
}, "\n")
repo.SkipIfNoTypeScriptSubmodule(t)
filePath := filepath.Join(repo.TypeScriptSubmodulePath, "src/compiler/checker.ts")
fileContent, err := os.ReadFile(filePath)
assert.NilError(t, err)
text := string(fileContent)
sourceFile := parser.ParseSourceFile(ast.SourceFileParseOptions{
FileName: "/checker.ts",
Path: "/checker.ts",
}, text, core.ScriptKindTS)
edits := format.FormatDocument(ctx, sourceFile)
newText := applyBulkEdits(text, edits)
assert.Assert(t, len(newText) > 0)
assert.Assert(t, text != newText)
})
}
func BenchmarkFormat(b *testing.B) {
ctx := format.WithFormatCodeSettings(b.Context(), &format.FormatCodeSettings{
EditorSettings: format.EditorSettings{
TabSize: 4,
IndentSize: 4,
BaseIndentSize: 4,
NewLineCharacter: "\n",
ConvertTabsToSpaces: true,
IndentStyle: format.IndentStyleSmart,
TrimTrailingWhitespace: true,
},
InsertSpaceBeforeTypeAnnotation: core.TSTrue,
}, "\n")
repo.SkipIfNoTypeScriptSubmodule(b)
filePath := filepath.Join(repo.TypeScriptSubmodulePath, "src/compiler/checker.ts")
fileContent, err := os.ReadFile(filePath)
assert.NilError(b, err)
text := string(fileContent)
sourceFile := parser.ParseSourceFile(ast.SourceFileParseOptions{
FileName: "/checker.ts",
Path: "/checker.ts",
}, text, core.ScriptKindTS)
b.Run("format checker.ts", func(b *testing.B) {
for b.Loop() {
edits := format.FormatDocument(ctx, sourceFile)
newText := applyBulkEdits(text, edits)
assert.Assert(b, len(newText) > 0)
}
})
b.Run("format checker.ts (no edit application)", func(b *testing.B) { // for comparison (how long does applying many edits take?)
for b.Loop() {
edits := format.FormatDocument(ctx, sourceFile)
assert.Assert(b, len(edits) > 0)
}
})
p := printer.NewPrinter(printer.PrinterOptions{}, printer.PrintHandlers{}, printer.NewEmitContext())
b.Run("pretty print checker.ts", func(b *testing.B) { // for comparison
for b.Loop() {
newText := p.EmitSourceFile(sourceFile)
assert.Assert(b, len(newText) > 0)
}
})
}

71
kitcom/internal/tsgo/format/comment_test.go
View File

@ -1,71 +0,0 @@
package format_test
import (
"strings"
"testing"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/ast"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/core"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/format"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/parser"
"gotest.tools/v3/assert"
)
func TestCommentFormatting(t *testing.T) {
t.Parallel()
t.Run("format comment issue reproduction", func(t *testing.T) {
t.Parallel()
ctx := format.WithFormatCodeSettings(t.Context(), &format.FormatCodeSettings{
EditorSettings: format.EditorSettings{
TabSize: 4,
IndentSize: 4,
BaseIndentSize: 4,
NewLineCharacter: "\n",
ConvertTabsToSpaces: true,
IndentStyle: format.IndentStyleSmart,
TrimTrailingWhitespace: true,
},
InsertSpaceBeforeTypeAnnotation: core.TSTrue,
}, "\n")
// Original code that causes the bug
originalText := `class C {
/**
*
*/
async x() {}
}`
sourceFile := parser.ParseSourceFile(ast.SourceFileParseOptions{
FileName: "/test.ts",
Path: "/test.ts",
}, originalText, core.ScriptKindTS)
// Apply formatting once
edits := format.FormatDocument(ctx, sourceFile)
firstFormatted := applyBulkEdits(originalText, edits)
// Check that the asterisk is not corrupted
assert.Check(t, !contains(firstFormatted, "*/\n /"), "should not corrupt */ to /")
assert.Check(t, contains(firstFormatted, "*/"), "should preserve */ token")
assert.Check(t, contains(firstFormatted, "async"), "should preserve async keyword")
// Apply formatting a second time to test stability
sourceFile2 := parser.ParseSourceFile(ast.SourceFileParseOptions{
FileName: "/test.ts",
Path: "/test.ts",
}, firstFormatted, core.ScriptKindTS)
edits2 := format.FormatDocument(ctx, sourceFile2)
secondFormatted := applyBulkEdits(firstFormatted, edits2)
// Check that second formatting doesn't introduce corruption
assert.Check(t, !contains(secondFormatted, " sync x()"), "should not corrupt async to sync")
assert.Check(t, contains(secondFormatted, "async"), "should preserve async keyword on second pass")
})
}
func contains(s, substr string) bool {
return len(substr) > 0 && strings.Contains(s, substr)
}

215
kitcom/internal/tsgo/format/context.go
View File

@ -1,215 +0,0 @@
package format
import (
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/ast"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/core"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/scanner"
)
type IndentStyle int
const (
IndentStyleNone IndentStyle = iota
IndentStyleBlock
IndentStyleSmart
)
type SemicolonPreference string
const (
SemicolonPreferenceIgnore SemicolonPreference = "ignore"
SemicolonPreferenceInsert SemicolonPreference = "insert"
SemicolonPreferenceRemove SemicolonPreference = "remove"
)
type EditorSettings struct {
BaseIndentSize int
IndentSize int
TabSize int
NewLineCharacter string
ConvertTabsToSpaces bool
IndentStyle IndentStyle
TrimTrailingWhitespace bool
}
type FormatCodeSettings struct {
EditorSettings
InsertSpaceAfterCommaDelimiter core.Tristate
InsertSpaceAfterSemicolonInForStatements core.Tristate
InsertSpaceBeforeAndAfterBinaryOperators core.Tristate
InsertSpaceAfterConstructor core.Tristate
InsertSpaceAfterKeywordsInControlFlowStatements core.Tristate
InsertSpaceAfterFunctionKeywordForAnonymousFunctions core.Tristate
InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis core.Tristate
InsertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets core.Tristate
InsertSpaceAfterOpeningAndBeforeClosingNonemptyBraces core.Tristate
InsertSpaceAfterOpeningAndBeforeClosingEmptyBraces core.Tristate
InsertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces core.Tristate
InsertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces core.Tristate
InsertSpaceAfterTypeAssertion core.Tristate
InsertSpaceBeforeFunctionParenthesis core.Tristate
PlaceOpenBraceOnNewLineForFunctions core.Tristate
PlaceOpenBraceOnNewLineForControlBlocks core.Tristate
InsertSpaceBeforeTypeAnnotation core.Tristate
IndentMultiLineObjectLiteralBeginningOnBlankLine core.Tristate
Semicolons SemicolonPreference
IndentSwitchCase core.Tristate
}
func GetDefaultFormatCodeSettings(newLineCharacter string) *FormatCodeSettings {
return &FormatCodeSettings{
EditorSettings: EditorSettings{
IndentSize: 4,
TabSize: 4,
NewLineCharacter: newLineCharacter,
ConvertTabsToSpaces: true,
IndentStyle: IndentStyleSmart,
TrimTrailingWhitespace: true,
},
InsertSpaceAfterConstructor: core.TSFalse,
InsertSpaceAfterCommaDelimiter: core.TSTrue,
InsertSpaceAfterSemicolonInForStatements: core.TSTrue,
InsertSpaceBeforeAndAfterBinaryOperators: core.TSTrue,
InsertSpaceAfterKeywordsInControlFlowStatements: core.TSTrue,
InsertSpaceAfterFunctionKeywordForAnonymousFunctions: core.TSFalse,
InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: core.TSFalse,
InsertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: core.TSFalse,
InsertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: core.TSTrue,
InsertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: core.TSFalse,
InsertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces: core.TSFalse,
InsertSpaceBeforeFunctionParenthesis: core.TSFalse,
PlaceOpenBraceOnNewLineForFunctions: core.TSFalse,
PlaceOpenBraceOnNewLineForControlBlocks: core.TSFalse,
Semicolons: SemicolonPreferenceIgnore,
IndentSwitchCase: core.TSTrue,
}
}
type formattingContext struct {
currentTokenSpan TextRangeWithKind
nextTokenSpan TextRangeWithKind
contextNode *ast.Node
currentTokenParent *ast.Node
nextTokenParent *ast.Node
contextNodeAllOnSameLine core.Tristate
nextNodeAllOnSameLine core.Tristate
tokensAreOnSameLine core.Tristate
contextNodeBlockIsOnOneLine core.Tristate
nextNodeBlockIsOnOneLine core.Tristate
SourceFile *ast.SourceFile
FormattingRequestKind FormatRequestKind
Options *FormatCodeSettings
scanner *scanner.Scanner
}
func NewFormattingContext(file *ast.SourceFile, kind FormatRequestKind, options *FormatCodeSettings) *formattingContext {
res := &formattingContext{
SourceFile: file,
FormattingRequestKind: kind,
Options: options,
scanner: scanner.NewScanner(),
}
res.scanner.SetText(file.Text())
res.scanner.SetSkipTrivia(true)
return res
}
func (this *formattingContext) UpdateContext(cur TextRangeWithKind, curParent *ast.Node, next TextRangeWithKind, nextParent *ast.Node, commonParent *ast.Node) {
if curParent == nil {
panic("nil current range node parent in update context")
}
if nextParent == nil {
panic("nil next range node parent in update context")
}
if commonParent == nil {
panic("nil common parent node in update context")
}
this.currentTokenSpan = cur
this.currentTokenParent = curParent
this.nextTokenSpan = next
this.nextTokenParent = nextParent
this.contextNode = commonParent
// drop cached results
this.contextNodeAllOnSameLine = core.TSUnknown
this.nextNodeAllOnSameLine = core.TSUnknown
this.tokensAreOnSameLine = core.TSUnknown
this.contextNodeBlockIsOnOneLine = core.TSUnknown
this.nextNodeBlockIsOnOneLine = core.TSUnknown
}
func (this *formattingContext) rangeIsOnOneLine(node core.TextRange) core.Tristate {
if rangeIsOnOneLine(node, this.SourceFile) {
return core.TSTrue
}
return core.TSFalse
}
func (this *formattingContext) nodeIsOnOneLine(node *ast.Node) core.Tristate {
return this.rangeIsOnOneLine(withTokenStart(node, this.SourceFile))
}
func withTokenStart(loc *ast.Node, file *ast.SourceFile) core.TextRange {
startPos := scanner.GetTokenPosOfNode(loc, file, false)
return core.NewTextRange(startPos, loc.End())
}
func (this *formattingContext) blockIsOnOneLine(node *ast.Node) core.Tristate {
// In strada, this relies on token child manifesting - we just use the scanner here,
// so this will have a differing performance profile. Is this OK? Needs profiling to know.
this.scanner.ResetPos(node.Pos())
end := node.End()
firstOpenBrace := -1
lastCloseBrace := -1
for this.scanner.TokenEnd() < end {
// tokenStart instead of tokenfullstart to skip trivia
if firstOpenBrace == -1 && this.scanner.Token() == ast.KindOpenBraceToken {
firstOpenBrace = this.scanner.TokenStart()
} else if this.scanner.Token() == ast.KindCloseBraceToken {
lastCloseBrace = this.scanner.TokenStart()
}
this.scanner.Scan()
}
if firstOpenBrace != -1 && lastCloseBrace != -1 {
return this.rangeIsOnOneLine(core.NewTextRange(firstOpenBrace, lastCloseBrace))
}
return core.TSFalse
}
func (this *formattingContext) ContextNodeAllOnSameLine() bool {
if this.contextNodeAllOnSameLine == core.TSUnknown {
this.contextNodeAllOnSameLine = this.nodeIsOnOneLine(this.contextNode)
}
return this.contextNodeAllOnSameLine == core.TSTrue
}
func (this *formattingContext) NextNodeAllOnSameLine() bool {
if this.nextNodeAllOnSameLine == core.TSUnknown {
this.nextNodeAllOnSameLine = this.nodeIsOnOneLine(this.nextTokenParent)
}
return this.nextNodeAllOnSameLine == core.TSTrue
}
func (this *formattingContext) TokensAreOnSameLine() bool {
if this.tokensAreOnSameLine == core.TSUnknown {
this.tokensAreOnSameLine = this.rangeIsOnOneLine(core.NewTextRange(this.currentTokenSpan.Loc.Pos(), this.nextTokenSpan.Loc.End()))
}
return this.tokensAreOnSameLine == core.TSTrue
}
func (this *formattingContext) ContextNodeBlockIsOnOneLine() bool {
if this.contextNodeBlockIsOnOneLine == core.TSUnknown {
this.contextNodeBlockIsOnOneLine = this.blockIsOnOneLine(this.contextNode)
}
return this.contextNodeBlockIsOnOneLine == core.TSTrue
}
func (this *formattingContext) NextNodeBlockIsOnOneLine() bool {
if this.nextNodeBlockIsOnOneLine == core.TSUnknown {
this.nextNodeBlockIsOnOneLine = this.blockIsOnOneLine(this.nextTokenParent)
}
return this.nextNodeBlockIsOnOneLine == core.TSTrue
}

559
kitcom/internal/tsgo/format/indent.go
View File

@ -1,559 +0,0 @@
package format
import (
"slices"
"unicode/utf8"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/ast"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/astnav"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/core"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/debug"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/scanner"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/stringutil"
)
func GetIndentationForNode(n *ast.Node, ignoreActualIndentationRange *core.TextRange, sourceFile *ast.SourceFile, options *FormatCodeSettings) int {
startline, startpos := scanner.GetECMALineAndCharacterOfPosition(sourceFile, scanner.GetTokenPosOfNode(n, sourceFile, false))
return getIndentationForNodeWorker(n, startline, startpos, ignoreActualIndentationRange /*indentationDelta*/, 0, sourceFile /*isNextChild*/, false, options)
}
func getIndentationForNodeWorker(
current *ast.Node,
currentStartLine int,
currentStartCharacter int,
ignoreActualIndentationRange *core.TextRange,
indentationDelta int,
sourceFile *ast.SourceFile,
isNextChild bool,
options *FormatCodeSettings,
) int {
parent := current.Parent
// Walk up the tree and collect indentation for parent-child node pairs. Indentation is not added if
// * parent and child nodes start on the same line, or
// * parent is an IfStatement and child starts on the same line as an 'else clause'.
for parent != nil {
useActualIndentation := true
if ignoreActualIndentationRange != nil {
start := scanner.GetTokenPosOfNode(current, sourceFile, false)
useActualIndentation = start < ignoreActualIndentationRange.Pos() || start > ignoreActualIndentationRange.End()
}
containingListOrParentStartLine, containingListOrParentStartCharacter := getContainingListOrParentStart(parent, current, sourceFile)
parentAndChildShareLine := containingListOrParentStartLine == currentStartLine ||
childStartsOnTheSameLineWithElseInIfStatement(parent, current, currentStartLine, sourceFile)
if useActualIndentation {
// check if current node is a list item - if yes, take indentation from it
var firstListChild *ast.Node
containerList := GetContainingList(current, sourceFile)
if containerList != nil {
firstListChild = core.FirstOrNil(containerList.Nodes)
}
// A list indents its children if the children begin on a later line than the list itself:
//
// f1( L0 - List start
// { L1 - First child start: indented, along with all other children
// prop: 0
// },
// {
// prop: 1
// }
// )
//
// f2({ L0 - List start and first child start: children are not indented.
// prop: 0 Object properties are indented only one level, because the list
// }, { itself contributes nothing.
// prop: 1 L3 - The indentation of the second object literal is best understood by
// }) looking at the relationship between the list and *first* list item.
listLine, _ := getStartLineAndCharacterForNode(firstListChild, sourceFile)
listIndentsChild := firstListChild != nil && listLine > containingListOrParentStartLine
actualIndentation := getActualIndentationForListItem(current, sourceFile, options, listIndentsChild)
if actualIndentation != -1 {
return actualIndentation + indentationDelta
}
// try to fetch actual indentation for current node from source text
actualIndentation = getActualIndentationForNode(current, parent, currentStartLine, currentStartCharacter, parentAndChildShareLine, sourceFile, options)
if actualIndentation != -1 {
return actualIndentation + indentationDelta
}
}
// increase indentation if parent node wants its content to be indented and parent and child nodes don't start on the same line
if ShouldIndentChildNode(options, parent, current, sourceFile, isNextChild) && !parentAndChildShareLine {
indentationDelta += options.IndentSize
}
// In our AST, a call argument's `parent` is the call-expression, not the argument list.
// We would like to increase indentation based on the relationship between an argument and its argument-list,
// so we spoof the starting position of the (parent) call-expression to match the (non-parent) argument-list.
// But, the spoofed start-value could then cause a problem when comparing the start position of the call-expression
// to *its* parent (in the case of an iife, an expression statement), adding an extra level of indentation.
//
// Instead, when at an argument, we unspoof the starting position of the enclosing call expression
// *after* applying indentation for the argument.
useTrueStart := isArgumentAndStartLineOverlapsExpressionBeingCalled(parent, current, currentStartLine, sourceFile)
current = parent
parent = current.Parent
if useTrueStart {
currentStartLine, currentStartCharacter = scanner.GetECMALineAndCharacterOfPosition(sourceFile, scanner.GetTokenPosOfNode(current, sourceFile, false))
} else {
currentStartLine = containingListOrParentStartLine
currentStartCharacter = containingListOrParentStartCharacter
}
}
return indentationDelta + options.BaseIndentSize
}
/*
* Function returns -1 if actual indentation for node should not be used (i.e because node is nested expression)
*/
func getActualIndentationForNode(current *ast.Node, parent *ast.Node, cuurentLine int, currentChar int, parentAndChildShareLine bool, sourceFile *ast.SourceFile, options *FormatCodeSettings) int {
// actual indentation is used for statements\declarations if one of cases below is true:
// - parent is SourceFile - by default immediate children of SourceFile are not indented except when user indents them manually
// - parent and child are not on the same line
useActualIndentation := (ast.IsDeclaration(current) || ast.IsStatementButNotDeclaration(current)) && (parent.Kind == ast.KindSourceFile || !parentAndChildShareLine)
if !useActualIndentation {
return -1
}
return findColumnForFirstNonWhitespaceCharacterInLine(cuurentLine, currentChar, sourceFile, options)
}
func isArgumentAndStartLineOverlapsExpressionBeingCalled(parent *ast.Node, child *ast.Node, childStartLine int, sourceFile *ast.SourceFile) bool {
if !(ast.IsCallExpression(child) && slices.Contains(parent.AsCallExpression().Arguments.Nodes, child)) {
return false
}
expressionOfCallExpressionEnd := parent.Expression().End()
expressionOfCallExpressionEndLine, _ := scanner.GetECMALineAndCharacterOfPosition(sourceFile, expressionOfCallExpressionEnd)
return expressionOfCallExpressionEndLine == childStartLine
}
func getActualIndentationForListItem(node *ast.Node, sourceFile *ast.SourceFile, options *FormatCodeSettings, listIndentsChild bool) int {
if node.Parent != nil && node.Parent.Kind == ast.KindVariableDeclarationList {
// VariableDeclarationList has no wrapping tokens
return -1
}
containingList := GetContainingList(node, sourceFile)
if containingList != nil {
index := core.FindIndex(containingList.Nodes, func(e *ast.Node) bool { return e == node })
if index != -1 {
result := deriveActualIndentationFromList(containingList, index, sourceFile, options)
if result != -1 {
return result
}
}
delta := 0
if listIndentsChild {
delta = options.IndentSize
}
res := getActualIndentationForListStartLine(containingList, sourceFile, options)
if res == -1 {
return delta
}
return res + delta
}
return -1
}
func getActualIndentationForListStartLine(list *ast.NodeList, sourceFile *ast.SourceFile, options *FormatCodeSettings) int {
if list == nil {
return -1
}
line, char := scanner.GetECMALineAndCharacterOfPosition(sourceFile, list.Loc.Pos())
return findColumnForFirstNonWhitespaceCharacterInLine(line, char, sourceFile, options)
}
func deriveActualIndentationFromList(list *ast.NodeList, index int, sourceFile *ast.SourceFile, options *FormatCodeSettings) int {
debug.Assert(list != nil && index >= 0 && index < len(list.Nodes))
node := list.Nodes[index]
// walk toward the start of the list starting from current node and check if the line is the same for all items.
// if end line for item [i - 1] differs from the start line for item [i] - find column of the first non-whitespace character on the line of item [i]
line, char := getStartLineAndCharacterForNode(node, sourceFile)
for i := index; i >= 0; i-- {
if list.Nodes[i].Kind == ast.KindCommaToken {
continue
}
// skip list items that ends on the same line with the current list element
prevEndLine, _ := scanner.GetECMALineAndCharacterOfPosition(sourceFile, list.Nodes[i].End())
if prevEndLine != line {
return findColumnForFirstNonWhitespaceCharacterInLine(line, char, sourceFile, options)
}
line, char = getStartLineAndCharacterForNode(list.Nodes[i], sourceFile)
}
return -1
}
func findColumnForFirstNonWhitespaceCharacterInLine(line int, char int, sourceFile *ast.SourceFile, options *FormatCodeSettings) int {
lineStart := scanner.GetECMAPositionOfLineAndCharacter(sourceFile, line, 0)
return FindFirstNonWhitespaceColumn(lineStart, lineStart+char, sourceFile, options)
}
func FindFirstNonWhitespaceColumn(startPos int, endPos int, sourceFile *ast.SourceFile, options *FormatCodeSettings) int {
_, col := findFirstNonWhitespaceCharacterAndColumn(startPos, endPos, sourceFile, options)
return col
}
/**
* Character is the actual index of the character since the beginning of the line.
* Column - position of the character after expanding tabs to spaces.
* "0\t2$"
* value of 'character' for '$' is 3
* value of 'column' for '$' is 6 (assuming that tab size is 4)
*/
func findFirstNonWhitespaceCharacterAndColumn(startPos int, endPos int, sourceFile *ast.SourceFile, options *FormatCodeSettings) (character int, column int) {
character = 0
column = 0
text := sourceFile.Text()
for pos := startPos; pos < endPos; pos++ {
ch, size := utf8.DecodeRuneInString(text[pos:])
if size == 0 && ch == utf8.RuneError {
continue // multibyte character - TODO: recognize non-tab multicolumn characters? ideographic space?
}
if !stringutil.IsWhiteSpaceSingleLine(ch) {
break
}
if ch == '\t' {
column += options.TabSize + (column % options.TabSize)
} else {
column++
}
character++
}
return character, column
}
func childStartsOnTheSameLineWithElseInIfStatement(parent *ast.Node, child *ast.Node, childStartLine int, sourceFile *ast.SourceFile) bool {
if parent.Kind == ast.KindIfStatement && parent.AsIfStatement().ElseStatement == child {
elseKeyword := astnav.FindPrecedingToken(sourceFile, child.Pos())
debug.AssertIsDefined(elseKeyword)
elseKeywordStartLine, _ := getStartLineAndCharacterForNode(elseKeyword, sourceFile)
return elseKeywordStartLine == childStartLine
}
return false
}
func getStartLineAndCharacterForNode(n *ast.Node, sourceFile *ast.SourceFile) (line int, character int) {
return scanner.GetECMALineAndCharacterOfPosition(sourceFile, scanner.GetTokenPosOfNode(n, sourceFile, false))
}
func GetContainingList(node *ast.Node, sourceFile *ast.SourceFile) *ast.NodeList {
if node.Parent == nil {
return nil
}
return getListByRange(scanner.GetTokenPosOfNode(node, sourceFile, false), node.End(), node.Parent, sourceFile)
}
func getListByPosition(pos int, node *ast.Node, sourceFile *ast.SourceFile) *ast.NodeList {
if node == nil {
return nil
}
return getListByRange(pos, pos, node, sourceFile)
}
func getListByRange(start int, end int, node *ast.Node, sourceFile *ast.SourceFile) *ast.NodeList {
r := core.NewTextRange(start, end)
switch node.Kind {
case ast.KindTypeReference:
return getList(node.AsTypeReferenceNode().TypeArguments, r, node, sourceFile)
case ast.KindObjectLiteralExpression:
return getList(node.AsObjectLiteralExpression().Properties, r, node, sourceFile)
case ast.KindArrayLiteralExpression:
return getList(node.AsArrayLiteralExpression().Elements, r, node, sourceFile)
case ast.KindTypeLiteral:
return getList(node.AsTypeLiteralNode().Members, r, node, sourceFile)
case ast.KindFunctionDeclaration,
ast.KindFunctionExpression,
ast.KindArrowFunction,
ast.KindMethodDeclaration,
ast.KindMethodSignature,
ast.KindCallSignature,
ast.KindConstructor,
ast.KindConstructorType,
ast.KindConstructSignature:
tpl := getList(node.TypeParameterList(), r, node, sourceFile)
if tpl != nil {
return tpl
}
return getList(node.ParameterList(), r, node, sourceFile)
case ast.KindGetAccessor:
return getList(node.ParameterList(), r, node, sourceFile)
case ast.KindClassDeclaration,
ast.KindClassExpression,
ast.KindInterfaceDeclaration,
ast.KindTypeAliasDeclaration,
ast.KindJSDocTemplateTag:
return getList(node.TypeParameterList(), r, node, sourceFile)
case ast.KindNewExpression, ast.KindCallExpression:
l := getList(node.TypeArgumentList(), r, node, sourceFile)
if l != nil {
return l
}
return getList(node.ArgumentList(), r, node, sourceFile)
case ast.KindVariableDeclarationList:
return getList(node.AsVariableDeclarationList().Declarations, r, node, sourceFile)
case ast.KindNamedImports:
return getList(node.AsNamedImports().Elements, r, node, sourceFile)
case ast.KindNamedExports:
return getList(node.AsNamedExports().Elements, r, node, sourceFile)
case ast.KindObjectBindingPattern, ast.KindArrayBindingPattern:
return getList(node.AsBindingPattern().Elements, r, node, sourceFile)
}
return nil // TODO: should this be a panic? It isn't in strada.
}
func getList(list *ast.NodeList, r core.TextRange, node *ast.Node, sourceFile *ast.SourceFile) *ast.NodeList {
if list == nil {
return nil
}
if r.ContainedBy(getVisualListRange(node, list.Loc, sourceFile)) {
return list
}
return nil
}
func getVisualListRange(node *ast.Node, list core.TextRange, sourceFile *ast.SourceFile) core.TextRange {
// In strada, this relied on the services .getChildren method, which manifested synthetic token nodes
// _however_, the logic boils down to "find the child with the matching span and adjust its start to the
// previous (possibly token) child's end and its end to the token start of the following element" - basically
// expanding the range to encompass all the neighboring non-token trivia
// Now, we perform that logic with the scanner instead
prior := astnav.FindPrecedingToken(sourceFile, list.Pos())
var priorEnd int
if prior == nil {
priorEnd = list.Pos()
} else {
priorEnd = prior.End()
}
next := astnav.FindNextToken(prior, node, sourceFile)
var nextStart int
if next == nil {
nextStart = list.End()
} else {
nextStart = next.Pos()
}
return core.NewTextRange(priorEnd, nextStart)
}
func getContainingListOrParentStart(parent *ast.Node, child *ast.Node, sourceFile *ast.SourceFile) (line int, character int) {
containingList := GetContainingList(child, sourceFile)
var startPos int
if containingList != nil {
startPos = containingList.Loc.Pos()
} else {
startPos = scanner.GetTokenPosOfNode(parent, sourceFile, false)
}
return scanner.GetECMALineAndCharacterOfPosition(sourceFile, startPos)
}
func isControlFlowEndingStatement(kind ast.Kind, parentKind ast.Kind) bool {
switch kind {
case ast.KindReturnStatement, ast.KindThrowStatement, ast.KindContinueStatement, ast.KindBreakStatement:
return parentKind != ast.KindBlock
default:
return false
}
}
/**
* True when the parent node should indent the given child by an explicit rule.
* @param isNextChild If true, we are judging indent of a hypothetical child *after* this one, not the current child.
*/
func ShouldIndentChildNode(settings *FormatCodeSettings, parent *ast.Node, child *ast.Node, sourceFile *ast.SourceFile, isNextChildArg ...bool) bool {
isNextChild := false
if len(isNextChildArg) > 0 {
isNextChild = isNextChildArg[0]
}
return NodeWillIndentChild(settings, parent, child, sourceFile, false) && !(isNextChild && child != nil && isControlFlowEndingStatement(child.Kind, parent.Kind))
}
func NodeWillIndentChild(settings *FormatCodeSettings, parent *ast.Node, child *ast.Node, sourceFile *ast.SourceFile, indentByDefault bool) bool {
childKind := ast.KindUnknown
if child != nil {
childKind = child.Kind
}
switch parent.Kind {
case ast.KindExpressionStatement,
ast.KindClassDeclaration,
ast.KindClassExpression,
ast.KindInterfaceDeclaration,
ast.KindEnumDeclaration,
ast.KindTypeAliasDeclaration,
ast.KindArrayLiteralExpression,
ast.KindBlock,
ast.KindModuleBlock,
ast.KindObjectLiteralExpression,
ast.KindTypeLiteral,
ast.KindMappedType,
ast.KindTupleType,
ast.KindParenthesizedExpression,
ast.KindPropertyAccessExpression,
ast.KindCallExpression,
ast.KindNewExpression,
ast.KindVariableStatement,
ast.KindExportAssignment,
ast.KindReturnStatement,
ast.KindConditionalExpression,
ast.KindArrayBindingPattern,
ast.KindObjectBindingPattern,
ast.KindJsxOpeningElement,
ast.KindJsxOpeningFragment,
ast.KindJsxSelfClosingElement,
ast.KindJsxExpression,
ast.KindMethodSignature,
ast.KindCallSignature,
ast.KindConstructSignature,
ast.KindParameter,
ast.KindFunctionType,
ast.KindConstructorType,
ast.KindParenthesizedType,
ast.KindTaggedTemplateExpression,
ast.KindAwaitExpression,
ast.KindNamedExports,
ast.KindNamedImports,
ast.KindExportSpecifier,
ast.KindImportSpecifier,
ast.KindPropertyDeclaration,
ast.KindCaseClause,
ast.KindDefaultClause:
return true
case ast.KindCaseBlock:
return settings.IndentSwitchCase.IsTrueOrUnknown()
case ast.KindVariableDeclaration, ast.KindPropertyAssignment, ast.KindBinaryExpression:
if settings.IndentMultiLineObjectLiteralBeginningOnBlankLine.IsFalseOrUnknown() && sourceFile != nil && childKind == ast.KindObjectLiteralExpression {
return rangeIsOnOneLine(child.Loc, sourceFile)
}
if parent.Kind == ast.KindBinaryExpression && sourceFile != nil && childKind == ast.KindJsxElement {
parentStartLine, _ := scanner.GetECMALineAndCharacterOfPosition(sourceFile, scanner.SkipTrivia(sourceFile.Text(), parent.Pos()))
childStartLine, _ := scanner.GetECMALineAndCharacterOfPosition(sourceFile, scanner.SkipTrivia(sourceFile.Text(), child.Pos()))
return parentStartLine != childStartLine
}
if parent.Kind != ast.KindBinaryExpression {
return true
}
return indentByDefault
case ast.KindDoStatement,
ast.KindWhileStatement,
ast.KindForInStatement,
ast.KindForOfStatement,
ast.KindForStatement,
ast.KindIfStatement,
ast.KindFunctionDeclaration,
ast.KindFunctionExpression,
ast.KindMethodDeclaration,
ast.KindConstructor,
ast.KindGetAccessor,
ast.KindSetAccessor:
return childKind != ast.KindBlock
case ast.KindArrowFunction:
if sourceFile != nil && childKind == ast.KindParenthesizedExpression {
return rangeIsOnOneLine(child.Loc, sourceFile)
}
return childKind != ast.KindBlock
case ast.KindExportDeclaration:
return childKind != ast.KindNamedExports
case ast.KindImportDeclaration:
return childKind != ast.KindImportClause || (child.AsImportClause().NamedBindings != nil && child.AsImportClause().NamedBindings.Kind != ast.KindNamedImports)
case ast.KindJsxElement:
return childKind != ast.KindJsxClosingElement
case ast.KindJsxFragment:
return childKind != ast.KindJsxClosingFragment
case ast.KindIntersectionType, ast.KindUnionType, ast.KindSatisfiesExpression:
if childKind == ast.KindTypeLiteral || childKind == ast.KindTupleType || childKind == ast.KindMappedType {
return false
}
return indentByDefault
case ast.KindTryStatement:
if childKind == ast.KindBlock {
return false
}
return indentByDefault
}
// No explicit rule for given nodes so the result will follow the default value argument
return indentByDefault
}
// A multiline conditional typically increases the indentation of its whenTrue and whenFalse children:
//
// condition
//
// ? whenTrue
// : whenFalse;
//
// However, that indentation does not apply if the subexpressions themselves span multiple lines,
// applying their own indentation:
//
// (() => {
// return complexCalculationForCondition();
// })() ? {
//
// whenTrue: 'multiline object literal'
// } : (
//
// whenFalse('multiline parenthesized expression')
//
// );
//
// In these cases, we must discard the indentation increase that would otherwise be applied to the
// whenTrue and whenFalse children to avoid double-indenting their contents. To identify this scenario,
// we check for the whenTrue branch beginning on the line that the condition ends, and the whenFalse
// branch beginning on the line that the whenTrue branch ends.
func childIsUnindentedBranchOfConditionalExpression(parent *ast.Node, child *ast.Node, childStartLine int, sourceFile *ast.SourceFile) bool {
if parent.Kind == ast.KindConditionalExpression && (child == parent.AsConditionalExpression().WhenTrue || child == parent.AsConditionalExpression().WhenFalse) {
conditionEndLine, _ := scanner.GetECMALineAndCharacterOfPosition(sourceFile, parent.AsConditionalExpression().Condition.End())
if child == parent.AsConditionalExpression().WhenTrue {
return childStartLine == conditionEndLine
} else {
// On the whenFalse side, we have to look at the whenTrue side, because if that one was
// indented, whenFalse must also be indented:
//
// const y = true
// ? 1 : ( L1: whenTrue indented because it's on a new line
// 0 L2: indented two stops, one because whenTrue was indented
// ); and one because of the parentheses spanning multiple lines
trueStartLine, _ := getStartLineAndCharacterForNode(parent.AsConditionalExpression().WhenTrue, sourceFile)
trueEndLine, _ := scanner.GetECMALineAndCharacterOfPosition(sourceFile, parent.AsConditionalExpression().WhenTrue.End())
return conditionEndLine == trueStartLine && trueEndLine == childStartLine
}
}
return false
}
func argumentStartsOnSameLineAsPreviousArgument(parent *ast.Node, child *ast.Node, childStartLine int, sourceFile *ast.SourceFile) bool {
if ast.IsCallExpression(parent) || ast.IsNewExpression(parent) {
if len(parent.Arguments()) == 0 {
return false
}
currentIndex := core.FindIndex(parent.Arguments(), func(n *ast.Node) bool { return n == child })
if currentIndex == -1 {
// If it's not one of the arguments, don't look past this
return false
}
if currentIndex == 0 {
return false // Can't look at previous node if first
}
previousNode := parent.Arguments()[currentIndex-1]
lineOfPreviousNode, _ := scanner.GetECMALineAndCharacterOfPosition(sourceFile, previousNode.End())
if childStartLine == lineOfPreviousNode {
return true
}
}
return false
}

109
kitcom/internal/tsgo/format/rule.go
View File

@ -1,109 +0,0 @@
package format
import "efprojects.com/kitten-ipc/kitcom/internal/tsgo/ast"
type ruleImpl struct {
debugName string
context []contextPredicate
action ruleAction
flags ruleFlags
}
func (r ruleImpl) Action() ruleAction {
return r.action
}
func (r ruleImpl) Context() []contextPredicate {
return r.context
}
func (r ruleImpl) Flags() ruleFlags {
return r.flags
}
func (r ruleImpl) String() string {
return r.debugName
}
type tokenRange struct {
tokens []ast.Kind
isSpecific bool
}
type ruleSpec struct {
leftTokenRange tokenRange
rightTokenRange tokenRange
rule *ruleImpl
}
/**
* A rule takes a two tokens (left/right) and a particular context
* for which you're meant to look at them. You then declare what should the
* whitespace annotation be between these tokens via the action param.
*
* @param debugName Name to print
* @param left The left side of the comparison
* @param right The right side of the comparison
* @param context A set of filters to narrow down the space in which this formatter rule applies
* @param action a declaration of the expected whitespace
* @param flags whether the rule deletes a line or not, defaults to no-op
*/
func rule(debugName string, left any, right any, context []contextPredicate, action ruleAction, flags ...ruleFlags) ruleSpec {
flag := ruleFlagsNone
if len(flags) > 0 {
flag = flags[0]
}
leftRange := toTokenRange(left)
rightRange := toTokenRange(right)
rule := &ruleImpl{
debugName: debugName,
context: context,
action: action,
flags: flag,
}
return ruleSpec{
leftTokenRange: leftRange,
rightTokenRange: rightRange,
rule: rule,
}
}
func toTokenRange(e any) tokenRange {
switch t := e.(type) {
case ast.Kind:
return tokenRange{isSpecific: true, tokens: []ast.Kind{t}}
case []ast.Kind:
return tokenRange{isSpecific: true, tokens: t}
case tokenRange:
return t
}
panic("Unknown argument type passed to toTokenRange - only ast.Kind, []ast.Kind, and tokenRange supported")
}
type contextPredicate = func(ctx *formattingContext) bool
var anyContext = []contextPredicate{}
type ruleAction int
const (
ruleActionNone ruleAction = 0
ruleActionStopProcessingSpaceActions ruleAction = 1 << 0
ruleActionStopProcessingTokenActions ruleAction = 1 << 1
ruleActionInsertSpace ruleAction = 1 << 2
ruleActionInsertNewLine ruleAction = 1 << 3
ruleActionDeleteSpace ruleAction = 1 << 4
ruleActionDeleteToken ruleAction = 1 << 5
ruleActionInsertTrailingSemicolon ruleAction = 1 << 6
ruleActionStopAction ruleAction = ruleActionStopProcessingSpaceActions | ruleActionStopProcessingTokenActions
ruleActionModifySpaceAction ruleAction = ruleActionInsertSpace | ruleActionInsertNewLine | ruleActionDeleteSpace
ruleActionModifyTokenAction ruleAction = ruleActionDeleteToken | ruleActionInsertTrailingSemicolon
)
type ruleFlags int
const (
ruleFlagsNone ruleFlags = iota
ruleFlagsCanDeleteNewLines
)

644
kitcom/internal/tsgo/format/rulecontext.go
View File

@ -1,644 +0,0 @@
package format
import (
"strings"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/ast"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/astnav"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/core"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/lsutil"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/scanner"
)
///
/// Contexts
///
type (
optionSelector = func(options *FormatCodeSettings) core.Tristate
anyOptionSelector[T comparable] = func(options *FormatCodeSettings) T
)
func semicolonOption(options *FormatCodeSettings) SemicolonPreference { return options.Semicolons }
func insertSpaceAfterCommaDelimiterOption(options *FormatCodeSettings) core.Tristate {
return options.InsertSpaceAfterCommaDelimiter
}
func insertSpaceAfterSemicolonInForStatementsOption(options *FormatCodeSettings) core.Tristate {
return options.InsertSpaceAfterSemicolonInForStatements
}
func insertSpaceBeforeAndAfterBinaryOperatorsOption(options *FormatCodeSettings) core.Tristate {
return options.InsertSpaceBeforeAndAfterBinaryOperators
}
func insertSpaceAfterConstructorOption(options *FormatCodeSettings) core.Tristate {
return options.InsertSpaceAfterConstructor
}
func insertSpaceAfterKeywordsInControlFlowStatementsOption(options *FormatCodeSettings) core.Tristate {
return options.InsertSpaceAfterKeywordsInControlFlowStatements
}
func insertSpaceAfterFunctionKeywordForAnonymousFunctionsOption(options *FormatCodeSettings) core.Tristate {
return options.InsertSpaceAfterFunctionKeywordForAnonymousFunctions
}
func insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesisOption(options *FormatCodeSettings) core.Tristate {
return options.InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis
}
func insertSpaceAfterOpeningAndBeforeClosingNonemptyBracketsOption(options *FormatCodeSettings) core.Tristate {
return options.InsertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets
}
func insertSpaceAfterOpeningAndBeforeClosingNonemptyBracesOption(options *FormatCodeSettings) core.Tristate {
return options.InsertSpaceAfterOpeningAndBeforeClosingNonemptyBraces
}
func insertSpaceAfterOpeningAndBeforeClosingEmptyBracesOption(options *FormatCodeSettings) core.Tristate {
return options.InsertSpaceAfterOpeningAndBeforeClosingEmptyBraces
}
func insertSpaceAfterOpeningAndBeforeClosingTemplateStringBracesOption(options *FormatCodeSettings) core.Tristate {
return options.InsertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces
}
func insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBracesOption(options *FormatCodeSettings) core.Tristate {
return options.InsertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces
}
func insertSpaceAfterTypeAssertionOption(options *FormatCodeSettings) core.Tristate {
return options.InsertSpaceAfterTypeAssertion
}
func insertSpaceBeforeFunctionParenthesisOption(options *FormatCodeSettings) core.Tristate {
return options.InsertSpaceBeforeFunctionParenthesis
}
func placeOpenBraceOnNewLineForFunctionsOption(options *FormatCodeSettings) core.Tristate {
return options.PlaceOpenBraceOnNewLineForFunctions
}
func placeOpenBraceOnNewLineForControlBlocksOption(options *FormatCodeSettings) core.Tristate {
return options.PlaceOpenBraceOnNewLineForControlBlocks
}
func insertSpaceBeforeTypeAnnotationOption(options *FormatCodeSettings) core.Tristate {
return options.InsertSpaceBeforeTypeAnnotation
}
func indentMultiLineObjectLiteralBeginningOnBlankLineOption(options *FormatCodeSettings) core.Tristate {
return options.IndentMultiLineObjectLiteralBeginningOnBlankLine
}
func indentSwitchCaseOption(options *FormatCodeSettings) core.Tristate {
return options.IndentSwitchCase
}
func optionEquals[T comparable](optionName anyOptionSelector[T], optionValue T) contextPredicate {
return func(context *formattingContext) bool {
if context.Options == nil {
return false
}
return optionName(context.Options) == optionValue
}
}
func isOptionEnabled(optionName optionSelector) contextPredicate {
return func(context *formattingContext) bool {
if context.Options == nil {
return false
}
return optionName(context.Options).IsTrue()
}
}
func isOptionDisabled(optionName optionSelector) contextPredicate {
return func(context *formattingContext) bool {
if context.Options == nil {
return true
}
return optionName(context.Options).IsFalse()
}
}
func isOptionDisabledOrUndefined(optionName optionSelector) contextPredicate {
return func(context *formattingContext) bool {
if context.Options == nil {
return true
}
return optionName(context.Options).IsFalseOrUnknown()
}
}
func isOptionDisabledOrUndefinedOrTokensOnSameLine(optionName optionSelector) contextPredicate {
return func(context *formattingContext) bool {
if context.Options == nil {
return true
}
return optionName(context.Options).IsFalseOrUnknown() || context.TokensAreOnSameLine()
}
}
func isOptionEnabledOrUndefined(optionName optionSelector) contextPredicate {
return func(context *formattingContext) bool {
if context.Options == nil {
return true
}
return optionName(context.Options).IsTrueOrUnknown()
}
}
func isForContext(context *formattingContext) bool {
return context.contextNode.Kind == ast.KindForStatement
}
func isNotForContext(context *formattingContext) bool {
return !isForContext(context)
}
func isBinaryOpContext(context *formattingContext) bool {
switch context.contextNode.Kind {
case ast.KindBinaryExpression:
return context.contextNode.AsBinaryExpression().OperatorToken.Kind != ast.KindCommaToken
case ast.KindConditionalExpression,
ast.KindConditionalType,
ast.KindAsExpression,
ast.KindExportSpecifier,
ast.KindImportSpecifier,
ast.KindTypePredicate,
ast.KindUnionType,
ast.KindIntersectionType,
ast.KindSatisfiesExpression:
return true
// equals in binding elements func foo([[x, y] = [1, 2]])
case ast.KindBindingElement:
// equals in type X = ...
fallthrough
case ast.KindTypeAliasDeclaration:
// equal in import a = module('a');
fallthrough
case ast.KindImportEqualsDeclaration:
// equal in export = 1
fallthrough
case ast.KindExportAssignment:
// equal in let a = 0
fallthrough
case ast.KindVariableDeclaration:
// equal in p = 0
fallthrough
case ast.KindParameter,
ast.KindEnumMember,
ast.KindPropertyDeclaration,
ast.KindPropertySignature:
return context.currentTokenSpan.Kind == ast.KindEqualsToken || context.nextTokenSpan.Kind == ast.KindEqualsToken
// "in" keyword in for (let x in []) { }
case ast.KindForInStatement:
// "in" keyword in [P in keyof T] T[P]
fallthrough
case ast.KindTypeParameter:
return context.currentTokenSpan.Kind == ast.KindInKeyword || context.nextTokenSpan.Kind == ast.KindInKeyword || context.currentTokenSpan.Kind == ast.KindEqualsToken || context.nextTokenSpan.Kind == ast.KindEqualsToken
// Technically, "of" is not a binary operator, but format it the same way as "in"
case ast.KindForOfStatement:
return context.currentTokenSpan.Kind == ast.KindOfKeyword || context.nextTokenSpan.Kind == ast.KindOfKeyword
}
return false
}
func isNotBinaryOpContext(context *formattingContext) bool {
return !isBinaryOpContext(context)
}
func isNotTypeAnnotationContext(context *formattingContext) bool {
return !isTypeAnnotationContext(context)
}
func isTypeAnnotationContext(context *formattingContext) bool {
contextKind := context.contextNode.Kind
return contextKind == ast.KindPropertyDeclaration ||
contextKind == ast.KindPropertySignature ||
contextKind == ast.KindParameter ||
contextKind == ast.KindVariableDeclaration ||
ast.IsFunctionLikeKind(contextKind)
}
func isOptionalPropertyContext(context *formattingContext) bool {
return ast.IsPropertyDeclaration(context.contextNode) && context.contextNode.AsPropertyDeclaration().PostfixToken != nil && context.contextNode.AsPropertyDeclaration().PostfixToken.Kind == ast.KindQuestionToken
}
func isNonOptionalPropertyContext(context *formattingContext) bool {
return !isOptionalPropertyContext(context)
}
func isConditionalOperatorContext(context *formattingContext) bool {
return context.contextNode.Kind == ast.KindConditionalExpression ||
context.contextNode.Kind == ast.KindConditionalType
}
func isSameLineTokenOrBeforeBlockContext(context *formattingContext) bool {
return context.TokensAreOnSameLine() || isBeforeBlockContext(context)
}
func isBraceWrappedContext(context *formattingContext) bool {
return context.contextNode.Kind == ast.KindObjectBindingPattern ||
context.contextNode.Kind == ast.KindMappedType ||
isSingleLineBlockContext(context)
}
// This check is done before an open brace in a control construct, a function, or a typescript block declaration
func isBeforeMultilineBlockContext(context *formattingContext) bool {
return isBeforeBlockContext(context) && !(context.NextNodeAllOnSameLine() || context.NextNodeBlockIsOnOneLine())
}
func isMultilineBlockContext(context *formattingContext) bool {
return isBlockContext(context) && !(context.ContextNodeAllOnSameLine() || context.ContextNodeBlockIsOnOneLine())
}
func isSingleLineBlockContext(context *formattingContext) bool {
return isBlockContext(context) && (context.ContextNodeAllOnSameLine() || context.ContextNodeBlockIsOnOneLine())
}
func isBlockContext(context *formattingContext) bool {
return nodeIsBlockContext(context.contextNode)
}
func isBeforeBlockContext(context *formattingContext) bool {
return nodeIsBlockContext(context.nextTokenParent)
}
// IMPORTANT!!! This method must return true ONLY for nodes with open and close braces as immediate children
func nodeIsBlockContext(node *ast.Node) bool {
if nodeIsTypeScriptDeclWithBlockContext(node) {
// This means we are in a context that looks like a block to the user, but in the grammar is actually not a node (it's a class, module, enum, object type literal, etc).
return true
}
switch node.Kind {
case ast.KindBlock,
ast.KindCaseBlock,
ast.KindObjectLiteralExpression,
ast.KindModuleBlock:
return true
}
return false
}
func isFunctionDeclContext(context *formattingContext) bool {
switch context.contextNode.Kind {
case ast.KindFunctionDeclaration,
ast.KindMethodDeclaration,
ast.KindMethodSignature:
// case ast.KindMemberFunctionDeclaration:
fallthrough
case ast.KindGetAccessor,
ast.KindSetAccessor:
// case ast.KindMethodSignature:
fallthrough
case ast.KindCallSignature,
ast.KindFunctionExpression,
ast.KindConstructor,
ast.KindArrowFunction:
// case ast.KindConstructorDeclaration:
// case ast.KindSimpleArrowFunctionExpression:
// case ast.KindParenthesizedArrowFunctionExpression:
fallthrough
case ast.KindInterfaceDeclaration: // This one is not truly a function, but for formatting purposes, it acts just like one
return true
}
return false
}
func isNotFunctionDeclContext(context *formattingContext) bool {
return !isFunctionDeclContext(context)
}
func isFunctionDeclarationOrFunctionExpressionContext(context *formattingContext) bool {
return context.contextNode.Kind == ast.KindFunctionDeclaration || context.contextNode.Kind == ast.KindFunctionExpression
}
func isTypeScriptDeclWithBlockContext(context *formattingContext) bool {
return nodeIsTypeScriptDeclWithBlockContext(context.contextNode)
}
func nodeIsTypeScriptDeclWithBlockContext(node *ast.Node) bool {
switch node.Kind {
case ast.KindClassDeclaration,
ast.KindClassExpression,
ast.KindInterfaceDeclaration,
ast.KindEnumDeclaration,
ast.KindTypeLiteral,
ast.KindModuleDeclaration,
ast.KindExportDeclaration,
ast.KindNamedExports,
ast.KindImportDeclaration,
ast.KindNamedImports:
return true
}
return false
}
func isAfterCodeBlockContext(context *formattingContext) bool {
switch context.currentTokenParent.Kind {
case ast.KindClassDeclaration,
ast.KindModuleDeclaration,
ast.KindEnumDeclaration,
ast.KindCatchClause,
ast.KindModuleBlock,
ast.KindSwitchStatement:
return true
case ast.KindBlock:
blockParent := context.currentTokenParent.Parent
// In a codefix scenario, we can't rely on parents being set. So just always return true.
if blockParent == nil || blockParent.Kind != ast.KindArrowFunction && blockParent.Kind != ast.KindFunctionExpression {
return true
}
}
return false
}
func isControlDeclContext(context *formattingContext) bool {
switch context.contextNode.Kind {
case ast.KindIfStatement,
ast.KindSwitchStatement,
ast.KindForStatement,
ast.KindForInStatement,
ast.KindForOfStatement,
ast.KindWhileStatement,
ast.KindTryStatement,
ast.KindDoStatement,
ast.KindWithStatement:
// TODO
// case ast.KindElseClause:
fallthrough
case ast.KindCatchClause:
return true
default:
return false
}
}
func isObjectContext(context *formattingContext) bool {
return context.contextNode.Kind == ast.KindObjectLiteralExpression
}
func isFunctionCallContext(context *formattingContext) bool {
return context.contextNode.Kind == ast.KindCallExpression
}
func isNewContext(context *formattingContext) bool {
return context.contextNode.Kind == ast.KindNewExpression
}
func isFunctionCallOrNewContext(context *formattingContext) bool {
return isFunctionCallContext(context) || isNewContext(context)
}
func isPreviousTokenNotComma(context *formattingContext) bool {
return context.currentTokenSpan.Kind != ast.KindCommaToken
}
func isNextTokenNotCloseBracket(context *formattingContext) bool {
return context.nextTokenSpan.Kind != ast.KindCloseBracketToken
}
func isNextTokenNotCloseParen(context *formattingContext) bool {
return context.nextTokenSpan.Kind != ast.KindCloseParenToken
}
func isArrowFunctionContext(context *formattingContext) bool {
return context.contextNode.Kind == ast.KindArrowFunction
}
func isImportTypeContext(context *formattingContext) bool {
return context.contextNode.Kind == ast.KindImportType
}
func isNonJsxSameLineTokenContext(context *formattingContext) bool {
return context.TokensAreOnSameLine() && context.contextNode.Kind != ast.KindJsxText
}
func isNonJsxTextContext(context *formattingContext) bool {
return context.contextNode.Kind != ast.KindJsxText
}
func isNonJsxElementOrFragmentContext(context *formattingContext) bool {
return context.contextNode.Kind != ast.KindJsxElement && context.contextNode.Kind != ast.KindJsxFragment
}
func isJsxExpressionContext(context *formattingContext) bool {
return context.contextNode.Kind == ast.KindJsxExpression || context.contextNode.Kind == ast.KindJsxSpreadAttribute
}
func isNextTokenParentJsxAttribute(context *formattingContext) bool {
return context.nextTokenParent.Kind == ast.KindJsxAttribute || (context.nextTokenParent.Kind == ast.KindJsxNamespacedName && context.nextTokenParent.Parent.Kind == ast.KindJsxAttribute)
}
func isJsxAttributeContext(context *formattingContext) bool {
return context.contextNode.Kind == ast.KindJsxAttribute
}
func isNextTokenParentNotJsxNamespacedName(context *formattingContext) bool {
return context.nextTokenParent.Kind != ast.KindJsxNamespacedName
}
func isNextTokenParentJsxNamespacedName(context *formattingContext) bool {
return context.nextTokenParent.Kind == ast.KindJsxNamespacedName
}
func isJsxSelfClosingElementContext(context *formattingContext) bool {
return context.contextNode.Kind == ast.KindJsxSelfClosingElement
}
func isNotBeforeBlockInFunctionDeclarationContext(context *formattingContext) bool {
return !isFunctionDeclContext(context) && !isBeforeBlockContext(context)
}
func isEndOfDecoratorContextOnSameLine(context *formattingContext) bool {
return context.TokensAreOnSameLine() &&
ast.HasDecorators(context.contextNode) &&
nodeIsInDecoratorContext(context.currentTokenParent) &&
!nodeIsInDecoratorContext(context.nextTokenParent)
}
func nodeIsInDecoratorContext(node *ast.Node) bool {
for node != nil && ast.IsExpression(node) {
node = node.Parent
}
return node != nil && node.Kind == ast.KindDecorator
}
func isStartOfVariableDeclarationList(context *formattingContext) bool {
return context.currentTokenParent.Kind == ast.KindVariableDeclarationList &&
scanner.GetTokenPosOfNode(context.currentTokenParent, context.SourceFile, false) == context.currentTokenSpan.Loc.Pos()
}
func isNotFormatOnEnter(context *formattingContext) bool {
return context.FormattingRequestKind != FormatRequestKindFormatOnEnter
}
func isModuleDeclContext(context *formattingContext) bool {
return context.contextNode.Kind == ast.KindModuleDeclaration
}
func isObjectTypeContext(context *formattingContext) bool {
return context.contextNode.Kind == ast.KindTypeLiteral // && context.contextNode.parent.Kind != ast.KindInterfaceDeclaration;
}
func isConstructorSignatureContext(context *formattingContext) bool {
return context.contextNode.Kind == ast.KindConstructSignature
}
func isTypeArgumentOrParameterOrAssertion(token TextRangeWithKind, parent *ast.Node) bool {
if token.Kind != ast.KindLessThanToken && token.Kind != ast.KindGreaterThanToken {
return false
}
switch parent.Kind {
case ast.KindTypeReference,
ast.KindTypeAssertionExpression,
ast.KindTypeAliasDeclaration,
ast.KindClassDeclaration,
ast.KindClassExpression,
ast.KindInterfaceDeclaration,
ast.KindFunctionDeclaration,
ast.KindFunctionExpression,
ast.KindArrowFunction,
ast.KindMethodDeclaration,
ast.KindMethodSignature,
ast.KindCallSignature,
ast.KindConstructSignature,
ast.KindCallExpression,
ast.KindNewExpression,
ast.KindExpressionWithTypeArguments:
return true
default:
return false
}
}
func isTypeArgumentOrParameterOrAssertionContext(context *formattingContext) bool {
return isTypeArgumentOrParameterOrAssertion(context.currentTokenSpan, context.currentTokenParent) ||
isTypeArgumentOrParameterOrAssertion(context.nextTokenSpan, context.nextTokenParent)
}
func isTypeAssertionContext(context *formattingContext) bool {
return context.contextNode.Kind == ast.KindTypeAssertionExpression
}
func isNonTypeAssertionContext(context *formattingContext) bool {
return !isTypeAssertionContext(context)
}
func isVoidOpContext(context *formattingContext) bool {
return context.currentTokenSpan.Kind == ast.KindVoidKeyword && context.currentTokenParent.Kind == ast.KindVoidExpression
}
func isYieldOrYieldStarWithOperand(context *formattingContext) bool {
return context.contextNode.Kind == ast.KindYieldExpression && context.contextNode.AsYieldExpression().Expression != nil
}
func isNonNullAssertionContext(context *formattingContext) bool {
return context.contextNode.Kind == ast.KindNonNullExpression
}
func isNotStatementConditionContext(context *formattingContext) bool {
return !isStatementConditionContext(context)
}
func isStatementConditionContext(context *formattingContext) bool {
switch context.contextNode.Kind {
case ast.KindIfStatement,
ast.KindForStatement,
ast.KindForInStatement,
ast.KindForOfStatement,
ast.KindDoStatement,
ast.KindWhileStatement:
return true
default:
return false
}
}
func isSemicolonDeletionContext(context *formattingContext) bool {
nextTokenKind := context.nextTokenSpan.Kind
nextTokenStart := context.nextTokenSpan.Loc.Pos()
if ast.IsTrivia(nextTokenKind) {
var nextRealToken *ast.Node
if context.nextTokenParent == context.currentTokenParent {
// !!! TODO: very different from strada, but strada's logic here is wonky - find the first ancestor without a parent? that's just the source file.
nextRealToken = astnav.FindNextToken(context.nextTokenParent, context.SourceFile.AsNode(), context.SourceFile)
} else {
nextRealToken = lsutil.GetFirstToken(context.nextTokenParent, context.SourceFile)
}
if nextRealToken == nil {
return true
}
nextTokenKind = nextRealToken.Kind
nextTokenStart = scanner.GetTokenPosOfNode(nextRealToken, context.SourceFile, false)
}
startLine, _ := scanner.GetECMALineAndCharacterOfPosition(context.SourceFile, context.currentTokenSpan.Loc.Pos())
endLine, _ := scanner.GetECMALineAndCharacterOfPosition(context.SourceFile, nextTokenStart)
if startLine == endLine {
return nextTokenKind == ast.KindCloseBraceToken || nextTokenKind == ast.KindEndOfFile
}
if nextTokenKind == ast.KindSemicolonToken &&
context.currentTokenSpan.Kind == ast.KindSemicolonToken {
return true
}
if nextTokenKind == ast.KindSemicolonClassElement ||
nextTokenKind == ast.KindSemicolonToken {
return false
}
if context.contextNode.Kind == ast.KindInterfaceDeclaration ||
context.contextNode.Kind == ast.KindTypeAliasDeclaration {
// Can't remove semicolon after `foo`; it would parse as a method declaration:
//
// interface I {
// foo;
// () void
// }
return context.currentTokenParent.Kind != ast.KindPropertySignature ||
context.currentTokenParent.Type() != nil ||
nextTokenKind != ast.KindOpenParenToken
}
if ast.IsPropertyDeclaration(context.currentTokenParent) {
return context.currentTokenParent.Initializer() == nil
}
return context.currentTokenParent.Kind != ast.KindForStatement &&
context.currentTokenParent.Kind != ast.KindEmptyStatement &&
context.currentTokenParent.Kind != ast.KindSemicolonClassElement &&
nextTokenKind != ast.KindOpenBracketToken &&
nextTokenKind != ast.KindOpenParenToken &&
nextTokenKind != ast.KindPlusToken &&
nextTokenKind != ast.KindMinusToken &&
nextTokenKind != ast.KindSlashToken &&
nextTokenKind != ast.KindRegularExpressionLiteral &&
nextTokenKind != ast.KindCommaToken &&
nextTokenKind != ast.KindTemplateExpression &&
nextTokenKind != ast.KindTemplateHead &&
nextTokenKind != ast.KindNoSubstitutionTemplateLiteral &&
nextTokenKind != ast.KindDotToken
}
func isSemicolonInsertionContext(context *formattingContext) bool {
return lsutil.PositionIsASICandidate(context.currentTokenSpan.Loc.End(), context.currentTokenParent, context.SourceFile)
}
func isNotPropertyAccessOnIntegerLiteral(context *formattingContext) bool {
return !ast.IsPropertyAccessExpression(context.contextNode) ||
!ast.IsNumericLiteral(context.contextNode.Expression()) ||
strings.Contains(context.contextNode.Expression().Text(), ".")
}

446
kitcom/internal/tsgo/format/rules.go
View File

@ -1,446 +0,0 @@
package format
import (
"slices"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/ast"
)
func getAllRules() []ruleSpec {
allTokens := make([]ast.Kind, 0, ast.KindLastToken-ast.KindFirstToken+1)
for token := ast.KindFirstToken; token <= ast.KindLastToken; token++ {
allTokens = append(allTokens, token)
}
anyTokenExcept := func(tokens ...ast.Kind) tokenRange {
newTokens := make([]ast.Kind, 0, ast.KindLastToken-ast.KindFirstToken+1)
for token := ast.KindFirstToken; token <= ast.KindLastToken; token++ {
if slices.Contains(tokens, token) {
continue
}
newTokens = append(newTokens, token)
}
return tokenRange{
isSpecific: false,
tokens: newTokens,
}
}
anyToken := tokenRange{
isSpecific: false,
tokens: allTokens,
}
anyTokenIncludingMultilineComments := tokenRangeFromEx(allTokens, ast.KindMultiLineCommentTrivia)
anyTokenIncludingEOF := tokenRangeFromEx(allTokens, ast.KindEndOfFile)
keywords := tokenRangeFromRange(ast.KindFirstKeyword, ast.KindLastKeyword)
binaryOperators := tokenRangeFromRange(ast.KindFirstBinaryOperator, ast.KindLastBinaryOperator)
binaryKeywordOperators := []ast.Kind{
ast.KindInKeyword,
ast.KindInstanceOfKeyword,
ast.KindOfKeyword,
ast.KindAsKeyword,
ast.KindIsKeyword,
ast.KindSatisfiesKeyword,
}
unaryPrefixOperators := []ast.Kind{ast.KindPlusPlusToken, ast.KindMinusToken, ast.KindTildeToken, ast.KindExclamationToken}
unaryPrefixExpressions := []ast.Kind{
ast.KindNumericLiteral,
ast.KindBigIntLiteral,
ast.KindIdentifier,
ast.KindOpenParenToken,
ast.KindOpenBracketToken,
ast.KindOpenBraceToken,
ast.KindThisKeyword,
ast.KindNewKeyword,
}
unaryPreincrementExpressions := []ast.Kind{ast.KindIdentifier, ast.KindOpenParenToken, ast.KindThisKeyword, ast.KindNewKeyword}
unaryPostincrementExpressions := []ast.Kind{ast.KindIdentifier, ast.KindCloseParenToken, ast.KindCloseBracketToken, ast.KindNewKeyword}
unaryPredecrementExpressions := []ast.Kind{ast.KindIdentifier, ast.KindOpenParenToken, ast.KindThisKeyword, ast.KindNewKeyword}
unaryPostdecrementExpressions := []ast.Kind{ast.KindIdentifier, ast.KindCloseParenToken, ast.KindCloseBracketToken, ast.KindNewKeyword}
comments := []ast.Kind{ast.KindSingleLineCommentTrivia, ast.KindMultiLineCommentTrivia}
typeKeywords := []ast.Kind{
ast.KindAnyKeyword,
ast.KindAssertsKeyword,
ast.KindBigIntKeyword,
ast.KindBooleanKeyword,
ast.KindFalseKeyword,
ast.KindInferKeyword,
ast.KindKeyOfKeyword,
ast.KindNeverKeyword,
ast.KindNullKeyword,
ast.KindNumberKeyword,
ast.KindObjectKeyword,
ast.KindReadonlyKeyword,
ast.KindStringKeyword,
ast.KindSymbolKeyword,
ast.KindTypeOfKeyword,
ast.KindTrueKeyword,
ast.KindVoidKeyword,
ast.KindUndefinedKeyword,
ast.KindUniqueKeyword,
ast.KindUnknownKeyword,
}
typeNames := append([]ast.Kind{ast.KindIdentifier}, typeKeywords...)
// Place a space before open brace in a function declaration
// TypeScript: Function can have return types, which can be made of tons of different token kinds
functionOpenBraceLeftTokenRange := anyTokenIncludingMultilineComments
// Place a space before open brace in a TypeScript declaration that has braces as children (class, module, enum, etc)
typeScriptOpenBraceLeftTokenRange := tokenRangeFrom(ast.KindIdentifier, ast.KindGreaterThanToken, ast.KindMultiLineCommentTrivia, ast.KindClassKeyword, ast.KindExportKeyword, ast.KindImportKeyword)
// Place a space before open brace in a control flow construct
controlOpenBraceLeftTokenRange := tokenRangeFrom(ast.KindCloseParenToken, ast.KindMultiLineCommentTrivia, ast.KindDoKeyword, ast.KindTryKeyword, ast.KindFinallyKeyword, ast.KindElseKeyword, ast.KindCatchKeyword)
// These rules are higher in priority than user-configurable
highPriorityCommonRules := []ruleSpec{
// Leave comments alone
rule("IgnoreBeforeComment", anyToken, comments, anyContext, ruleActionStopProcessingSpaceActions),
rule("IgnoreAfterLineComment", ast.KindSingleLineCommentTrivia, anyToken, anyContext, ruleActionStopProcessingSpaceActions),
rule("NotSpaceBeforeColon", anyToken, ast.KindColonToken, []contextPredicate{isNonJsxSameLineTokenContext, isNotBinaryOpContext, isNotTypeAnnotationContext}, ruleActionDeleteSpace),
rule("SpaceAfterColon", ast.KindColonToken, anyToken, []contextPredicate{isNonJsxSameLineTokenContext, isNotBinaryOpContext, isNextTokenParentNotJsxNamespacedName}, ruleActionInsertSpace),
rule("NoSpaceBeforeQuestionMark", anyToken, ast.KindQuestionToken, []contextPredicate{isNonJsxSameLineTokenContext, isNotBinaryOpContext, isNotTypeAnnotationContext}, ruleActionDeleteSpace),
// insert space after '?' only when it is used in conditional operator
rule("SpaceAfterQuestionMarkInConditionalOperator", ast.KindQuestionToken, anyToken, []contextPredicate{isNonJsxSameLineTokenContext, isConditionalOperatorContext}, ruleActionInsertSpace),
// in other cases there should be no space between '?' and next token
rule("NoSpaceAfterQuestionMark", ast.KindQuestionToken, anyToken, []contextPredicate{isNonJsxSameLineTokenContext, isNonOptionalPropertyContext}, ruleActionDeleteSpace),
rule("NoSpaceBeforeDot", anyToken, []ast.Kind{ast.KindDotToken, ast.KindQuestionDotToken}, []contextPredicate{isNonJsxSameLineTokenContext, isNotPropertyAccessOnIntegerLiteral}, ruleActionDeleteSpace),
rule("NoSpaceAfterDot", []ast.Kind{ast.KindDotToken, ast.KindQuestionDotToken}, anyToken, []contextPredicate{isNonJsxSameLineTokenContext}, ruleActionDeleteSpace),
rule("NoSpaceBetweenImportParenInImportType", ast.KindImportKeyword, ast.KindOpenParenToken, []contextPredicate{isNonJsxSameLineTokenContext, isImportTypeContext}, ruleActionDeleteSpace),
// Special handling of unary operators.
// Prefix operators generally shouldn't have a space between
// them and their target unary expression.
rule("NoSpaceAfterUnaryPrefixOperator", unaryPrefixOperators, unaryPrefixExpressions, []contextPredicate{isNonJsxSameLineTokenContext, isNotBinaryOpContext}, ruleActionDeleteSpace),
rule("NoSpaceAfterUnaryPreincrementOperator", ast.KindPlusPlusToken, unaryPreincrementExpressions, []contextPredicate{isNonJsxSameLineTokenContext}, ruleActionDeleteSpace),
rule("NoSpaceAfterUnaryPredecrementOperator", ast.KindMinusMinusToken, unaryPredecrementExpressions, []contextPredicate{isNonJsxSameLineTokenContext}, ruleActionDeleteSpace),
rule("NoSpaceBeforeUnaryPostincrementOperator", unaryPostincrementExpressions, ast.KindPlusPlusToken, []contextPredicate{isNonJsxSameLineTokenContext, isNotStatementConditionContext}, ruleActionDeleteSpace),
rule("NoSpaceBeforeUnaryPostdecrementOperator", unaryPostdecrementExpressions, ast.KindMinusMinusToken, []contextPredicate{isNonJsxSameLineTokenContext, isNotStatementConditionContext}, ruleActionDeleteSpace),
// More unary operator special-casing.
// DevDiv 181814: Be careful when removing leading whitespace
// around unary operators. Examples:
// 1 - -2 --X--> 1--2
// a + ++b --X--> a+++b
rule("SpaceAfterPostincrementWhenFollowedByAdd", ast.KindPlusPlusToken, ast.KindPlusToken, []contextPredicate{isNonJsxSameLineTokenContext, isBinaryOpContext}, ruleActionInsertSpace),
rule("SpaceAfterAddWhenFollowedByUnaryPlus", ast.KindPlusToken, ast.KindPlusToken, []contextPredicate{isNonJsxSameLineTokenContext, isBinaryOpContext}, ruleActionInsertSpace),
rule("SpaceAfterAddWhenFollowedByPreincrement", ast.KindPlusToken, ast.KindPlusPlusToken, []contextPredicate{isNonJsxSameLineTokenContext, isBinaryOpContext}, ruleActionInsertSpace),
rule("SpaceAfterPostdecrementWhenFollowedBySubtract", ast.KindMinusMinusToken, ast.KindMinusToken, []contextPredicate{isNonJsxSameLineTokenContext, isBinaryOpContext}, ruleActionInsertSpace),
rule("SpaceAfterSubtractWhenFollowedByUnaryMinus", ast.KindMinusToken, ast.KindMinusToken, []contextPredicate{isNonJsxSameLineTokenContext, isBinaryOpContext}, ruleActionInsertSpace),
rule("SpaceAfterSubtractWhenFollowedByPredecrement", ast.KindMinusToken, ast.KindMinusMinusToken, []contextPredicate{isNonJsxSameLineTokenContext, isBinaryOpContext}, ruleActionInsertSpace),
rule("NoSpaceAfterCloseBrace", ast.KindCloseBraceToken, []ast.Kind{ast.KindCommaToken, ast.KindSemicolonToken}, []contextPredicate{isNonJsxSameLineTokenContext}, ruleActionDeleteSpace),
// For functions and control block place } on a new line []ast.Kind{multi-line rule}
rule("NewLineBeforeCloseBraceInBlockContext", anyTokenIncludingMultilineComments, ast.KindCloseBraceToken, []contextPredicate{isMultilineBlockContext}, ruleActionInsertNewLine),
// Space/new line after }.
rule("SpaceAfterCloseBrace", ast.KindCloseBraceToken, anyTokenExcept(ast.KindCloseParenToken), []contextPredicate{isNonJsxSameLineTokenContext, isAfterCodeBlockContext}, ruleActionInsertSpace),
// Special case for (}, else) and (}, while) since else & while tokens are not part of the tree which makes SpaceAfterCloseBrace rule not applied
// Also should not apply to })
rule("SpaceBetweenCloseBraceAndElse", ast.KindCloseBraceToken, ast.KindElseKeyword, []contextPredicate{isNonJsxSameLineTokenContext}, ruleActionInsertSpace),
rule("SpaceBetweenCloseBraceAndWhile", ast.KindCloseBraceToken, ast.KindWhileKeyword, []contextPredicate{isNonJsxSameLineTokenContext}, ruleActionInsertSpace),
rule("NoSpaceBetweenEmptyBraceBrackets", ast.KindOpenBraceToken, ast.KindCloseBraceToken, []contextPredicate{isNonJsxSameLineTokenContext, isObjectContext}, ruleActionDeleteSpace),
// Add a space after control dec context if the next character is an open bracket ex: 'if (false)[]ast.Kind{a, b} = []ast.Kind{1, 2};' -> 'if (false) []ast.Kind{a, b} = []ast.Kind{1, 2};'
rule("SpaceAfterConditionalClosingParen", ast.KindCloseParenToken, ast.KindOpenBracketToken, []contextPredicate{isControlDeclContext}, ruleActionInsertSpace),
rule("NoSpaceBetweenFunctionKeywordAndStar", ast.KindFunctionKeyword, ast.KindAsteriskToken, []contextPredicate{isFunctionDeclarationOrFunctionExpressionContext}, ruleActionDeleteSpace),
rule("SpaceAfterStarInGeneratorDeclaration", ast.KindAsteriskToken, ast.KindIdentifier, []contextPredicate{isFunctionDeclarationOrFunctionExpressionContext}, ruleActionInsertSpace),
rule("SpaceAfterFunctionInFuncDecl", ast.KindFunctionKeyword, anyToken, []contextPredicate{isFunctionDeclContext}, ruleActionInsertSpace),
// Insert new line after { and before } in multi-line contexts.
rule("NewLineAfterOpenBraceInBlockContext", ast.KindOpenBraceToken, anyToken, []contextPredicate{isMultilineBlockContext}, ruleActionInsertNewLine),
// For get/set members, we check for (identifier,identifier) since get/set don't have tokens and they are represented as just an identifier token.
// Though, we do extra check on the context to make sure we are dealing with get/set node. Example:
// get x() {}
// set x(val) {}
rule("SpaceAfterGetSetInMember", []ast.Kind{ast.KindGetKeyword, ast.KindSetKeyword}, ast.KindIdentifier, []contextPredicate{isFunctionDeclContext}, ruleActionInsertSpace),
rule("NoSpaceBetweenYieldKeywordAndStar", ast.KindYieldKeyword, ast.KindAsteriskToken, []contextPredicate{isNonJsxSameLineTokenContext, isYieldOrYieldStarWithOperand}, ruleActionDeleteSpace),
rule("SpaceBetweenYieldOrYieldStarAndOperand", []ast.Kind{ast.KindYieldKeyword, ast.KindAsteriskToken}, anyToken, []contextPredicate{isNonJsxSameLineTokenContext, isYieldOrYieldStarWithOperand}, ruleActionInsertSpace),
rule("NoSpaceBetweenReturnAndSemicolon", ast.KindReturnKeyword, ast.KindSemicolonToken, []contextPredicate{isNonJsxSameLineTokenContext}, ruleActionDeleteSpace),
rule("SpaceAfterCertainKeywords", []ast.Kind{ast.KindVarKeyword, ast.KindThrowKeyword, ast.KindNewKeyword, ast.KindDeleteKeyword, ast.KindReturnKeyword, ast.KindTypeOfKeyword, ast.KindAwaitKeyword}, anyToken, []contextPredicate{isNonJsxSameLineTokenContext}, ruleActionInsertSpace),
rule("SpaceAfterLetConstInVariableDeclaration", []ast.Kind{ast.KindLetKeyword, ast.KindConstKeyword}, anyToken, []contextPredicate{isNonJsxSameLineTokenContext, isStartOfVariableDeclarationList}, ruleActionInsertSpace),
rule("NoSpaceBeforeOpenParenInFuncCall", anyToken, ast.KindOpenParenToken, []contextPredicate{isNonJsxSameLineTokenContext, isFunctionCallOrNewContext, isPreviousTokenNotComma}, ruleActionDeleteSpace),
// Special case for binary operators (that are keywords). For these we have to add a space and shouldn't follow any user options.
rule("SpaceBeforeBinaryKeywordOperator", anyToken, binaryKeywordOperators, []contextPredicate{isNonJsxSameLineTokenContext, isBinaryOpContext}, ruleActionInsertSpace),
rule("SpaceAfterBinaryKeywordOperator", binaryKeywordOperators, anyToken, []contextPredicate{isNonJsxSameLineTokenContext, isBinaryOpContext}, ruleActionInsertSpace),
rule("SpaceAfterVoidOperator", ast.KindVoidKeyword, anyToken, []contextPredicate{isNonJsxSameLineTokenContext, isVoidOpContext}, ruleActionInsertSpace),
// Async-await
rule("SpaceBetweenAsyncAndOpenParen", ast.KindAsyncKeyword, ast.KindOpenParenToken, []contextPredicate{isArrowFunctionContext, isNonJsxSameLineTokenContext}, ruleActionInsertSpace),
rule("SpaceBetweenAsyncAndFunctionKeyword", ast.KindAsyncKeyword, []ast.Kind{ast.KindFunctionKeyword, ast.KindIdentifier}, []contextPredicate{isNonJsxSameLineTokenContext}, ruleActionInsertSpace),
// Template string
rule("NoSpaceBetweenTagAndTemplateString", []ast.Kind{ast.KindIdentifier, ast.KindCloseParenToken}, []ast.Kind{ast.KindNoSubstitutionTemplateLiteral, ast.KindTemplateHead}, []contextPredicate{isNonJsxSameLineTokenContext}, ruleActionDeleteSpace),
// JSX opening elements
rule("SpaceBeforeJsxAttribute", anyToken, ast.KindIdentifier, []contextPredicate{isNextTokenParentJsxAttribute, isNonJsxSameLineTokenContext}, ruleActionInsertSpace),
rule("SpaceBeforeSlashInJsxOpeningElement", anyToken, ast.KindSlashToken, []contextPredicate{isJsxSelfClosingElementContext, isNonJsxSameLineTokenContext}, ruleActionInsertSpace),
rule("NoSpaceBeforeGreaterThanTokenInJsxOpeningElement", ast.KindSlashToken, ast.KindGreaterThanToken, []contextPredicate{isJsxSelfClosingElementContext, isNonJsxSameLineTokenContext}, ruleActionDeleteSpace),
rule("NoSpaceBeforeEqualInJsxAttribute", anyToken, ast.KindEqualsToken, []contextPredicate{isJsxAttributeContext, isNonJsxSameLineTokenContext}, ruleActionDeleteSpace),
rule("NoSpaceAfterEqualInJsxAttribute", ast.KindEqualsToken, anyToken, []contextPredicate{isJsxAttributeContext, isNonJsxSameLineTokenContext}, ruleActionDeleteSpace),
rule("NoSpaceBeforeJsxNamespaceColon", ast.KindIdentifier, ast.KindColonToken, []contextPredicate{isNextTokenParentJsxNamespacedName}, ruleActionDeleteSpace),
rule("NoSpaceAfterJsxNamespaceColon", ast.KindColonToken, ast.KindIdentifier, []contextPredicate{isNextTokenParentJsxNamespacedName}, ruleActionDeleteSpace),
// TypeScript-specific rules
// Use of module as a function call. e.g.: import m2 = module("m2");
rule("NoSpaceAfterModuleImport", []ast.Kind{ast.KindModuleKeyword, ast.KindRequireKeyword}, ast.KindOpenParenToken, []contextPredicate{isNonJsxSameLineTokenContext}, ruleActionDeleteSpace),
// Add a space around certain TypeScript keywords
rule(
"SpaceAfterCertainTypeScriptKeywords",
[]ast.Kind{
ast.KindAbstractKeyword,
ast.KindAccessorKeyword,
ast.KindClassKeyword,
ast.KindDeclareKeyword,
ast.KindDefaultKeyword,
ast.KindEnumKeyword,
ast.KindExportKeyword,
ast.KindExtendsKeyword,
ast.KindGetKeyword,
ast.KindImplementsKeyword,
ast.KindImportKeyword,
ast.KindInterfaceKeyword,
ast.KindModuleKeyword,
ast.KindNamespaceKeyword,
ast.KindPrivateKeyword,
ast.KindPublicKeyword,
ast.KindProtectedKeyword,
ast.KindReadonlyKeyword,
ast.KindSetKeyword,
ast.KindStaticKeyword,
ast.KindTypeKeyword,
ast.KindFromKeyword,
ast.KindKeyOfKeyword,
ast.KindInferKeyword,
},
anyToken,
[]contextPredicate{isNonJsxSameLineTokenContext},
ruleActionInsertSpace,
),
rule(
"SpaceBeforeCertainTypeScriptKeywords",
anyToken,
[]ast.Kind{ast.KindExtendsKeyword, ast.KindImplementsKeyword, ast.KindFromKeyword},
[]contextPredicate{isNonJsxSameLineTokenContext},
ruleActionInsertSpace,
),
// Treat string literals in module names as identifiers, and add a space between the literal and the opening Brace braces, e.g.: module "m2" {
rule("SpaceAfterModuleName", ast.KindStringLiteral, ast.KindOpenBraceToken, []contextPredicate{isModuleDeclContext}, ruleActionInsertSpace),
// Lambda expressions
rule("SpaceBeforeArrow", anyToken, ast.KindEqualsGreaterThanToken, []contextPredicate{isNonJsxSameLineTokenContext}, ruleActionInsertSpace),
rule("SpaceAfterArrow", ast.KindEqualsGreaterThanToken, anyToken, []contextPredicate{isNonJsxSameLineTokenContext}, ruleActionInsertSpace),
// Optional parameters and let args
rule("NoSpaceAfterEllipsis", ast.KindDotDotDotToken, ast.KindIdentifier, []contextPredicate{isNonJsxSameLineTokenContext}, ruleActionDeleteSpace),
rule("NoSpaceAfterOptionalParameters", ast.KindQuestionToken, []ast.Kind{ast.KindCloseParenToken, ast.KindCommaToken}, []contextPredicate{isNonJsxSameLineTokenContext, isNotBinaryOpContext}, ruleActionDeleteSpace),
// Remove spaces in empty interface literals. e.g.: x: {}
rule("NoSpaceBetweenEmptyInterfaceBraceBrackets", ast.KindOpenBraceToken, ast.KindCloseBraceToken, []contextPredicate{isNonJsxSameLineTokenContext, isObjectTypeContext}, ruleActionDeleteSpace),
// generics and type assertions
rule("NoSpaceBeforeOpenAngularBracket", typeNames, ast.KindLessThanToken, []contextPredicate{isNonJsxSameLineTokenContext, isTypeArgumentOrParameterOrAssertionContext}, ruleActionDeleteSpace),
rule("NoSpaceBetweenCloseParenAndAngularBracket", ast.KindCloseParenToken, ast.KindLessThanToken, []contextPredicate{isNonJsxSameLineTokenContext, isTypeArgumentOrParameterOrAssertionContext}, ruleActionDeleteSpace),
rule("NoSpaceAfterOpenAngularBracket", ast.KindLessThanToken, anyToken, []contextPredicate{isNonJsxSameLineTokenContext, isTypeArgumentOrParameterOrAssertionContext}, ruleActionDeleteSpace),
rule("NoSpaceBeforeCloseAngularBracket", anyToken, ast.KindGreaterThanToken, []contextPredicate{isNonJsxSameLineTokenContext, isTypeArgumentOrParameterOrAssertionContext}, ruleActionDeleteSpace),
rule("NoSpaceAfterCloseAngularBracket", ast.KindGreaterThanToken, []ast.Kind{ast.KindOpenParenToken, ast.KindOpenBracketToken, ast.KindGreaterThanToken, ast.KindCommaToken}, []contextPredicate{
isNonJsxSameLineTokenContext,
isTypeArgumentOrParameterOrAssertionContext,
isNotFunctionDeclContext, /*To prevent an interference with the SpaceBeforeOpenParenInFuncDecl rule*/
isNonTypeAssertionContext,
}, ruleActionDeleteSpace),
// decorators
rule("SpaceBeforeAt", []ast.Kind{ast.KindCloseParenToken, ast.KindIdentifier}, ast.KindAtToken, []contextPredicate{isNonJsxSameLineTokenContext}, ruleActionInsertSpace),
rule("NoSpaceAfterAt", ast.KindAtToken, anyToken, []contextPredicate{isNonJsxSameLineTokenContext}, ruleActionDeleteSpace),
// Insert space after @ in decorator
rule(
"SpaceAfterDecorator",
anyToken,
[]ast.Kind{
ast.KindAbstractKeyword,
ast.KindIdentifier,
ast.KindExportKeyword,
ast.KindDefaultKeyword,
ast.KindClassKeyword,
ast.KindStaticKeyword,
ast.KindPublicKeyword,
ast.KindPrivateKeyword,
ast.KindProtectedKeyword,
ast.KindGetKeyword,
ast.KindSetKeyword,
ast.KindOpenBracketToken,
ast.KindAsteriskToken,
},
[]contextPredicate{isEndOfDecoratorContextOnSameLine},
ruleActionInsertSpace,
),
rule("NoSpaceBeforeNonNullAssertionOperator", anyToken, ast.KindExclamationToken, []contextPredicate{isNonJsxSameLineTokenContext, isNonNullAssertionContext}, ruleActionDeleteSpace),
rule("NoSpaceAfterNewKeywordOnConstructorSignature", ast.KindNewKeyword, ast.KindOpenParenToken, []contextPredicate{isNonJsxSameLineTokenContext, isConstructorSignatureContext}, ruleActionDeleteSpace),
rule("SpaceLessThanAndNonJSXTypeAnnotation", ast.KindLessThanToken, ast.KindLessThanToken, []contextPredicate{isNonJsxSameLineTokenContext}, ruleActionInsertSpace),
}
// These rules are applied after high priority
userConfigurableRules := []ruleSpec{
// Treat constructor as an identifier in a function declaration, and remove spaces between constructor and following left parentheses
rule("SpaceAfterConstructor", ast.KindConstructorKeyword, ast.KindOpenParenToken, []contextPredicate{isOptionEnabled(insertSpaceAfterConstructorOption), isNonJsxSameLineTokenContext}, ruleActionInsertSpace),
rule("NoSpaceAfterConstructor", ast.KindConstructorKeyword, ast.KindOpenParenToken, []contextPredicate{isOptionDisabledOrUndefined(insertSpaceAfterConstructorOption), isNonJsxSameLineTokenContext}, ruleActionDeleteSpace),
rule("SpaceAfterComma", ast.KindCommaToken, anyToken, []contextPredicate{isOptionEnabled(insertSpaceAfterCommaDelimiterOption), isNonJsxSameLineTokenContext, isNonJsxElementOrFragmentContext, isNextTokenNotCloseBracket, isNextTokenNotCloseParen}, ruleActionInsertSpace),
rule("NoSpaceAfterComma", ast.KindCommaToken, anyToken, []contextPredicate{isOptionDisabledOrUndefined(insertSpaceAfterCommaDelimiterOption), isNonJsxSameLineTokenContext, isNonJsxElementOrFragmentContext}, ruleActionDeleteSpace),
// Insert space after function keyword for anonymous functions
rule("SpaceAfterAnonymousFunctionKeyword", []ast.Kind{ast.KindFunctionKeyword, ast.KindAsteriskToken}, ast.KindOpenParenToken, []contextPredicate{isOptionEnabled(insertSpaceAfterFunctionKeywordForAnonymousFunctionsOption), isFunctionDeclContext}, ruleActionInsertSpace),
rule("NoSpaceAfterAnonymousFunctionKeyword", []ast.Kind{ast.KindFunctionKeyword, ast.KindAsteriskToken}, ast.KindOpenParenToken, []contextPredicate{isOptionDisabledOrUndefined(insertSpaceAfterFunctionKeywordForAnonymousFunctionsOption), isFunctionDeclContext}, ruleActionDeleteSpace),
// Insert space after keywords in control flow statements
rule("SpaceAfterKeywordInControl", keywords, ast.KindOpenParenToken, []contextPredicate{isOptionEnabled(insertSpaceAfterKeywordsInControlFlowStatementsOption), isControlDeclContext}, ruleActionInsertSpace),
rule("NoSpaceAfterKeywordInControl", keywords, ast.KindOpenParenToken, []contextPredicate{isOptionDisabledOrUndefined(insertSpaceAfterKeywordsInControlFlowStatementsOption), isControlDeclContext}, ruleActionDeleteSpace),
// Insert space after opening and before closing nonempty parenthesis
rule("SpaceAfterOpenParen", ast.KindOpenParenToken, anyToken, []contextPredicate{isOptionEnabled(insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesisOption), isNonJsxSameLineTokenContext}, ruleActionInsertSpace),
rule("SpaceBeforeCloseParen", anyToken, ast.KindCloseParenToken, []contextPredicate{isOptionEnabled(insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesisOption), isNonJsxSameLineTokenContext}, ruleActionInsertSpace),
rule("SpaceBetweenOpenParens", ast.KindOpenParenToken, ast.KindOpenParenToken, []contextPredicate{isOptionEnabled(insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesisOption), isNonJsxSameLineTokenContext}, ruleActionInsertSpace),
rule("NoSpaceBetweenParens", ast.KindOpenParenToken, ast.KindCloseParenToken, []contextPredicate{isNonJsxSameLineTokenContext}, ruleActionDeleteSpace),
rule("NoSpaceAfterOpenParen", ast.KindOpenParenToken, anyToken, []contextPredicate{isOptionDisabledOrUndefined(insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesisOption), isNonJsxSameLineTokenContext}, ruleActionDeleteSpace),
rule("NoSpaceBeforeCloseParen", anyToken, ast.KindCloseParenToken, []contextPredicate{isOptionDisabledOrUndefined(insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesisOption), isNonJsxSameLineTokenContext}, ruleActionDeleteSpace),
// Insert space after opening and before closing nonempty brackets
rule("SpaceAfterOpenBracket", ast.KindOpenBracketToken, anyToken, []contextPredicate{isOptionEnabled(insertSpaceAfterOpeningAndBeforeClosingNonemptyBracketsOption), isNonJsxSameLineTokenContext}, ruleActionInsertSpace),
rule("SpaceBeforeCloseBracket", anyToken, ast.KindCloseBracketToken, []contextPredicate{isOptionEnabled(insertSpaceAfterOpeningAndBeforeClosingNonemptyBracketsOption), isNonJsxSameLineTokenContext}, ruleActionInsertSpace),
rule("NoSpaceBetweenBrackets", ast.KindOpenBracketToken, ast.KindCloseBracketToken, []contextPredicate{isNonJsxSameLineTokenContext}, ruleActionDeleteSpace),
rule("NoSpaceAfterOpenBracket", ast.KindOpenBracketToken, anyToken, []contextPredicate{isOptionDisabledOrUndefined(insertSpaceAfterOpeningAndBeforeClosingNonemptyBracketsOption), isNonJsxSameLineTokenContext}, ruleActionDeleteSpace),
rule("NoSpaceBeforeCloseBracket", anyToken, ast.KindCloseBracketToken, []contextPredicate{isOptionDisabledOrUndefined(insertSpaceAfterOpeningAndBeforeClosingNonemptyBracketsOption), isNonJsxSameLineTokenContext}, ruleActionDeleteSpace),
// Insert a space after { and before } in single-line contexts, but remove space from empty object literals {}.
rule("SpaceAfterOpenBrace", ast.KindOpenBraceToken, anyToken, []contextPredicate{isOptionEnabledOrUndefined(insertSpaceAfterOpeningAndBeforeClosingNonemptyBracesOption), isBraceWrappedContext}, ruleActionInsertSpace),
rule("SpaceBeforeCloseBrace", anyToken, ast.KindCloseBraceToken, []contextPredicate{isOptionEnabledOrUndefined(insertSpaceAfterOpeningAndBeforeClosingNonemptyBracesOption), isBraceWrappedContext}, ruleActionInsertSpace),
rule("NoSpaceBetweenEmptyBraceBrackets", ast.KindOpenBraceToken, ast.KindCloseBraceToken, []contextPredicate{isNonJsxSameLineTokenContext, isObjectContext}, ruleActionDeleteSpace),
rule("NoSpaceAfterOpenBrace", ast.KindOpenBraceToken, anyToken, []contextPredicate{isOptionDisabled(insertSpaceAfterOpeningAndBeforeClosingNonemptyBracesOption), isNonJsxSameLineTokenContext}, ruleActionDeleteSpace),
rule("NoSpaceBeforeCloseBrace", anyToken, ast.KindCloseBraceToken, []contextPredicate{isOptionDisabled(insertSpaceAfterOpeningAndBeforeClosingNonemptyBracesOption), isNonJsxSameLineTokenContext}, ruleActionDeleteSpace),
// Insert a space after opening and before closing empty brace brackets
rule("SpaceBetweenEmptyBraceBrackets", ast.KindOpenBraceToken, ast.KindCloseBraceToken, []contextPredicate{isOptionEnabled(insertSpaceAfterOpeningAndBeforeClosingEmptyBracesOption)}, ruleActionInsertSpace),
rule("NoSpaceBetweenEmptyBraceBrackets", ast.KindOpenBraceToken, ast.KindCloseBraceToken, []contextPredicate{isOptionDisabled(insertSpaceAfterOpeningAndBeforeClosingEmptyBracesOption), isNonJsxSameLineTokenContext}, ruleActionDeleteSpace),
// Insert space after opening and before closing template string braces
rule("SpaceAfterTemplateHeadAndMiddle", []ast.Kind{ast.KindTemplateHead, ast.KindTemplateMiddle}, anyToken, []contextPredicate{isOptionEnabled(insertSpaceAfterOpeningAndBeforeClosingTemplateStringBracesOption), isNonJsxTextContext}, ruleActionInsertSpace, ruleFlagsCanDeleteNewLines),
rule("SpaceBeforeTemplateMiddleAndTail", anyToken, []ast.Kind{ast.KindTemplateMiddle, ast.KindTemplateTail}, []contextPredicate{isOptionEnabled(insertSpaceAfterOpeningAndBeforeClosingTemplateStringBracesOption), isNonJsxSameLineTokenContext}, ruleActionInsertSpace),
rule("NoSpaceAfterTemplateHeadAndMiddle", []ast.Kind{ast.KindTemplateHead, ast.KindTemplateMiddle}, anyToken, []contextPredicate{isOptionDisabledOrUndefined(insertSpaceAfterOpeningAndBeforeClosingTemplateStringBracesOption), isNonJsxTextContext}, ruleActionDeleteSpace, ruleFlagsCanDeleteNewLines),
rule("NoSpaceBeforeTemplateMiddleAndTail", anyToken, []ast.Kind{ast.KindTemplateMiddle, ast.KindTemplateTail}, []contextPredicate{isOptionDisabledOrUndefined(insertSpaceAfterOpeningAndBeforeClosingTemplateStringBracesOption), isNonJsxSameLineTokenContext}, ruleActionDeleteSpace),
// No space after { and before } in JSX expression
rule("SpaceAfterOpenBraceInJsxExpression", ast.KindOpenBraceToken, anyToken, []contextPredicate{isOptionEnabled(insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBracesOption), isNonJsxSameLineTokenContext, isJsxExpressionContext}, ruleActionInsertSpace),
rule("SpaceBeforeCloseBraceInJsxExpression", anyToken, ast.KindCloseBraceToken, []contextPredicate{isOptionEnabled(insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBracesOption), isNonJsxSameLineTokenContext, isJsxExpressionContext}, ruleActionInsertSpace),
rule("NoSpaceAfterOpenBraceInJsxExpression", ast.KindOpenBraceToken, anyToken, []contextPredicate{isOptionDisabledOrUndefined(insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBracesOption), isNonJsxSameLineTokenContext, isJsxExpressionContext}, ruleActionDeleteSpace),
rule("NoSpaceBeforeCloseBraceInJsxExpression", anyToken, ast.KindCloseBraceToken, []contextPredicate{isOptionDisabledOrUndefined(insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBracesOption), isNonJsxSameLineTokenContext, isJsxExpressionContext}, ruleActionDeleteSpace),
// Insert space after semicolon in for statement
rule("SpaceAfterSemicolonInFor", ast.KindSemicolonToken, anyToken, []contextPredicate{isOptionEnabled(insertSpaceAfterSemicolonInForStatementsOption), isNonJsxSameLineTokenContext, isForContext}, ruleActionInsertSpace),
rule("NoSpaceAfterSemicolonInFor", ast.KindSemicolonToken, anyToken, []contextPredicate{isOptionDisabledOrUndefined(insertSpaceAfterSemicolonInForStatementsOption), isNonJsxSameLineTokenContext, isForContext}, ruleActionDeleteSpace),
// Insert space before and after binary operators
rule("SpaceBeforeBinaryOperator", anyToken, binaryOperators, []contextPredicate{isOptionEnabled(insertSpaceBeforeAndAfterBinaryOperatorsOption), isNonJsxSameLineTokenContext, isBinaryOpContext}, ruleActionInsertSpace),
rule("SpaceAfterBinaryOperator", binaryOperators, anyToken, []contextPredicate{isOptionEnabled(insertSpaceBeforeAndAfterBinaryOperatorsOption), isNonJsxSameLineTokenContext, isBinaryOpContext}, ruleActionInsertSpace),
rule("NoSpaceBeforeBinaryOperator", anyToken, binaryOperators, []contextPredicate{isOptionDisabledOrUndefined(insertSpaceBeforeAndAfterBinaryOperatorsOption), isNonJsxSameLineTokenContext, isBinaryOpContext}, ruleActionDeleteSpace),
rule("NoSpaceAfterBinaryOperator", binaryOperators, anyToken, []contextPredicate{isOptionDisabledOrUndefined(insertSpaceBeforeAndAfterBinaryOperatorsOption), isNonJsxSameLineTokenContext, isBinaryOpContext}, ruleActionDeleteSpace),
rule("SpaceBeforeOpenParenInFuncDecl", anyToken, ast.KindOpenParenToken, []contextPredicate{isOptionEnabled(insertSpaceBeforeFunctionParenthesisOption), isNonJsxSameLineTokenContext, isFunctionDeclContext}, ruleActionInsertSpace),
rule("NoSpaceBeforeOpenParenInFuncDecl", anyToken, ast.KindOpenParenToken, []contextPredicate{isOptionDisabledOrUndefined(insertSpaceBeforeFunctionParenthesisOption), isNonJsxSameLineTokenContext, isFunctionDeclContext}, ruleActionDeleteSpace),
// Open Brace braces after control block
rule("NewLineBeforeOpenBraceInControl", controlOpenBraceLeftTokenRange, ast.KindOpenBraceToken, []contextPredicate{isOptionEnabled(placeOpenBraceOnNewLineForControlBlocksOption), isControlDeclContext, isBeforeMultilineBlockContext}, ruleActionInsertNewLine, ruleFlagsCanDeleteNewLines),
// Open Brace braces after function
// TypeScript: Function can have return types, which can be made of tons of different token kinds
rule("NewLineBeforeOpenBraceInFunction", functionOpenBraceLeftTokenRange, ast.KindOpenBraceToken, []contextPredicate{isOptionEnabled(placeOpenBraceOnNewLineForFunctionsOption), isFunctionDeclContext, isBeforeMultilineBlockContext}, ruleActionInsertNewLine, ruleFlagsCanDeleteNewLines),
// Open Brace braces after TypeScript module/class/interface
rule("NewLineBeforeOpenBraceInTypeScriptDeclWithBlock", typeScriptOpenBraceLeftTokenRange, ast.KindOpenBraceToken, []contextPredicate{isOptionEnabled(placeOpenBraceOnNewLineForFunctionsOption), isTypeScriptDeclWithBlockContext, isBeforeMultilineBlockContext}, ruleActionInsertNewLine, ruleFlagsCanDeleteNewLines),
rule("SpaceAfterTypeAssertion", ast.KindGreaterThanToken, anyToken, []contextPredicate{isOptionEnabled(insertSpaceAfterTypeAssertionOption), isNonJsxSameLineTokenContext, isTypeAssertionContext}, ruleActionInsertSpace),
rule("NoSpaceAfterTypeAssertion", ast.KindGreaterThanToken, anyToken, []contextPredicate{isOptionDisabledOrUndefined(insertSpaceAfterTypeAssertionOption), isNonJsxSameLineTokenContext, isTypeAssertionContext}, ruleActionDeleteSpace),
rule("SpaceBeforeTypeAnnotation", anyToken, []ast.Kind{ast.KindQuestionToken, ast.KindColonToken}, []contextPredicate{isOptionEnabled(insertSpaceBeforeTypeAnnotationOption), isNonJsxSameLineTokenContext, isTypeAnnotationContext}, ruleActionInsertSpace),
rule("NoSpaceBeforeTypeAnnotation", anyToken, []ast.Kind{ast.KindQuestionToken, ast.KindColonToken}, []contextPredicate{isOptionDisabledOrUndefined(insertSpaceBeforeTypeAnnotationOption), isNonJsxSameLineTokenContext, isTypeAnnotationContext}, ruleActionDeleteSpace),
rule("NoOptionalSemicolon", ast.KindSemicolonToken, anyTokenIncludingEOF, []contextPredicate{optionEquals(semicolonOption, SemicolonPreferenceRemove), isSemicolonDeletionContext}, ruleActionDeleteToken),
rule("OptionalSemicolon", anyToken, anyTokenIncludingEOF, []contextPredicate{optionEquals(semicolonOption, SemicolonPreferenceInsert), isSemicolonInsertionContext}, ruleActionInsertTrailingSemicolon),
}
// These rules are lower in priority than user-configurable. Rules earlier in this list have priority over rules later in the list.
lowPriorityCommonRules := []ruleSpec{
// Space after keyword but not before ; or : or ?
rule("NoSpaceBeforeSemicolon", anyToken, ast.KindSemicolonToken, []contextPredicate{isNonJsxSameLineTokenContext}, ruleActionDeleteSpace),
rule("SpaceBeforeOpenBraceInControl", controlOpenBraceLeftTokenRange, ast.KindOpenBraceToken, []contextPredicate{isOptionDisabledOrUndefinedOrTokensOnSameLine(placeOpenBraceOnNewLineForControlBlocksOption), isControlDeclContext, isNotFormatOnEnter, isSameLineTokenOrBeforeBlockContext}, ruleActionInsertSpace, ruleFlagsCanDeleteNewLines),
rule("SpaceBeforeOpenBraceInFunction", functionOpenBraceLeftTokenRange, ast.KindOpenBraceToken, []contextPredicate{isOptionDisabledOrUndefinedOrTokensOnSameLine(placeOpenBraceOnNewLineForFunctionsOption), isFunctionDeclContext, isBeforeBlockContext, isNotFormatOnEnter, isSameLineTokenOrBeforeBlockContext}, ruleActionInsertSpace, ruleFlagsCanDeleteNewLines),
rule("SpaceBeforeOpenBraceInTypeScriptDeclWithBlock", typeScriptOpenBraceLeftTokenRange, ast.KindOpenBraceToken, []contextPredicate{isOptionDisabledOrUndefinedOrTokensOnSameLine(placeOpenBraceOnNewLineForFunctionsOption), isTypeScriptDeclWithBlockContext, isNotFormatOnEnter, isSameLineTokenOrBeforeBlockContext}, ruleActionInsertSpace, ruleFlagsCanDeleteNewLines),
rule("NoSpaceBeforeComma", anyToken, ast.KindCommaToken, []contextPredicate{isNonJsxSameLineTokenContext}, ruleActionDeleteSpace),
// No space before and after indexer `x[]ast.Kind{}`
rule("NoSpaceBeforeOpenBracket", anyTokenExcept(ast.KindAsyncKeyword, ast.KindCaseKeyword), ast.KindOpenBracketToken, []contextPredicate{isNonJsxSameLineTokenContext}, ruleActionDeleteSpace),
rule("NoSpaceAfterCloseBracket", ast.KindCloseBracketToken, anyToken, []contextPredicate{isNonJsxSameLineTokenContext, isNotBeforeBlockInFunctionDeclarationContext}, ruleActionDeleteSpace),
rule("SpaceAfterSemicolon", ast.KindSemicolonToken, anyToken, []contextPredicate{isNonJsxSameLineTokenContext}, ruleActionInsertSpace),
// Remove extra space between for and await
rule("SpaceBetweenForAndAwaitKeyword", ast.KindForKeyword, ast.KindAwaitKeyword, []contextPredicate{isNonJsxSameLineTokenContext}, ruleActionInsertSpace),
// Remove extra spaces between ... and type name in tuple spread
rule("SpaceBetweenDotDotDotAndTypeName", ast.KindDotDotDotToken, typeNames, []contextPredicate{isNonJsxSameLineTokenContext}, ruleActionDeleteSpace),
// Add a space between statements. All keywords except (do,else,case) has open/close parens after them.
// So, we have a rule to add a space for []ast.Kind{),Any}, []ast.Kind{do,Any}, []ast.Kind{else,Any}, and []ast.Kind{case,Any}
rule(
"SpaceBetweenStatements",
[]ast.Kind{ast.KindCloseParenToken, ast.KindDoKeyword, ast.KindElseKeyword, ast.KindCaseKeyword},
anyToken,
[]contextPredicate{isNonJsxSameLineTokenContext, isNonJsxElementOrFragmentContext, isNotForContext},
ruleActionInsertSpace,
),
// This low-pri rule takes care of "try {", "catch {" and "finally {" in case the rule SpaceBeforeOpenBraceInControl didn't execute on FormatOnEnter.
rule("SpaceAfterTryCatchFinally", []ast.Kind{ast.KindTryKeyword, ast.KindCatchKeyword, ast.KindFinallyKeyword}, ast.KindOpenBraceToken, []contextPredicate{isNonJsxSameLineTokenContext}, ruleActionInsertSpace),
}
result := make([]ruleSpec, 0, len(highPriorityCommonRules)+len(userConfigurableRules)+len(lowPriorityCommonRules))
result = append(result, highPriorityCommonRules...)
result = append(result, userConfigurableRules...)
result = append(result, lowPriorityCommonRules...)
return result
}
func tokenRangeFrom(tokens ...ast.Kind) tokenRange {
return tokenRange{
isSpecific: true,
tokens: tokens,
}
}
func tokenRangeFromEx(prefix []ast.Kind, tokens ...ast.Kind) tokenRange {
tokens = append(prefix, tokens...)
return tokenRange{
isSpecific: true,
tokens: tokens,
}
}
func tokenRangeFromRange(start ast.Kind, end ast.Kind) tokenRange {
tokens := make([]ast.Kind, 0, end-start+1)
for token := start; token <= end; token++ {
tokens = append(tokens, token)
}
return tokenRangeFrom(tokens...)
}

156
kitcom/internal/tsgo/format/rulesmap.go
View File

@ -1,156 +0,0 @@
package format
import (
"slices"
"sync"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/ast"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/debug"
)
func getRules(context *formattingContext, rules []*ruleImpl) []*ruleImpl {
bucket := getRulesMap()[getRuleBucketIndex(context.currentTokenSpan.Kind, context.nextTokenSpan.Kind)]
if len(bucket) > 0 {
ruleActionMask := ruleActionNone
outer:
for _, rule := range bucket {
acceptRuleActions := ^getRuleActionExclusion(ruleActionMask)
if rule.Action()&acceptRuleActions != 0 {
preds := rule.Context()
for _, p := range preds {
if !p(context) {
continue outer
}
}
rules = append(rules, rule)
ruleActionMask |= rule.Action()
}
}
return rules
}
return rules
}
func getRuleBucketIndex(row ast.Kind, column ast.Kind) int {
debug.Assert(row <= ast.KindLastKeyword && column <= ast.KindLastKeyword, "Must compute formatting context from tokens")
return (int(row) * mapRowLength) + int(column)
}
const (
maskBitSize = 5
mask = 0b11111 // MaskBitSize bits
mapRowLength = int(ast.KindLastToken) + 1
)
/**
* For a given rule action, gets a mask of other rule actions that
* cannot be applied at the same position.
*/
func getRuleActionExclusion(ruleAction ruleAction) ruleAction {
mask := ruleActionNone
if ruleAction&ruleActionStopProcessingSpaceActions != 0 {
mask |= ruleActionModifySpaceAction
}
if ruleAction&ruleActionStopProcessingTokenActions != 0 {
mask |= ruleActionModifyTokenAction
}
if ruleAction&ruleActionModifySpaceAction != 0 {
mask |= ruleActionModifySpaceAction
}
if ruleAction&ruleActionModifyTokenAction != 0 {
mask |= ruleActionModifyTokenAction
}
return mask
}
var getRulesMap = sync.OnceValue(buildRulesMap)
func buildRulesMap() [][]*ruleImpl {
rules := getAllRules()
// Map from bucket index to array of rules
m := make([][]*ruleImpl, mapRowLength*mapRowLength)
// This array is used only during construction of the rulesbucket in the map
rulesBucketConstructionStateList := make([]int, len(m))
for _, rule := range rules {
specificRule := rule.leftTokenRange.isSpecific && rule.rightTokenRange.isSpecific
for _, left := range rule.leftTokenRange.tokens {
for _, right := range rule.rightTokenRange.tokens {
index := getRuleBucketIndex(left, right)
m[index] = addRule(m[index], rule.rule, specificRule, rulesBucketConstructionStateList, index)
}
}
}
return m
}
type RulesPosition int
const (
RulesPositionStopRulesSpecific RulesPosition = 0
RulesPositionStopRulesAny RulesPosition = maskBitSize * 1
RulesPositionContextRulesSpecific RulesPosition = maskBitSize * 2
RulesPositionContextRulesAny RulesPosition = maskBitSize * 3
RulesPositionNoContextRulesSpecific RulesPosition = maskBitSize * 4
RulesPositionNoContextRulesAny RulesPosition = maskBitSize * 5
)
// The Rules list contains all the inserted rules into a rulebucket in the following order:
//
// 1- Ignore rules with specific token combination
// 2- Ignore rules with any token combination
// 3- Context rules with specific token combination
// 4- Context rules with any token combination
// 5- Non-context rules with specific token combination
// 6- Non-context rules with any token combination
//
// The member rulesInsertionIndexBitmap is used to describe the number of rules
// in each sub-bucket (above) hence can be used to know the index of where to insert
// the next rule. It's a bitmap which contains 6 different sections each is given 5 bits.
//
// Example:
// In order to insert a rule to the end of sub-bucket (3), we get the index by adding
// the values in the bitmap segments 3rd, 2nd, and 1st.
func addRule(rules []*ruleImpl, rule *ruleImpl, specificTokens bool, constructionState []int, rulesBucketIndex int) []*ruleImpl {
var position RulesPosition
if rule.Action()&ruleActionStopAction != 0 {
if specificTokens {
position = RulesPositionStopRulesSpecific
} else {
position = RulesPositionStopRulesAny
}
} else if len(rule.Context()) != 0 {
if specificTokens {
position = RulesPositionContextRulesSpecific
} else {
position = RulesPositionContextRulesAny
}
} else {
if specificTokens {
position = RulesPositionNoContextRulesSpecific
} else {
position = RulesPositionNoContextRulesAny
}
}
state := constructionState[rulesBucketIndex]
rules = slices.Insert(rules, getRuleInsertionIndex(state, position), rule)
constructionState[rulesBucketIndex] = increaseInsertionIndex(state, position)
return rules
}
func getRuleInsertionIndex(indexBitmap int, maskPosition RulesPosition) int {
index := 0
for pos := 0; pos <= int(maskPosition); pos += maskBitSize {
index += indexBitmap & mask
indexBitmap >>= maskBitSize
}
return index
}
func increaseInsertionIndex(indexBitmap int, maskPosition RulesPosition) int {
value := ((indexBitmap >> maskPosition) & mask) + 1
debug.Assert((value&mask) == value, "Adding more rules into the sub-bucket than allowed. Maximum allowed is 32 rules.")
return (indexBitmap & ^(mask << maskPosition)) | (value << maskPosition)
}

355
kitcom/internal/tsgo/format/scanner.go
View File

@ -1,355 +0,0 @@
package format
import (
"slices"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/ast"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/core"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/debug"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/scanner"
)
type TextRangeWithKind struct {
Loc core.TextRange
Kind ast.Kind
}
func NewTextRangeWithKind(pos int, end int, kind ast.Kind) TextRangeWithKind {
return TextRangeWithKind{
Loc: core.NewTextRange(pos, end),
Kind: kind,
}
}
type tokenInfo struct {
leadingTrivia []TextRangeWithKind
token TextRangeWithKind
trailingTrivia []TextRangeWithKind
}
type formattingScanner struct {
s *scanner.Scanner
startPos int
endPos int
savedPos int
hasLastTokenInfo bool
lastTokenInfo tokenInfo
lastScanAction scanAction
leadingTrivia []TextRangeWithKind
trailingTrivia []TextRangeWithKind
wasNewLine bool
}
func newFormattingScanner(text string, languageVariant core.LanguageVariant, startPos int, endPos int, worker *formatSpanWorker) []core.TextChange {
scan := scanner.NewScanner()
scan.Reset()
scan.SetSkipTrivia(false)
scan.SetLanguageVariant(languageVariant)
scan.SetText(text)
fmtScn := &formattingScanner{
s: scan,
startPos: startPos,
endPos: endPos,
wasNewLine: true,
}
res := worker.execute(fmtScn)
fmtScn.hasLastTokenInfo = false
scan.Reset()
return res
}
func (s *formattingScanner) advance() {
s.hasLastTokenInfo = false
isStarted := s.s.TokenFullStart() != s.startPos
if isStarted {
s.wasNewLine = len(s.trailingTrivia) > 0 && core.LastOrNil(s.trailingTrivia).Kind == ast.KindNewLineTrivia
} else {
s.s.Scan()
}
s.leadingTrivia = nil
s.trailingTrivia = nil
pos := s.s.TokenFullStart()
// Read leading trivia and token
for pos < s.endPos {
t := s.s.Token()
if !ast.IsTrivia(t) {
break
}
// consume leading trivia
s.s.Scan()
item := NewTextRangeWithKind(pos, s.s.TokenFullStart(), t)
pos = s.s.TokenFullStart()
s.leadingTrivia = append(s.leadingTrivia, item)
}
s.savedPos = s.s.TokenFullStart()
}
func shouldRescanGreaterThanToken(node *ast.Node) bool {
switch node.Kind {
case ast.KindGreaterThanEqualsToken,
ast.KindGreaterThanGreaterThanEqualsToken,
ast.KindGreaterThanGreaterThanGreaterThanEqualsToken,
ast.KindGreaterThanGreaterThanGreaterThanToken,
ast.KindGreaterThanGreaterThanToken:
return true
}
return false
}
func shouldRescanJsxIdentifier(node *ast.Node) bool {
if node.Parent != nil {
switch node.Parent.Kind {
case ast.KindJsxAttribute,
ast.KindJsxOpeningElement,
ast.KindJsxClosingElement,
ast.KindJsxSelfClosingElement:
// May parse an identifier like `module-layout`; that will be scanned as a keyword at first, but we should parse the whole thing to get an identifier.
return ast.IsKeywordKind(node.Kind) || node.Kind == ast.KindIdentifier
}
}
return false
}
func (s *formattingScanner) shouldRescanJsxText(node *ast.Node) bool {
if ast.IsJsxText(node) {
return true
}
if !ast.IsJsxElement(node) || s.hasLastTokenInfo == false {
return false
}
return s.lastTokenInfo.token.Kind == ast.KindJsxText
}
func shouldRescanSlashToken(container *ast.Node) bool {
return container.Kind == ast.KindRegularExpressionLiteral
}
func shouldRescanTemplateToken(container *ast.Node) bool {
return container.Kind == ast.KindTemplateMiddle ||
container.Kind == ast.KindTemplateTail
}
func shouldRescanJsxAttributeValue(node *ast.Node) bool {
return node.Parent != nil && ast.IsJsxAttribute(node.Parent) && node.Parent.Initializer() == node
}
func startsWithSlashToken(t ast.Kind) bool {
return t == ast.KindSlashToken || t == ast.KindSlashEqualsToken
}
type scanAction int
const (
actionScan scanAction = iota
actionRescanGreaterThanToken
actionRescanSlashToken
actionRescanTemplateToken
actionRescanJsxIdentifier
actionRescanJsxText
actionRescanJsxAttributeValue
)
func fixTokenKind(tokenInfo tokenInfo, container *ast.Node) tokenInfo {
if ast.IsTokenKind(container.Kind) && tokenInfo.token.Kind != container.Kind {
tokenInfo.token.Kind = container.Kind
}
return tokenInfo
}
func (s *formattingScanner) readTokenInfo(n *ast.Node) tokenInfo {
debug.Assert(s.isOnToken())
// normally scanner returns the smallest available token
// check the kind of context node to determine if scanner should have more greedy behavior and consume more text.
var expectedScanAction scanAction
if shouldRescanGreaterThanToken(n) {
expectedScanAction = actionRescanGreaterThanToken
} else if shouldRescanSlashToken(n) {
expectedScanAction = actionRescanSlashToken
} else if shouldRescanTemplateToken(n) {
expectedScanAction = actionRescanTemplateToken
} else if shouldRescanJsxIdentifier(n) {
expectedScanAction = actionRescanJsxIdentifier
} else if s.shouldRescanJsxText(n) {
expectedScanAction = actionRescanJsxText
} else if shouldRescanJsxAttributeValue(n) {
expectedScanAction = actionRescanJsxAttributeValue
} else {
expectedScanAction = actionScan
}
if s.hasLastTokenInfo && expectedScanAction == s.lastScanAction {
// readTokenInfo was called before with the same expected scan action.
// No need to re-scan text, return existing 'lastTokenInfo'
// it is ok to call fixTokenKind here since it does not affect
// what portion of text is consumed. In contrast rescanning can change it,
// i.e. for '>=' when originally scanner eats just one character
// and rescanning forces it to consume more.
s.lastTokenInfo = fixTokenKind(s.lastTokenInfo, n)
return s.lastTokenInfo
}
if s.s.TokenFullStart() != s.savedPos {
// readTokenInfo was called before but scan action differs - rescan text
s.s.ResetTokenState(s.savedPos)
s.s.Scan()
}
currentToken := s.getNextToken(n, expectedScanAction)
token := NewTextRangeWithKind(
s.s.TokenFullStart(),
s.s.TokenEnd(),
currentToken,
)
// consume trailing trivia
s.trailingTrivia = nil
for s.s.TokenFullStart() < s.endPos {
currentToken = s.s.Scan()
if !ast.IsTrivia(currentToken) {
break
}
trivia := NewTextRangeWithKind(
s.s.TokenFullStart(),
s.s.TokenEnd(),
currentToken,
)
s.trailingTrivia = append(s.trailingTrivia, trivia)
if currentToken == ast.KindNewLineTrivia {
// move past new line
s.s.Scan()
break
}
}
s.hasLastTokenInfo = true
s.lastTokenInfo = tokenInfo{
leadingTrivia: slices.Clone(s.leadingTrivia),
token: token,
trailingTrivia: slices.Clone(s.trailingTrivia),
}
s.lastTokenInfo = fixTokenKind(s.lastTokenInfo, n)
return s.lastTokenInfo
}
func (s *formattingScanner) getNextToken(n *ast.Node, expectedScanAction scanAction) ast.Kind {
token := s.s.Token()
s.lastScanAction = actionScan
switch expectedScanAction {
case actionRescanGreaterThanToken:
if token == ast.KindGreaterThanToken {
s.lastScanAction = actionRescanGreaterThanToken
newToken := s.s.ReScanGreaterThanToken()
debug.Assert(n.Kind == newToken)
return newToken
}
case actionRescanSlashToken:
if startsWithSlashToken(token) {
s.lastScanAction = actionRescanSlashToken
newToken := s.s.ReScanSlashToken()
debug.Assert(n.Kind == newToken)
return newToken
}
case actionRescanTemplateToken:
if token == ast.KindCloseBraceToken {
s.lastScanAction = actionRescanTemplateToken
return s.s.ReScanTemplateToken( /*isTaggedTemplate*/ false)
}
case actionRescanJsxIdentifier:
s.lastScanAction = actionRescanJsxIdentifier
return s.s.ScanJsxIdentifier()
case actionRescanJsxText:
s.lastScanAction = actionRescanJsxText
return s.s.ReScanJsxToken( /*allowMultilineJsxText*/ false)
case actionRescanJsxAttributeValue:
s.lastScanAction = actionRescanJsxAttributeValue
return s.s.ReScanJsxAttributeValue()
case actionScan:
break
default:
debug.AssertNever(expectedScanAction, "unhandled scan action kind")
}
return token
}
func (s *formattingScanner) readEOFTokenRange() TextRangeWithKind {
debug.Assert(s.isOnEOF())
return NewTextRangeWithKind(
s.s.TokenFullStart(),
s.s.TokenEnd(),
ast.KindEndOfFile,
)
}
func (s *formattingScanner) isOnToken() bool {
current := s.s.Token()
if s.hasLastTokenInfo {
current = s.lastTokenInfo.token.Kind
}
return current != ast.KindEndOfFile && !ast.IsTrivia(current)
}
func (s *formattingScanner) isOnEOF() bool {
current := s.s.Token()
if s.hasLastTokenInfo {
current = s.lastTokenInfo.token.Kind
}
return current == ast.KindEndOfFile
}
func (s *formattingScanner) skipToEndOf(r *core.TextRange) {
s.s.ResetTokenState(r.End())
s.savedPos = s.s.TokenFullStart()
s.lastScanAction = actionScan
s.hasLastTokenInfo = false
s.wasNewLine = false
s.leadingTrivia = nil
s.trailingTrivia = nil
}
func (s *formattingScanner) skipToStartOf(r *core.TextRange) {
s.s.ResetTokenState(r.Pos())
s.savedPos = s.s.TokenFullStart()
s.lastScanAction = actionScan
s.hasLastTokenInfo = false
s.wasNewLine = false
s.leadingTrivia = nil
s.trailingTrivia = nil
}
func (s *formattingScanner) getCurrentLeadingTrivia() []TextRangeWithKind {
return s.leadingTrivia
}
func (s *formattingScanner) lastTrailingTriviaWasNewLine() bool {
return s.wasNewLine
}
func (s *formattingScanner) getTokenFullStart() int {
if s.hasLastTokenInfo {
return s.lastTokenInfo.token.Loc.Pos()
}
return s.s.TokenFullStart()
}
func (s *formattingScanner) getStartPos() int { // TODO: redundant?
return s.getTokenFullStart()
}

1215
kitcom/internal/tsgo/format/span.go
View File

File diff suppressed because it is too large Load Diff

190
kitcom/internal/tsgo/format/util.go
View File

@ -1,190 +0,0 @@
package format
import (
"slices"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/ast"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/astnav"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/core"
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/scanner"
)
func rangeIsOnOneLine(node core.TextRange, file *ast.SourceFile) bool {
startLine, _ := scanner.GetECMALineAndCharacterOfPosition(file, node.Pos())
endLine, _ := scanner.GetECMALineAndCharacterOfPosition(file, node.End())
return startLine == endLine
}
func getOpenTokenForList(node *ast.Node, list *ast.NodeList) ast.Kind {
switch node.Kind {
case ast.KindConstructor,
ast.KindFunctionDeclaration,
ast.KindFunctionExpression,
ast.KindMethodDeclaration,
ast.KindMethodSignature,
ast.KindArrowFunction,
ast.KindCallSignature,
ast.KindConstructSignature,
ast.KindFunctionType,
ast.KindConstructorType,
ast.KindGetAccessor,
ast.KindSetAccessor:
if node.TypeParameterList() == list {
return ast.KindLessThanToken
} else if node.ParameterList() == list {
return ast.KindOpenParenToken
}
case ast.KindCallExpression, ast.KindNewExpression:
if node.TypeArgumentList() == list {
return ast.KindLessThanToken
} else if node.ArgumentList() == list {
return ast.KindOpenParenToken
}
case ast.KindClassDeclaration,
ast.KindClassExpression,
ast.KindInterfaceDeclaration,
ast.KindTypeAliasDeclaration:
if node.TypeParameterList() == list {
return ast.KindLessThanToken
}
case ast.KindTypeReference,
ast.KindTaggedTemplateExpression,
ast.KindTypeQuery,
ast.KindExpressionWithTypeArguments,
ast.KindImportType:
if node.TypeArgumentList() == list {
return ast.KindLessThanToken
}
case ast.KindTypeLiteral:
return ast.KindOpenBraceToken
}
return ast.KindUnknown
}
func getCloseTokenForOpenToken(kind ast.Kind) ast.Kind {
// TODO: matches strada - seems like it could handle more pairs of braces, though? [] notably missing
switch kind {
case ast.KindOpenParenToken:
return ast.KindCloseParenToken
case ast.KindLessThanToken:
return ast.KindGreaterThanToken
case ast.KindOpenBraceToken:
return ast.KindCloseBraceToken
}
return ast.KindUnknown
}
func GetLineStartPositionForPosition(position int, sourceFile *ast.SourceFile) int {
lineStarts := scanner.GetECMALineStarts(sourceFile)
line, _ := scanner.GetECMALineAndCharacterOfPosition(sourceFile, position)
return int(lineStarts[line])
}
/**
* Tests whether `child` is a grammar error on `parent`.
* In strada, this also checked node arrays, but it is never actually called with one in practice.
*/
func isGrammarError(parent *ast.Node, child *ast.Node) bool {
if ast.IsTypeParameterDeclaration(parent) {
return child == parent.AsTypeParameter().Expression
}
if ast.IsPropertySignatureDeclaration(parent) {
return child == parent.AsPropertySignatureDeclaration().Initializer
}
if ast.IsPropertyDeclaration(parent) {
return ast.IsAutoAccessorPropertyDeclaration(parent) && child == parent.AsPropertyDeclaration().PostfixToken && child.Kind == ast.KindQuestionToken
}
if ast.IsPropertyAssignment(parent) {
pa := parent.AsPropertyAssignment()
mods := pa.Modifiers()
return child == pa.PostfixToken || (mods != nil && isGrammarErrorElement(&mods.NodeList, child, ast.IsModifierLike))
}
if ast.IsShorthandPropertyAssignment(parent) {
sp := parent.AsShorthandPropertyAssignment()
mods := sp.Modifiers()
return child == sp.EqualsToken || child == sp.PostfixToken || (mods != nil && isGrammarErrorElement(&mods.NodeList, child, ast.IsModifierLike))
}
if ast.IsMethodDeclaration(parent) {
return child == parent.AsMethodDeclaration().PostfixToken && child.Kind == ast.KindExclamationToken
}
if ast.IsConstructorDeclaration(parent) {
return child == parent.AsConstructorDeclaration().Type || isGrammarErrorElement(parent.AsConstructorDeclaration().TypeParameters, child, ast.IsTypeParameterDeclaration)
}
if ast.IsGetAccessorDeclaration(parent) {
return isGrammarErrorElement(parent.AsGetAccessorDeclaration().TypeParameters, child, ast.IsTypeParameterDeclaration)
}
if ast.IsSetAccessorDeclaration(parent) {
return child == parent.AsSetAccessorDeclaration().Type || isGrammarErrorElement(parent.AsSetAccessorDeclaration().TypeParameters, child, ast.IsTypeParameterDeclaration)
}
if ast.IsNamespaceExportDeclaration(parent) {
mods := parent.AsNamespaceExportDeclaration().Modifiers()
return mods != nil && isGrammarErrorElement(&mods.NodeList, child, ast.IsModifierLike)
}
return false
}
func isGrammarErrorElement(list *ast.NodeList, child *ast.Node, isPossibleElement func(node *ast.Node) bool) bool {
if list == nil || len(list.Nodes) == 0 {
return false
}
if !isPossibleElement(child) {
return false
}
return slices.Contains(list.Nodes, child)
}
/**
* Validating `expectedTokenKind` ensures the token was typed in the context we expect (eg: not a comment).
* @param expectedTokenKind The kind of the last token constituting the desired parent node.
*/
func findImmediatelyPrecedingTokenOfKind(end int, expectedTokenKind ast.Kind, sourceFile *ast.SourceFile) *ast.Node {
precedingToken := astnav.FindPrecedingToken(sourceFile, end)
if precedingToken == nil || precedingToken.Kind != expectedTokenKind || precedingToken.End() != end {
return nil
}
return precedingToken
}
/**
* Finds the highest node enclosing `node` at the same list level as `node`
* and whose end does not exceed `node.end`.
*
* Consider typing the following
* ```
* let x = 1;
* while (true) {
* }
* ```
* Upon typing the closing curly, we want to format the entire `while`-statement, but not the preceding
* variable declaration.
*/
func findOutermostNodeWithinListLevel(node *ast.Node) *ast.Node {
current := node
for current != nil &&
current.Parent != nil &&
current.Parent.End() == node.End() &&
!isListElement(current.Parent, current) {
current = current.Parent
}
return current
}
// Returns true if node is a element in some list in parent
// i.e. parent is class declaration with the list of members and node is one of members.
func isListElement(parent *ast.Node, node *ast.Node) bool {
switch parent.Kind {
case ast.KindClassDeclaration, ast.KindInterfaceDeclaration:
return node.Loc.ContainedBy(parent.MemberList().Loc)
case ast.KindModuleDeclaration:
body := parent.Body()
return body != nil && body.Kind == ast.KindModuleBlock && node.Loc.ContainedBy(body.StatementList().Loc)
case ast.KindSourceFile, ast.KindBlock, ast.KindModuleBlock:
return node.Loc.ContainedBy(parent.StatementList().Loc)
case ast.KindCatchClause:
return node.Loc.ContainedBy(parent.AsCatchClause().Block.StatementList().Loc)
}
return false
}