📦 Optimized packaging
This commit is contained in:
32
frontend/src/common/prettier/plugins/go/build.bat
Normal file
32
frontend/src/common/prettier/plugins/go/build.bat
Normal file
@@ -0,0 +1,32 @@
|
||||
@echo off
|
||||
rem Build script for Go Prettier Plugin WASM
|
||||
rem This script compiles the Go code to WebAssembly
|
||||
|
||||
echo 🔨 Building Go Prettier Plugin WASM...
|
||||
|
||||
rem Set WASM build environment
|
||||
set GOOS=js
|
||||
set GOARCH=wasm
|
||||
|
||||
rem Build the WASM file
|
||||
echo Compiling main.go to go.wasm...
|
||||
go build -o go.wasm main.go
|
||||
|
||||
if %ERRORLEVEL% EQU 0 (
|
||||
echo ✅ Build successful!
|
||||
|
||||
rem Show file size (Windows version)
|
||||
for %%A in (go.wasm) do echo 📊 WASM file size: %%~zA bytes
|
||||
|
||||
rem Copy to public directory for browser access
|
||||
if exist "..\..\..\..\..\public" (
|
||||
copy go.wasm ..\..\..\..\..\public\go.wasm > nul
|
||||
echo 📋 Copied to public directory
|
||||
)
|
||||
|
||||
echo 🎉 Go Prettier Plugin WASM is ready!
|
||||
) else (
|
||||
echo ❌ Build failed!
|
||||
pause
|
||||
exit /b 1
|
||||
)
|
||||
30
frontend/src/common/prettier/plugins/go/build.sh
Normal file
30
frontend/src/common/prettier/plugins/go/build.sh
Normal file
@@ -0,0 +1,30 @@
|
||||
#!/bin/bash
|
||||
|
||||
# Build script for Go Prettier Plugin WASM
|
||||
# This script compiles the Go code to WebAssembly
|
||||
|
||||
echo "🔨 Building Go Prettier Plugin WASM..."
|
||||
|
||||
# Set WASM build environment
|
||||
export GOOS=js
|
||||
export GOARCH=wasm
|
||||
|
||||
# Build the WASM file
|
||||
echo "Compiling main.go to go.wasm..."
|
||||
go build -o go.wasm main.go
|
||||
|
||||
if [ $? -eq 0 ]; then
|
||||
echo "✅ Build successful!"
|
||||
echo "📊 WASM file size: $(du -h go.wasm | cut -f1)"
|
||||
|
||||
# Copy to public directory for browser access
|
||||
if [ -d "../../../../../public" ]; then
|
||||
cp go.wasm ../../../../../public/go.wasm
|
||||
echo "📋 Copied to public directory"
|
||||
fi
|
||||
|
||||
echo "🎉 Go Prettier Plugin WASM is ready!"
|
||||
else
|
||||
echo "❌ Build failed!"
|
||||
exit 1
|
||||
fi
|
||||
10
frontend/src/common/prettier/plugins/go/go.d.ts
vendored
Normal file
10
frontend/src/common/prettier/plugins/go/go.d.ts
vendored
Normal file
@@ -0,0 +1,10 @@
|
||||
import { Parser, Plugin } from "prettier";
|
||||
|
||||
export declare const languages: Plugin["languages"];
|
||||
export declare const parsers: {
|
||||
go: Parser;
|
||||
};
|
||||
export declare const printers: Plugin["printers"];
|
||||
|
||||
declare const plugin: Plugin;
|
||||
export default plugin;
|
||||
116
frontend/src/common/prettier/plugins/go/go.mjs
Normal file
116
frontend/src/common/prettier/plugins/go/go.mjs
Normal file
@@ -0,0 +1,116 @@
|
||||
/**
|
||||
* Go Prettier Plugin for Vite + Vue3 Environment
|
||||
* WebAssembly-based Go code formatter for Prettier
|
||||
*/
|
||||
|
||||
let initializePromise = null;
|
||||
|
||||
// Load WASM file from public directory
|
||||
const loadWasm = async () => {
|
||||
try {
|
||||
const response = await fetch('/go.wasm');
|
||||
if (!response.ok) {
|
||||
throw new Error(`Failed to load WASM file: ${response.status} ${response.statusText}`);
|
||||
}
|
||||
return await response.arrayBuffer();
|
||||
} catch (error) {
|
||||
console.error('WASM loading failed:', error);
|
||||
throw error;
|
||||
}
|
||||
};
|
||||
|
||||
// Initialize Go runtime
|
||||
const initGoRuntime = async () => {
|
||||
if (globalThis.Go) return;
|
||||
|
||||
// Auto-load wasm_exec.js if not available
|
||||
try {
|
||||
|
||||
const script = document.createElement('script');
|
||||
script.src = '/wasm_exec.js';
|
||||
document.head.appendChild(script);
|
||||
|
||||
await new Promise((resolve, reject) => {
|
||||
script.onload = resolve;
|
||||
script.onerror = () => reject(new Error('Failed to load wasm_exec.js'));
|
||||
setTimeout(() => reject(new Error('wasm_exec.js loading timeout')), 5000);
|
||||
});
|
||||
if (!globalThis.Go) {
|
||||
throw new Error('Go WASM runtime is not available after loading wasm_exec.js');
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('Failed to load wasm_exec.js:', error);
|
||||
throw error;
|
||||
}
|
||||
};
|
||||
|
||||
const initialize = async () => {
|
||||
if (initializePromise) return initializePromise;
|
||||
|
||||
initializePromise = (async () => {
|
||||
await initGoRuntime();
|
||||
|
||||
const go = new globalThis.Go();
|
||||
const wasmBuffer = await loadWasm();
|
||||
const {instance} = await WebAssembly.instantiate(wasmBuffer, go.importObject);
|
||||
|
||||
// Run Go program
|
||||
go.run(instance).catch(err => {
|
||||
console.error('Go WASM program exit error:', err);
|
||||
});
|
||||
|
||||
// Wait for initialization to complete
|
||||
await new Promise(resolve => setTimeout(resolve, 200));
|
||||
|
||||
// Check if formatGo function is available
|
||||
if (typeof globalThis.formatGo !== 'function') {
|
||||
throw new Error('Go WASM module not properly initialized - formatGo function not available');
|
||||
}
|
||||
})();
|
||||
|
||||
return initializePromise;
|
||||
};
|
||||
|
||||
export const languages = [
|
||||
{
|
||||
name: "Go",
|
||||
parsers: ["go"],
|
||||
extensions: [".go"],
|
||||
vscodeLanguageIds: ["go"],
|
||||
},
|
||||
];
|
||||
|
||||
export const parsers = {
|
||||
go: {
|
||||
parse: (text) => text,
|
||||
astFormat: "go-format",
|
||||
locStart: (node) => 0,
|
||||
locEnd: (node) => node.length,
|
||||
},
|
||||
};
|
||||
|
||||
export const printers = {
|
||||
"go-format": {
|
||||
print: async (path) => {
|
||||
await initialize();
|
||||
const text = path.getValue();
|
||||
|
||||
if (typeof globalThis.formatGo !== 'function') {
|
||||
throw new Error('Go WASM module not properly initialized - formatGo function missing');
|
||||
}
|
||||
|
||||
try {
|
||||
return globalThis.formatGo(text);
|
||||
} catch (error) {
|
||||
throw new Error(`Go formatting failed: ${error.message}`);
|
||||
}
|
||||
},
|
||||
},
|
||||
};
|
||||
|
||||
// Default export for Prettier plugin compatibility
|
||||
export default {
|
||||
languages,
|
||||
parsers,
|
||||
printers
|
||||
};
|
||||
255
frontend/src/common/prettier/plugins/go/main.go
Normal file
255
frontend/src/common/prettier/plugins/go/main.go
Normal file
@@ -0,0 +1,255 @@
|
||||
//go:build js && wasm
|
||||
|
||||
// Package main implements a WebAssembly module that provides Go code formatting
|
||||
// functionality for the Prettier plugin. This package exposes the formatGo function
|
||||
// to JavaScript, enabling web-based Go code formatting with better error tolerance.
|
||||
package main
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"go/format"
|
||||
"go/parser"
|
||||
"go/token"
|
||||
"strings"
|
||||
"syscall/js"
|
||||
)
|
||||
|
||||
// formatGoCode attempts to format Go source code with better error tolerance
|
||||
func formatGoCode(src string) (string, error) {
|
||||
// Trim input but preserve leading/trailing newlines structure
|
||||
trimmed := strings.TrimSpace(src)
|
||||
if trimmed == "" {
|
||||
return src, nil
|
||||
}
|
||||
|
||||
// First try the standard format.Source for complete, valid code
|
||||
if formatted, err := format.Source([]byte(src)); err == nil {
|
||||
return string(formatted), nil
|
||||
}
|
||||
|
||||
// Create a new file set for parsing
|
||||
fset := token.NewFileSet()
|
||||
|
||||
// Strategy 1: Try as complete Go file
|
||||
if parsed, err := parser.ParseFile(fset, "", src, parser.ParseComments); err == nil {
|
||||
return formatASTNode(fset, parsed)
|
||||
}
|
||||
|
||||
// Strategy 2: Try wrapping as package-level declarations
|
||||
packageWrapped := fmt.Sprintf("package main\n\n%s", trimmed)
|
||||
if parsed, err := parser.ParseFile(fset, "", packageWrapped, parser.ParseComments); err == nil {
|
||||
if formatted, err := formatASTNode(fset, parsed); err == nil {
|
||||
return extractPackageContent(formatted), nil
|
||||
}
|
||||
}
|
||||
|
||||
// Strategy 3: Try wrapping in main function
|
||||
funcWrapped := fmt.Sprintf("package main\n\nfunc main() {\n%s\n}", indentLines(trimmed, "\t"))
|
||||
if parsed, err := parser.ParseFile(fset, "", funcWrapped, parser.ParseComments); err == nil {
|
||||
if formatted, err := formatASTNode(fset, parsed); err == nil {
|
||||
return extractFunctionBody(formatted), nil
|
||||
}
|
||||
}
|
||||
|
||||
// Strategy 4: Try wrapping in anonymous function
|
||||
anonWrapped := fmt.Sprintf("package main\n\nvar _ = func() {\n%s\n}", indentLines(trimmed, "\t"))
|
||||
if parsed, err := parser.ParseFile(fset, "", anonWrapped, parser.ParseComments); err == nil {
|
||||
if formatted, err := formatASTNode(fset, parsed); err == nil {
|
||||
return extractFunctionBody(formatted), nil
|
||||
}
|
||||
}
|
||||
|
||||
// Strategy 5: Try line-by-line formatting for complex cases
|
||||
return formatLineByLine(trimmed, fset)
|
||||
}
|
||||
|
||||
// formatASTNode formats an AST node using the standard formatter
|
||||
func formatASTNode(fset *token.FileSet, node interface{}) (string, error) {
|
||||
var buf bytes.Buffer
|
||||
if err := format.Node(&buf, fset, node); err != nil {
|
||||
return "", err
|
||||
}
|
||||
return buf.String(), nil
|
||||
}
|
||||
|
||||
// extractPackageContent extracts content after package declaration
|
||||
func extractPackageContent(formatted string) string {
|
||||
lines := strings.Split(formatted, "\n")
|
||||
var contentLines []string
|
||||
skipNext := false
|
||||
|
||||
for _, line := range lines {
|
||||
if strings.HasPrefix(line, "package ") {
|
||||
skipNext = true
|
||||
continue
|
||||
}
|
||||
if skipNext && strings.TrimSpace(line) == "" {
|
||||
skipNext = false
|
||||
continue
|
||||
}
|
||||
if !skipNext {
|
||||
contentLines = append(contentLines, line)
|
||||
}
|
||||
}
|
||||
|
||||
return strings.Join(contentLines, "\n")
|
||||
}
|
||||
|
||||
// extractFunctionBody extracts content from within a function body
|
||||
func extractFunctionBody(formatted string) string {
|
||||
lines := strings.Split(formatted, "\n")
|
||||
var bodyLines []string
|
||||
inFunction := false
|
||||
braceCount := 0
|
||||
|
||||
for _, line := range lines {
|
||||
if strings.Contains(line, "func ") && strings.Contains(line, "{") {
|
||||
inFunction = true
|
||||
braceCount = 1
|
||||
continue
|
||||
}
|
||||
|
||||
if inFunction {
|
||||
// Count braces to know when function ends
|
||||
braceCount += strings.Count(line, "{")
|
||||
braceCount -= strings.Count(line, "}")
|
||||
|
||||
if braceCount == 0 {
|
||||
break
|
||||
}
|
||||
|
||||
// Remove one level of indentation and add the line
|
||||
if strings.HasPrefix(line, "\t") {
|
||||
bodyLines = append(bodyLines, line[1:])
|
||||
} else {
|
||||
bodyLines = append(bodyLines, line)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Remove empty lines from start and end
|
||||
for len(bodyLines) > 0 && strings.TrimSpace(bodyLines[0]) == "" {
|
||||
bodyLines = bodyLines[1:]
|
||||
}
|
||||
for len(bodyLines) > 0 && strings.TrimSpace(bodyLines[len(bodyLines)-1]) == "" {
|
||||
bodyLines = bodyLines[:len(bodyLines)-1]
|
||||
}
|
||||
|
||||
return strings.Join(bodyLines, "\n")
|
||||
}
|
||||
|
||||
// indentLines adds indentation to each non-empty line
|
||||
func indentLines(text, indent string) string {
|
||||
lines := strings.Split(text, "\n")
|
||||
var indentedLines []string
|
||||
|
||||
for _, line := range lines {
|
||||
if strings.TrimSpace(line) == "" {
|
||||
indentedLines = append(indentedLines, "")
|
||||
} else {
|
||||
indentedLines = append(indentedLines, indent+line)
|
||||
}
|
||||
}
|
||||
|
||||
return strings.Join(indentedLines, "\n")
|
||||
}
|
||||
|
||||
// formatLineByLine attempts to format each statement individually
|
||||
func formatLineByLine(src string, fset *token.FileSet) (string, error) {
|
||||
lines := strings.Split(src, "\n")
|
||||
var formattedLines []string
|
||||
|
||||
for _, line := range lines {
|
||||
trimmedLine := strings.TrimSpace(line)
|
||||
if trimmedLine == "" {
|
||||
formattedLines = append(formattedLines, "")
|
||||
continue
|
||||
}
|
||||
|
||||
// Try different wrapping strategies for individual lines
|
||||
attempts := []string{
|
||||
fmt.Sprintf("package main\n\nfunc main() {\n\t%s\n}", trimmedLine),
|
||||
fmt.Sprintf("package main\n\n%s", trimmedLine),
|
||||
fmt.Sprintf("package main\n\nvar _ = %s", trimmedLine),
|
||||
}
|
||||
|
||||
formatted := trimmedLine // fallback
|
||||
for _, attempt := range attempts {
|
||||
if parsed, err := parser.ParseFile(fset, "", attempt, parser.ParseComments); err == nil {
|
||||
if result, err := formatASTNode(fset, parsed); err == nil {
|
||||
if extracted := extractSingleStatement(result, trimmedLine); extracted != "" {
|
||||
formatted = extracted
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
formattedLines = append(formattedLines, formatted)
|
||||
}
|
||||
|
||||
return strings.Join(formattedLines, "\n"), nil
|
||||
}
|
||||
|
||||
// extractSingleStatement tries to extract a single formatted statement
|
||||
func extractSingleStatement(formatted, original string) string {
|
||||
lines := strings.Split(formatted, "\n")
|
||||
|
||||
for _, line := range lines {
|
||||
trimmed := strings.TrimSpace(line)
|
||||
if trimmed != "" && !strings.HasPrefix(trimmed, "package ") &&
|
||||
!strings.HasPrefix(trimmed, "func ") && !strings.HasPrefix(trimmed, "var _ =") &&
|
||||
trimmed != "{" && trimmed != "}" {
|
||||
// Remove leading tabs/spaces to normalize indentation
|
||||
return strings.TrimLeft(line, " \t")
|
||||
}
|
||||
}
|
||||
|
||||
return original
|
||||
}
|
||||
|
||||
// formatGo is a JavaScript-callable function that formats Go source code.
|
||||
// It attempts multiple strategies to format code, including handling incomplete
|
||||
// or syntactically invalid code fragments.
|
||||
//
|
||||
// Parameters:
|
||||
// - this: The JavaScript 'this' context (unused)
|
||||
// - i: JavaScript arguments array where i[0] should contain the Go source code as a string
|
||||
//
|
||||
// Returns:
|
||||
// - js.Value: The formatted Go source code as a JavaScript string value
|
||||
// - If formatting fails completely, returns the original code unchanged
|
||||
// - If no arguments are provided, returns js.Null() and logs an error
|
||||
func formatGo(this js.Value, i []js.Value) interface{} {
|
||||
if len(i) == 0 {
|
||||
js.Global().Get("console").Call("error", "formatGo: missing code argument")
|
||||
return js.Null()
|
||||
}
|
||||
|
||||
code := i[0].String()
|
||||
if strings.TrimSpace(code) == "" {
|
||||
return js.ValueOf(code)
|
||||
}
|
||||
|
||||
formatted, err := formatGoCode(code)
|
||||
if err != nil {
|
||||
js.Global().Get("console").Call("warn", "Go formatting had issues:", err.Error())
|
||||
return js.ValueOf(code) // Return original code if all attempts fail
|
||||
}
|
||||
|
||||
return js.ValueOf(formatted)
|
||||
}
|
||||
|
||||
// main initializes the WebAssembly module and exposes the formatGo function
|
||||
// to the JavaScript global scope.
|
||||
func main() {
|
||||
// Create a channel to keep the Go program running
|
||||
c := make(chan struct{}, 0)
|
||||
|
||||
// Expose the formatGo function to the JavaScript global scope
|
||||
js.Global().Set("formatGo", js.FuncOf(formatGo))
|
||||
|
||||
// Block forever
|
||||
<-c
|
||||
}
|
||||
17
frontend/src/common/prettier/plugins/java/comments.d.ts
vendored
Normal file
17
frontend/src/common/prettier/plugins/java/comments.d.ts
vendored
Normal file
@@ -0,0 +1,17 @@
|
||||
import type { IToken } from "java-parser";
|
||||
import { type AstPath } from "prettier";
|
||||
import { type JavaNode, type JavaNonTerminal, type JavaParserOptions } from "./printers/helpers.js";
|
||||
export declare function determineFormatterOffOnRanges(cst: JavaNonTerminal): void;
|
||||
export declare function isFullyBetweenFormatterOffOn(path: AstPath<JavaNode>): boolean;
|
||||
export declare function canAttachComment(node: JavaNode): boolean;
|
||||
export declare function handleLineComment(commentNode: JavaComment, _: string, options: JavaParserOptions): boolean;
|
||||
export declare function handleRemainingComment(commentNode: JavaComment): boolean;
|
||||
export type JavaComment = IToken & {
|
||||
value: string;
|
||||
leading: boolean;
|
||||
trailing: boolean;
|
||||
printed: boolean;
|
||||
enclosingNode?: JavaNonTerminal;
|
||||
precedingNode?: JavaNonTerminal;
|
||||
followingNode?: JavaNonTerminal;
|
||||
};
|
||||
199
frontend/src/common/prettier/plugins/java/comments.js
Normal file
199
frontend/src/common/prettier/plugins/java/comments.js
Normal file
@@ -0,0 +1,199 @@
|
||||
import { util } from "prettier";
|
||||
import parser from "./parser.js";
|
||||
import { isEmptyStatement, isNonTerminal, isTerminal } from "./printers/helpers.js";
|
||||
const formatterOffOnRangesByCst = new WeakMap();
|
||||
export function determineFormatterOffOnRanges(cst) {
|
||||
const { comments } = cst;
|
||||
if (!comments) {
|
||||
return;
|
||||
}
|
||||
const ranges = comments
|
||||
.filter(({ image }) => /^(\/\/\s*@formatter:(off|on)\s*|\/\*\s*@formatter:(off|on)\s*\*\/)$/.test(image))
|
||||
.reduce((ranges, { image, startOffset }) => {
|
||||
const previous = ranges.at(-1);
|
||||
if (image.endsWith("off")) {
|
||||
if ((previous === null || previous === void 0 ? void 0 : previous.on) !== Infinity) {
|
||||
ranges.push({ off: startOffset, on: Infinity });
|
||||
}
|
||||
}
|
||||
else if ((previous === null || previous === void 0 ? void 0 : previous.on) === Infinity) {
|
||||
previous.on = startOffset;
|
||||
}
|
||||
return ranges;
|
||||
}, new Array());
|
||||
formatterOffOnRangesByCst.set(cst, ranges);
|
||||
}
|
||||
export function isFullyBetweenFormatterOffOn(path) {
|
||||
var _a;
|
||||
const { node, root } = path;
|
||||
const start = parser.locStart(node);
|
||||
const end = parser.locEnd(node);
|
||||
return (((_a = formatterOffOnRangesByCst
|
||||
.get(root)) === null || _a === void 0 ? void 0 : _a.some(range => range.off < start && end < range.on)) === true);
|
||||
}
|
||||
export function canAttachComment(node) {
|
||||
var _a, _b, _c;
|
||||
if (isTerminal(node)) {
|
||||
const { name, CATEGORIES } = node.tokenType;
|
||||
return (name === "Identifier" ||
|
||||
(CATEGORIES === null || CATEGORIES === void 0 ? void 0 : CATEGORIES.find(({ name }) => name === "BinaryOperator")) !== undefined);
|
||||
}
|
||||
const { children, name } = node;
|
||||
switch (name) {
|
||||
case "argumentList":
|
||||
case "blockStatements":
|
||||
case "emptyStatement":
|
||||
case "enumBodyDeclarations":
|
||||
return false;
|
||||
case "annotationInterfaceMemberDeclaration":
|
||||
case "classMemberDeclaration":
|
||||
case "interfaceMemberDeclaration":
|
||||
case "methodBody":
|
||||
return !children.Semicolon;
|
||||
case "blockStatement":
|
||||
return !children.statement || !isEmptyStatement(children.statement[0]);
|
||||
case "classBodyDeclaration":
|
||||
return !((_a = children.classMemberDeclaration) === null || _a === void 0 ? void 0 : _a[0].children.Semicolon);
|
||||
case "recordBodyDeclaration":
|
||||
return !((_c = (_b = children.classBodyDeclaration) === null || _b === void 0 ? void 0 : _b[0].children.classMemberDeclaration) === null || _c === void 0 ? void 0 : _c[0].children.Semicolon);
|
||||
case "statement":
|
||||
return !isEmptyStatement(node);
|
||||
case "statementWithoutTrailingSubstatement":
|
||||
return !children.emptyStatement;
|
||||
default:
|
||||
return true;
|
||||
}
|
||||
}
|
||||
export function handleLineComment(commentNode, _, options) {
|
||||
return [
|
||||
handleBinaryExpressionComments,
|
||||
handleFqnOrRefTypeComments,
|
||||
handleIfStatementComments,
|
||||
handleJumpStatementComments,
|
||||
handleLabeledStatementComments,
|
||||
handleNameComments
|
||||
].some(fn => fn(commentNode, options));
|
||||
}
|
||||
export function handleRemainingComment(commentNode) {
|
||||
return [
|
||||
handleFqnOrRefTypeComments,
|
||||
handleMethodDeclaratorComments,
|
||||
handleNameComments,
|
||||
handleJumpStatementComments
|
||||
].some(fn => fn(commentNode));
|
||||
}
|
||||
function handleBinaryExpressionComments(commentNode, options) {
|
||||
const { enclosingNode, precedingNode, followingNode } = commentNode;
|
||||
if (enclosingNode &&
|
||||
isNonTerminal(enclosingNode) &&
|
||||
enclosingNode.name === "binaryExpression") {
|
||||
if (isBinaryOperator(followingNode)) {
|
||||
if (options.experimentalOperatorPosition === "start") {
|
||||
util.addLeadingComment(followingNode, commentNode);
|
||||
}
|
||||
else {
|
||||
util.addTrailingComment(followingNode, commentNode);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
else if (options.experimentalOperatorPosition === "start" &&
|
||||
isBinaryOperator(precedingNode)) {
|
||||
util.addLeadingComment(precedingNode, commentNode);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function handleFqnOrRefTypeComments(commentNode) {
|
||||
const { enclosingNode, followingNode } = commentNode;
|
||||
if (enclosingNode &&
|
||||
isNonTerminal(enclosingNode) &&
|
||||
enclosingNode.name === "fqnOrRefType" &&
|
||||
followingNode) {
|
||||
util.addLeadingComment(followingNode, commentNode);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function handleIfStatementComments(commentNode) {
|
||||
const { enclosingNode, precedingNode } = commentNode;
|
||||
if (enclosingNode &&
|
||||
isNonTerminal(enclosingNode) &&
|
||||
enclosingNode.name === "ifStatement" &&
|
||||
precedingNode &&
|
||||
isNonTerminal(precedingNode) &&
|
||||
precedingNode.name === "statement") {
|
||||
util.addDanglingComment(enclosingNode, commentNode, undefined);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function handleJumpStatementComments(commentNode) {
|
||||
const { enclosingNode, precedingNode, followingNode } = commentNode;
|
||||
if (enclosingNode &&
|
||||
!precedingNode &&
|
||||
!followingNode &&
|
||||
isNonTerminal(enclosingNode) &&
|
||||
["breakStatement", "continueStatement", "returnStatement"].includes(enclosingNode.name)) {
|
||||
util.addTrailingComment(enclosingNode, commentNode);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function handleLabeledStatementComments(commentNode) {
|
||||
const { enclosingNode, precedingNode } = commentNode;
|
||||
if (enclosingNode &&
|
||||
precedingNode &&
|
||||
isNonTerminal(enclosingNode) &&
|
||||
enclosingNode.name === "labeledStatement" &&
|
||||
isTerminal(precedingNode) &&
|
||||
precedingNode.tokenType.name === "Identifier") {
|
||||
util.addLeadingComment(precedingNode, commentNode);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function handleMethodDeclaratorComments(commentNode) {
|
||||
const { enclosingNode } = commentNode;
|
||||
if (enclosingNode &&
|
||||
isNonTerminal(enclosingNode) &&
|
||||
enclosingNode.name === "methodDeclarator" &&
|
||||
!enclosingNode.children.receiverParameter &&
|
||||
!enclosingNode.children.formalParameterList &&
|
||||
enclosingNode.children.LBrace[0].startOffset < commentNode.startOffset &&
|
||||
commentNode.startOffset < enclosingNode.children.RBrace[0].startOffset) {
|
||||
util.addDanglingComment(enclosingNode, commentNode, undefined);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function handleNameComments(commentNode) {
|
||||
const { enclosingNode, precedingNode } = commentNode;
|
||||
if (enclosingNode &&
|
||||
precedingNode &&
|
||||
isNonTerminal(enclosingNode) &&
|
||||
isTerminal(precedingNode) &&
|
||||
precedingNode.tokenType.name === "Identifier" &&
|
||||
[
|
||||
"ambiguousName",
|
||||
"classOrInterfaceTypeToInstantiate",
|
||||
"expressionName",
|
||||
"moduleDeclaration",
|
||||
"moduleName",
|
||||
"packageDeclaration",
|
||||
"packageName",
|
||||
"packageOrTypeName",
|
||||
"typeName"
|
||||
].includes(enclosingNode.name)) {
|
||||
util.addTrailingComment(precedingNode, commentNode);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function isBinaryOperator(node) {
|
||||
var _a;
|
||||
return (node !== undefined &&
|
||||
(isNonTerminal(node)
|
||||
? node.name === "shiftOperator"
|
||||
: (_a = node.tokenType.CATEGORIES) === null || _a === void 0 ? void 0 : _a.some(({ name }) => name === "BinaryOperator")));
|
||||
}
|
||||
563
frontend/src/common/prettier/plugins/java/index.d.ts
vendored
Normal file
563
frontend/src/common/prettier/plugins/java/index.d.ts
vendored
Normal file
@@ -0,0 +1,563 @@
|
||||
import type { JavaNode } from "./printers/helpers.js";
|
||||
declare const _default: {
|
||||
languages: {
|
||||
name: string;
|
||||
parsers: "java"[];
|
||||
group: string;
|
||||
tmScope: string;
|
||||
aceMode: string;
|
||||
codemirrorMode: string;
|
||||
codemirrorMimeType: string;
|
||||
extensions: string[];
|
||||
linguistLanguageId: number;
|
||||
vscodeLanguageIds: string[];
|
||||
}[];
|
||||
parsers: {
|
||||
java: {
|
||||
parse(text: string, options: import("./printers/helpers.js").JavaParserOptions): import("./printers/helpers.js").JavaNonTerminal;
|
||||
astFormat: string;
|
||||
hasPragma(text: string): boolean;
|
||||
locStart(node: JavaNode): number;
|
||||
locEnd(node: JavaNode): number;
|
||||
};
|
||||
};
|
||||
printers: {
|
||||
java: {
|
||||
print(path: import("prettier").AstPath<import("java-parser").ArrayInitializerCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").VariableInitializerListCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").BlockCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").BlockStatementsCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").LocalVariableDeclarationStatementCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").LocalVariableDeclarationCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").LabeledStatementCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ExpressionStatementCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").IfStatementCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").AssertStatementCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").SwitchStatementCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").SwitchBlockCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").SwitchBlockStatementGroupCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").SwitchLabelCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").SwitchRuleCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").WhileStatementCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").DoStatementCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").BasicForStatementCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").StatementExpressionListCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").EnhancedForStatementCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").BreakStatementCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ContinueStatementCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ReturnStatementCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ThrowStatementCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").SynchronizedStatementCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").TryStatementCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").CatchesCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").CatchClauseCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").CatchFormalParameterCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").CatchTypeCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").FinallyCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").TryWithResourcesStatementCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ResourceSpecificationCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ResourceListCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").YieldStatementCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ForInitCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ForUpdateCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").StatementCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").StatementWithoutTrailingSubstatementCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ForStatementCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").BlockStatementCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").CaseConstantCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").CasePatternCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").EmptyStatementCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").StatementExpressionCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").LocalVariableTypeCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ResourceCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").VariableAccessCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ClassDeclarationCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").NormalClassDeclarationCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").TypeParametersCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").TypeParameterListCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ClassExtendsCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ClassImplementsCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").InterfaceTypeListCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ClassBodyCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ClassMemberDeclarationCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").FieldDeclarationCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").VariableDeclaratorListCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").VariableDeclaratorCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").VariableDeclaratorIdCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").UnannPrimitiveTypeWithOptionalDimsSuffixCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").UnannReferenceTypeCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").MethodDeclarationCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").MethodHeaderCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").MethodDeclaratorCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ReceiverParameterCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").FormalParameterListCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").VariableParaRegularParameterCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").VariableArityParameterCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ThrowsCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ExceptionTypeListCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").StaticInitializerCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ConstructorDeclarationCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ConstructorDeclaratorCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ConstructorBodyCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").UnqualifiedExplicitConstructorInvocationCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").QualifiedExplicitConstructorInvocationCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").EnumDeclarationCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").EnumBodyCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").EnumConstantListCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").EnumConstantCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").EnumBodyDeclarationsCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").RecordDeclarationCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").RecordHeaderCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").RecordComponentListCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").RecordComponentCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").VariableArityRecordComponentCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").RecordBodyCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").CompactConstructorDeclarationCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").UnannTypeCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").VariableInitializerCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").VariableModifierCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").UnannClassTypeCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ClassBodyDeclarationCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").InstanceInitializerCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ClassModifierCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ClassPermitsCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").FieldModifierCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").MethodModifierCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").MethodBodyCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ConstructorModifierCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").SimpleTypeNameCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ExplicitConstructorInvocationCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").EnumConstantModifierCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ExceptionTypeCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").FormalParameterCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ResultCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").RecordBodyDeclarationCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").RecordComponentModifierCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").UnannClassOrInterfaceTypeCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").UnannInterfaceTypeCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").UnannPrimitiveTypeCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").UnannTypeVariableCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").LambdaExpressionCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").LambdaParametersCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").LambdaParametersWithBracesCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ConciseLambdaParameterListCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").NormalLambdaParameterListCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").RegularLambdaParameterCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ConditionalExpressionCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").BinaryExpressionCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").UnaryExpressionCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").UnaryExpressionNotPlusMinusCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").PrimaryCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").PrimarySuffixCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").FqnOrRefTypeCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").FqnOrRefTypePartFirstCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").FqnOrRefTypePartRestCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").FqnOrRefTypePartCommonCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ParenthesisExpressionCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").PrimitiveCastExpressionCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ReferenceTypeCastExpressionCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").UnqualifiedClassInstanceCreationExpressionCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ClassOrInterfaceTypeToInstantiateCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").MethodInvocationSuffixCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ArgumentListCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ArrayCreationExpressionCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ArrayCreationExpressionWithoutInitializerSuffixCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ArrayCreationWithInitializerSuffixCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").DimExprsCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").DimExprCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ClassLiteralSuffixCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ArrayAccessSuffixCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").MethodReferenceSuffixCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").StringTemplateCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").TextBlockTemplateCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").RecordPatternCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ComponentPatternListCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").GuardCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").TemplateCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").PatternCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ExpressionCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").TypePatternCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").CastExpressionCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").TypeArgumentsOrDiamondCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").DiamondCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ComponentPatternCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").MatchAllPatternCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ConciseLambdaParameterCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").EmbeddedExpressionCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").LambdaBodyCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").LambdaParameterListCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").NormalLambdaParameterCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").LambdaParameterTypeCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").NewExpressionCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").PrimaryPrefixCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").TemplateArgumentCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").InterfaceDeclarationCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").NormalInterfaceDeclarationCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").InterfaceExtendsCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").InterfaceBodyCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").InterfaceMemberDeclarationCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ConstantDeclarationCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").InterfaceMethodDeclarationCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").AnnotationInterfaceDeclarationCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").AnnotationInterfaceBodyCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").AnnotationInterfaceMemberDeclarationCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").AnnotationInterfaceElementDeclarationCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").DefaultValueCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").AnnotationCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ElementValuePairListCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ElementValuePairCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ElementValueArrayInitializerCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ElementValueListCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ElementValueCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").AnnotationInterfaceElementModifierCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ConstantModifierCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").InterfaceModifierCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").InterfacePermitsCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").InterfaceMethodModifierCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").LiteralCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ShiftOperatorCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").BooleanLiteralCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").FloatingPointLiteralCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").IntegerLiteralCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").MethodNameCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").AmbiguousNameCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").TypeNameCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").TypeIdentifierCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ExpressionNameCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").PackageNameCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ModuleNameCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").PackageOrTypeNameCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").CompilationUnitCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").OrdinaryCompilationUnitCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ModularCompilationUnitCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").PackageDeclarationCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ImportDeclarationCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").TypeDeclarationCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ModuleDeclarationCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").RequiresModuleDirectiveCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ExportsModuleDirectiveCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").OpensModuleDirectiveCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").UsesModuleDirectiveCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ProvidesModuleDirectiveCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ModuleDirectiveCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").RequiresModifierCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").PackageModifierCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").PrimitiveTypeCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ReferenceTypeCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").TypeVariableCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").DimsCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").TypeParameterCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").TypeBoundCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").AdditionalBoundCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").TypeArgumentsCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").TypeArgumentListCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").WildcardCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").WildcardBoundsCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").InterfaceTypeCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ClassTypeCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").NumericTypeCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").ClassOrInterfaceTypeCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").FloatingPointTypeCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").IntegralTypeCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").TypeArgumentCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").TypeParameterModifierCstNode & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}> | import("prettier").AstPath<import("java-parser").IToken & {
|
||||
comments?: import("./comments.js").JavaComment[];
|
||||
}>, options: import("prettier").ParserOptions<JavaNode>, print: (path: import("prettier").AstPath<JavaNode>) => import("prettier").Doc, args: unknown): import("prettier/doc.js").builders.Doc;
|
||||
hasPrettierIgnore(path: import("prettier").AstPath<JavaNode>): boolean;
|
||||
canAttachComment: typeof import("./comments.js").canAttachComment;
|
||||
isBlockComment(node: JavaNode): boolean;
|
||||
printComment(commentPath: import("prettier").AstPath<JavaNode>): string | import("prettier/doc.js").builders.Doc[];
|
||||
getCommentChildNodes(node: JavaNode): any[];
|
||||
handleComments: {
|
||||
ownLine: typeof import("./comments.js").handleLineComment;
|
||||
endOfLine: typeof import("./comments.js").handleLineComment;
|
||||
remaining: typeof import("./comments.js").handleRemainingComment;
|
||||
};
|
||||
};
|
||||
};
|
||||
options: {
|
||||
entrypoint: {
|
||||
type: "choice";
|
||||
category: string;
|
||||
default: string;
|
||||
choices: {
|
||||
value: string;
|
||||
description: string;
|
||||
}[];
|
||||
description: string;
|
||||
};
|
||||
arrowParens: {
|
||||
type: "choice";
|
||||
category: string;
|
||||
default: string;
|
||||
choices: {
|
||||
value: string;
|
||||
description: string;
|
||||
}[];
|
||||
description: string;
|
||||
};
|
||||
trailingComma: {
|
||||
type: "choice";
|
||||
category: string;
|
||||
default: string;
|
||||
choices: {
|
||||
value: string;
|
||||
description: string;
|
||||
}[];
|
||||
description: string;
|
||||
};
|
||||
experimentalOperatorPosition: {
|
||||
type: "choice";
|
||||
category: string;
|
||||
default: string;
|
||||
choices: {
|
||||
value: string;
|
||||
description: string;
|
||||
}[];
|
||||
description: string;
|
||||
};
|
||||
};
|
||||
defaultOptions: {
|
||||
arrowParens: "avoid";
|
||||
};
|
||||
};
|
||||
export default _default;
|
||||
29
frontend/src/common/prettier/plugins/java/index.js
Normal file
29
frontend/src/common/prettier/plugins/java/index.js
Normal file
@@ -0,0 +1,29 @@
|
||||
import options from "./options.js";
|
||||
import parser from "./parser.js";
|
||||
import printer from "./printer.js";
|
||||
export default {
|
||||
languages: [
|
||||
{
|
||||
name: "Java",
|
||||
parsers: ["java"],
|
||||
group: "Java",
|
||||
tmScope: "source.java",
|
||||
aceMode: "java",
|
||||
codemirrorMode: "clike",
|
||||
codemirrorMimeType: "text/x-java",
|
||||
extensions: [".java"],
|
||||
linguistLanguageId: 181,
|
||||
vscodeLanguageIds: ["java"]
|
||||
}
|
||||
],
|
||||
parsers: {
|
||||
java: parser
|
||||
},
|
||||
printers: {
|
||||
java: printer
|
||||
},
|
||||
options,
|
||||
defaultOptions: {
|
||||
arrowParens: "avoid"
|
||||
}
|
||||
};
|
||||
43
frontend/src/common/prettier/plugins/java/options.d.ts
vendored
Normal file
43
frontend/src/common/prettier/plugins/java/options.d.ts
vendored
Normal file
@@ -0,0 +1,43 @@
|
||||
declare const _default: {
|
||||
entrypoint: {
|
||||
type: "choice";
|
||||
category: string;
|
||||
default: string;
|
||||
choices: {
|
||||
value: string;
|
||||
description: string;
|
||||
}[];
|
||||
description: string;
|
||||
};
|
||||
arrowParens: {
|
||||
type: "choice";
|
||||
category: string;
|
||||
default: string;
|
||||
choices: {
|
||||
value: string;
|
||||
description: string;
|
||||
}[];
|
||||
description: string;
|
||||
};
|
||||
trailingComma: {
|
||||
type: "choice";
|
||||
category: string;
|
||||
default: string;
|
||||
choices: {
|
||||
value: string;
|
||||
description: string;
|
||||
}[];
|
||||
description: string;
|
||||
};
|
||||
experimentalOperatorPosition: {
|
||||
type: "choice";
|
||||
category: string;
|
||||
default: string;
|
||||
choices: {
|
||||
value: string;
|
||||
description: string;
|
||||
}[];
|
||||
description: string;
|
||||
};
|
||||
};
|
||||
export default _default;
|
||||
284
frontend/src/common/prettier/plugins/java/options.js
Normal file
284
frontend/src/common/prettier/plugins/java/options.js
Normal file
@@ -0,0 +1,284 @@
|
||||
export default {
|
||||
entrypoint: {
|
||||
type: "choice",
|
||||
category: "Global",
|
||||
default: "compilationUnit",
|
||||
// sed -nr 's/.*\.RULE\(([^,]+),.*/\1/p' $(ls path/to/java-parser/rules/folder/*)
|
||||
choices: [
|
||||
{ value: "arrayInitializer", description: "" },
|
||||
{ value: "variableInitializerList", description: "" },
|
||||
{ value: "block", description: "" },
|
||||
{ value: "blockStatements", description: "" },
|
||||
{ value: "blockStatement", description: "" },
|
||||
{ value: "localVariableDeclarationStatement", description: "" },
|
||||
{ value: "localVariableDeclaration", description: "" },
|
||||
{ value: "localVariableType", description: "" },
|
||||
{ value: "statement", description: "" },
|
||||
{ value: "statementWithoutTrailingSubstatement", description: "" },
|
||||
{ value: "emptyStatement", description: "" },
|
||||
{ value: "labeledStatement", description: "" },
|
||||
{ value: "expressionStatement", description: "" },
|
||||
{ value: "statementExpression", description: "" },
|
||||
{ value: "ifStatement", description: "" },
|
||||
{ value: "assertStatement", description: "" },
|
||||
{ value: "switchStatement", description: "" },
|
||||
{ value: "switchBlock", description: "" },
|
||||
{ value: "switchBlockStatementGroup", description: "" },
|
||||
{ value: "switchLabel", description: "" },
|
||||
{ value: "switchRule", description: "" },
|
||||
{ value: "caseConstant", description: "" },
|
||||
{ value: "casePattern", description: "" },
|
||||
{ value: "whileStatement", description: "" },
|
||||
{ value: "doStatement", description: "" },
|
||||
{ value: "forStatement", description: "" },
|
||||
{ value: "basicForStatement", description: "" },
|
||||
{ value: "forInit", description: "" },
|
||||
{ value: "forUpdate", description: "" },
|
||||
{ value: "statementExpressionList", description: "" },
|
||||
{ value: "enhancedForStatement", description: "" },
|
||||
{ value: "breakStatement", description: "" },
|
||||
{ value: "continueStatement", description: "" },
|
||||
{ value: "returnStatement", description: "" },
|
||||
{ value: "throwStatement", description: "" },
|
||||
{ value: "synchronizedStatement", description: "" },
|
||||
{ value: "tryStatement", description: "" },
|
||||
{ value: "catches", description: "" },
|
||||
{ value: "catchClause", description: "" },
|
||||
{ value: "catchFormalParameter", description: "" },
|
||||
{ value: "catchType", description: "" },
|
||||
{ value: "finally", description: "" },
|
||||
{ value: "tryWithResourcesStatement", description: "" },
|
||||
{ value: "resourceSpecification", description: "" },
|
||||
{ value: "resourceList", description: "" },
|
||||
{ value: "resource", description: "" },
|
||||
{ value: "yieldStatement", description: "" },
|
||||
{ value: "variableAccess", description: "" },
|
||||
{ value: "classDeclaration", description: "" },
|
||||
{ value: "normalClassDeclaration", description: "" },
|
||||
{ value: "classModifier", description: "" },
|
||||
{ value: "typeParameters", description: "" },
|
||||
{ value: "typeParameterList", description: "" },
|
||||
{ value: "classExtends", description: "" },
|
||||
{ value: "classImplements", description: "" },
|
||||
{ value: "interfaceTypeList", description: "" },
|
||||
{ value: "classPermits", description: "" },
|
||||
{ value: "classBody", description: "" },
|
||||
{ value: "classBodyDeclaration", description: "" },
|
||||
{ value: "classMemberDeclaration", description: "" },
|
||||
{ value: "fieldDeclaration", description: "" },
|
||||
{ value: "fieldModifier", description: "" },
|
||||
{ value: "variableDeclaratorList", description: "" },
|
||||
{ value: "variableDeclarator", description: "" },
|
||||
{ value: "variableDeclaratorId", description: "" },
|
||||
{ value: "variableInitializer", description: "" },
|
||||
{ value: "unannType", description: "" },
|
||||
{ value: "unannPrimitiveTypeWithOptionalDimsSuffix", description: "" },
|
||||
{ value: "unannPrimitiveType", description: "" },
|
||||
{ value: "unannReferenceType", description: "" },
|
||||
{ value: "unannClassOrInterfaceType", description: "" },
|
||||
{ value: "unannClassType", description: "" },
|
||||
{ value: "unannInterfaceType", description: "" },
|
||||
{ value: "unannTypeVariable", description: "" },
|
||||
{ value: "methodDeclaration", description: "" },
|
||||
{ value: "methodModifier", description: "" },
|
||||
{ value: "methodHeader", description: "" },
|
||||
{ value: "result", description: "" },
|
||||
{ value: "methodDeclarator", description: "" },
|
||||
{ value: "receiverParameter", description: "" },
|
||||
{ value: "formalParameterList", description: "" },
|
||||
{ value: "formalParameter", description: "" },
|
||||
{ value: "variableParaRegularParameter", description: "" },
|
||||
{ value: "variableArityParameter", description: "" },
|
||||
{ value: "variableModifier", description: "" },
|
||||
{ value: "throws", description: "" },
|
||||
{ value: "exceptionTypeList", description: "" },
|
||||
{ value: "exceptionType", description: "" },
|
||||
{ value: "methodBody", description: "" },
|
||||
{ value: "instanceInitializer", description: "" },
|
||||
{ value: "staticInitializer", description: "" },
|
||||
{ value: "constructorDeclaration", description: "" },
|
||||
{ value: "constructorModifier", description: "" },
|
||||
{ value: "constructorDeclarator", description: "" },
|
||||
{ value: "simpleTypeName", description: "" },
|
||||
{ value: "constructorBody", description: "" },
|
||||
{ value: "explicitConstructorInvocation", description: "" },
|
||||
{ value: "unqualifiedExplicitConstructorInvocation", description: "" },
|
||||
{ value: "qualifiedExplicitConstructorInvocation", description: "" },
|
||||
{ value: "enumDeclaration", description: "" },
|
||||
{ value: "enumBody", description: "" },
|
||||
{ value: "enumConstantList", description: "" },
|
||||
{ value: "enumConstant", description: "" },
|
||||
{ value: "enumConstantModifier", description: "" },
|
||||
{ value: "enumBodyDeclarations", description: "" },
|
||||
{ value: "recordDeclaration", description: "" },
|
||||
{ value: "recordHeader", description: "" },
|
||||
{ value: "recordComponentList", description: "" },
|
||||
{ value: "recordComponent", description: "" },
|
||||
{ value: "variableArityRecordComponent", description: "" },
|
||||
{ value: "recordComponentModifier", description: "" },
|
||||
{ value: "recordBody", description: "" },
|
||||
{ value: "recordBodyDeclaration", description: "" },
|
||||
{ value: "compactConstructorDeclaration", description: "" },
|
||||
{ value: "isDims", description: "" },
|
||||
{ value: "expression", description: "" },
|
||||
{ value: "lambdaExpression", description: "" },
|
||||
{ value: "lambdaParameters", description: "" },
|
||||
{ value: "lambdaParametersWithBraces", description: "" },
|
||||
{ value: "lambdaParameterList", description: "" },
|
||||
{ value: "conciseLambdaParameterList", description: "" },
|
||||
{ value: "normalLambdaParameterList", description: "" },
|
||||
{ value: "normalLambdaParameter", description: "" },
|
||||
{ value: "regularLambdaParameter", description: "" },
|
||||
{ value: "lambdaParameterType", description: "" },
|
||||
{ value: "conciseLambdaParameter", description: "" },
|
||||
{ value: "lambdaBody", description: "" },
|
||||
{ value: "conditionalExpression", description: "" },
|
||||
{ value: "binaryExpression", description: "" },
|
||||
{ value: "unaryExpression", description: "" },
|
||||
{ value: "unaryExpressionNotPlusMinus", description: "" },
|
||||
{ value: "primary", description: "" },
|
||||
{ value: "primaryPrefix", description: "" },
|
||||
{ value: "primarySuffix", description: "" },
|
||||
{ value: "fqnOrRefType", description: "" },
|
||||
{ value: "fqnOrRefTypePartRest", description: "" },
|
||||
{ value: "fqnOrRefTypePartCommon", description: "" },
|
||||
{ value: "fqnOrRefTypePartFirst", description: "" },
|
||||
{ value: "parenthesisExpression", description: "" },
|
||||
{ value: "castExpression", description: "" },
|
||||
{ value: "primitiveCastExpression", description: "" },
|
||||
{ value: "referenceTypeCastExpression", description: "" },
|
||||
{ value: "newExpression", description: "" },
|
||||
{ value: "unqualifiedClassInstanceCreationExpression", description: "" },
|
||||
{ value: "classOrInterfaceTypeToInstantiate", description: "" },
|
||||
{ value: "typeArgumentsOrDiamond", description: "" },
|
||||
{ value: "diamond", description: "" },
|
||||
{ value: "methodInvocationSuffix", description: "" },
|
||||
{ value: "argumentList", description: "" },
|
||||
{ value: "arrayCreationExpression", description: "" },
|
||||
{
|
||||
value: "arrayCreationExpressionWithoutInitializerSuffix",
|
||||
description: ""
|
||||
},
|
||||
{ value: "arrayCreationWithInitializerSuffix", description: "" },
|
||||
{ value: "dimExprs", description: "" },
|
||||
{ value: "dimExpr", description: "" },
|
||||
{ value: "classLiteralSuffix", description: "" },
|
||||
{ value: "arrayAccessSuffix", description: "" },
|
||||
{ value: "methodReferenceSuffix", description: "" },
|
||||
{ value: "templateArgument", description: "" },
|
||||
{ value: "template", description: "" },
|
||||
{ value: "stringTemplate", description: "" },
|
||||
{ value: "textBlockTemplate", description: "" },
|
||||
{ value: "embeddedExpression", description: "" },
|
||||
{ value: "pattern", description: "" },
|
||||
{ value: "typePattern", description: "" },
|
||||
{ value: "recordPattern", description: "" },
|
||||
{ value: "componentPatternList", description: "" },
|
||||
{ value: "componentPattern", description: "" },
|
||||
{ value: "matchAllPattern", description: "" },
|
||||
{ value: "guard", description: "" },
|
||||
{ value: "isRefTypeInMethodRef", description: "" },
|
||||
{ value: "interfaceDeclaration", description: "" },
|
||||
{ value: "normalInterfaceDeclaration", description: "" },
|
||||
{ value: "interfaceModifier", description: "" },
|
||||
{ value: "interfaceExtends", description: "" },
|
||||
{ value: "interfacePermits", description: "" },
|
||||
{ value: "interfaceBody", description: "" },
|
||||
{ value: "interfaceMemberDeclaration", description: "" },
|
||||
{ value: "constantDeclaration", description: "" },
|
||||
{ value: "constantModifier", description: "" },
|
||||
{ value: "interfaceMethodDeclaration", description: "" },
|
||||
{ value: "interfaceMethodModifier", description: "" },
|
||||
{ value: "annotationInterfaceDeclaration", description: "" },
|
||||
{ value: "annotationInterfaceBody", description: "" },
|
||||
{ value: "annotationInterfaceMemberDeclaration", description: "" },
|
||||
{ value: "annotationInterfaceElementDeclaration", description: "" },
|
||||
{ value: "annotationInterfaceElementModifier", description: "" },
|
||||
{ value: "defaultValue", description: "" },
|
||||
{ value: "annotation", description: "" },
|
||||
{ value: "elementValuePairList", description: "" },
|
||||
{ value: "elementValuePair", description: "" },
|
||||
{ value: "elementValue", description: "" },
|
||||
{ value: "elementValueArrayInitializer", description: "" },
|
||||
{ value: "elementValueList", description: "" },
|
||||
{ value: "literal", description: "" },
|
||||
{ value: "integerLiteral", description: "" },
|
||||
{ value: "floatingPointLiteral", description: "" },
|
||||
{ value: "booleanLiteral", description: "" },
|
||||
{ value: "shiftOperator", description: "" },
|
||||
{ value: "moduleName", description: "" },
|
||||
{ value: "packageName", description: "" },
|
||||
{ value: "typeName", description: "" },
|
||||
{ value: "expressionName", description: "" },
|
||||
{ value: "methodName", description: "" },
|
||||
{ value: "packageOrTypeName", description: "" },
|
||||
{ value: "ambiguousName", description: "" },
|
||||
{ value: "compilationUnit", description: "" },
|
||||
{ value: "ordinaryCompilationUnit", description: "" },
|
||||
{ value: "modularCompilationUnit", description: "" },
|
||||
{ value: "packageDeclaration", description: "" },
|
||||
{ value: "packageModifier", description: "" },
|
||||
{ value: "importDeclaration", description: "" },
|
||||
{ value: "typeDeclaration", description: "" },
|
||||
{ value: "moduleDeclaration", description: "" },
|
||||
{ value: "moduleDirective", description: "" },
|
||||
{ value: "requiresModuleDirective", description: "" },
|
||||
{ value: "exportsModuleDirective", description: "" },
|
||||
{ value: "opensModuleDirective", description: "" },
|
||||
{ value: "usesModuleDirective", description: "" },
|
||||
{ value: "providesModuleDirective", description: "" },
|
||||
{ value: "requiresModifier", description: "" },
|
||||
{ value: "primitiveType", description: "" },
|
||||
{ value: "numericType", description: "" },
|
||||
{ value: "integralType", description: "" },
|
||||
{ value: "floatingPointType", description: "" },
|
||||
{ value: "referenceType", description: "" },
|
||||
{ value: "classOrInterfaceType", description: "" },
|
||||
{ value: "classType", description: "" },
|
||||
{ value: "interfaceType", description: "" },
|
||||
{ value: "typeVariable", description: "" },
|
||||
{ value: "dims", description: "" },
|
||||
{ value: "typeParameter", description: "" },
|
||||
{ value: "typeParameterModifier", description: "" },
|
||||
{ value: "typeBound", description: "" },
|
||||
{ value: "additionalBound", description: "" },
|
||||
{ value: "typeArguments", description: "" },
|
||||
{ value: "typeArgumentList", description: "" },
|
||||
{ value: "typeArgument", description: "" },
|
||||
{ value: "wildcard", description: "" },
|
||||
{ value: "wildcardBounds", description: "" }
|
||||
],
|
||||
description: "Prettify from the entrypoint, allowing to use prettier on snippet."
|
||||
},
|
||||
arrowParens: {
|
||||
type: "choice",
|
||||
category: "Java",
|
||||
default: "always",
|
||||
choices: [
|
||||
{ value: "always", description: "" },
|
||||
{ value: "avoid", description: "" }
|
||||
],
|
||||
description: "Include parentheses around a sole arrow function parameter."
|
||||
},
|
||||
trailingComma: {
|
||||
type: "choice",
|
||||
category: "Java",
|
||||
default: "all",
|
||||
choices: [
|
||||
{ value: "all", description: "" },
|
||||
{ value: "es5", description: "" },
|
||||
{ value: "none", description: "" }
|
||||
],
|
||||
description: "Print trailing commas wherever possible when multi-line."
|
||||
},
|
||||
experimentalOperatorPosition: {
|
||||
type: "choice",
|
||||
category: "Java",
|
||||
default: "end",
|
||||
choices: [
|
||||
{ value: "start", description: "" },
|
||||
{ value: "end", description: "" }
|
||||
],
|
||||
description: "Where to print operators when binary expressions wrap lines."
|
||||
}
|
||||
};
|
||||
9
frontend/src/common/prettier/plugins/java/parser.d.ts
vendored
Normal file
9
frontend/src/common/prettier/plugins/java/parser.d.ts
vendored
Normal file
@@ -0,0 +1,9 @@
|
||||
import { type JavaNode, type JavaNonTerminal, type JavaParserOptions } from "./printers/helpers.js";
|
||||
declare const _default: {
|
||||
parse(text: string, options: JavaParserOptions): JavaNonTerminal;
|
||||
astFormat: string;
|
||||
hasPragma(text: string): boolean;
|
||||
locStart(node: JavaNode): number;
|
||||
locEnd(node: JavaNode): number;
|
||||
};
|
||||
export default _default;
|
||||
24
frontend/src/common/prettier/plugins/java/parser.js
Normal file
24
frontend/src/common/prettier/plugins/java/parser.js
Normal file
@@ -0,0 +1,24 @@
|
||||
import { parse } from "java-parser";
|
||||
import { determineFormatterOffOnRanges } from "./comments.js";
|
||||
import { isTerminal } from "./printers/helpers.js";
|
||||
export default {
|
||||
parse(text, options) {
|
||||
var _a;
|
||||
const cst = parse(text, options.entrypoint);
|
||||
(_a = cst.comments) === null || _a === void 0 ? void 0 : _a.forEach(comment => {
|
||||
comment.value = comment.image;
|
||||
});
|
||||
determineFormatterOffOnRanges(cst);
|
||||
return cst;
|
||||
},
|
||||
astFormat: "java",
|
||||
hasPragma(text) {
|
||||
return /^\/\*\*\n\s+\*\s@(format|prettier)\n\s+\*\//.test(text);
|
||||
},
|
||||
locStart(node) {
|
||||
return isTerminal(node) ? node.startOffset : node.location.startOffset;
|
||||
},
|
||||
locEnd(node) {
|
||||
return (isTerminal(node) ? node.endOffset : node.location.endOffset) + 1;
|
||||
}
|
||||
};
|
||||
18
frontend/src/common/prettier/plugins/java/printer.d.ts
vendored
Normal file
18
frontend/src/common/prettier/plugins/java/printer.d.ts
vendored
Normal file
@@ -0,0 +1,18 @@
|
||||
import type { AstPath } from "prettier";
|
||||
import { canAttachComment, handleLineComment, handleRemainingComment } from "./comments.js";
|
||||
import { type JavaNode } from "./printers/helpers.js";
|
||||
declare const _default: {
|
||||
print(path: DistributedAstPath<JavaNode>, options: import("prettier").ParserOptions<JavaNode>, print: (path: AstPath<JavaNode>) => import("prettier").Doc, args: unknown): import("prettier/doc.js").builders.Doc;
|
||||
hasPrettierIgnore(path: AstPath<JavaNode>): boolean;
|
||||
canAttachComment: typeof canAttachComment;
|
||||
isBlockComment(node: JavaNode): boolean;
|
||||
printComment(commentPath: AstPath<JavaNode>): string | import("prettier/doc.js").builders.Doc[];
|
||||
getCommentChildNodes(node: JavaNode): any[];
|
||||
handleComments: {
|
||||
ownLine: typeof handleLineComment;
|
||||
endOfLine: typeof handleLineComment;
|
||||
remaining: typeof handleRemainingComment;
|
||||
};
|
||||
};
|
||||
export default _default;
|
||||
type DistributedAstPath<T> = T extends any ? AstPath<T> : never;
|
||||
40
frontend/src/common/prettier/plugins/java/printer.js
Normal file
40
frontend/src/common/prettier/plugins/java/printer.js
Normal file
@@ -0,0 +1,40 @@
|
||||
import { canAttachComment, handleLineComment, handleRemainingComment, isFullyBetweenFormatterOffOn } from "./comments.js";
|
||||
import { isNonTerminal, isTerminal, printComment } from "./printers/helpers.js";
|
||||
import { printerForNodeType } from "./printers/index.js";
|
||||
export default {
|
||||
print(path, options, print, args) {
|
||||
return hasTerminal(path)
|
||||
? path.node.image
|
||||
: printerForNodeType(path.node.name)(path, print, options, args);
|
||||
},
|
||||
hasPrettierIgnore(path) {
|
||||
var _a;
|
||||
const { node } = path;
|
||||
return (((_a = node.comments) === null || _a === void 0 ? void 0 : _a.some(({ image }) => /^(\/\/\s*prettier-ignore|\/\*\s*prettier-ignore\s*\*\/)$/.test(image))) === true ||
|
||||
(canAttachComment(node) && isFullyBetweenFormatterOffOn(path)));
|
||||
},
|
||||
canAttachComment,
|
||||
isBlockComment(node) {
|
||||
return isTerminal(node) && node.tokenType.name === "TraditionalComment";
|
||||
},
|
||||
printComment(commentPath) {
|
||||
const { node } = commentPath;
|
||||
if (isNonTerminal(node) || node.tokenType.GROUP !== "comments") {
|
||||
throw new Error(`Not a comment: ${JSON.stringify(node)}`);
|
||||
}
|
||||
return printComment(node);
|
||||
},
|
||||
getCommentChildNodes(node) {
|
||||
return isNonTerminal(node)
|
||||
? Object.values(node.children).flatMap(child => child)
|
||||
: [];
|
||||
},
|
||||
handleComments: {
|
||||
ownLine: handleLineComment,
|
||||
endOfLine: handleLineComment,
|
||||
remaining: handleRemainingComment
|
||||
}
|
||||
};
|
||||
function hasTerminal(path) {
|
||||
return isTerminal(path.node);
|
||||
}
|
||||
9
frontend/src/common/prettier/plugins/java/printers/arrays.d.ts
vendored
Normal file
9
frontend/src/common/prettier/plugins/java/printers/arrays.d.ts
vendored
Normal file
@@ -0,0 +1,9 @@
|
||||
declare const _default: {
|
||||
arrayInitializer(path: import("prettier").AstPath<import("java-parser").ArrayInitializerCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn, options: import("./helpers.js").JavaParserOptions): import("prettier/doc.js").builders.Group | "{}";
|
||||
variableInitializerList(path: import("prettier").AstPath<import("java-parser").VariableInitializerListCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): import("prettier/doc.js").builders.Doc[];
|
||||
};
|
||||
export default _default;
|
||||
@@ -0,0 +1,9 @@
|
||||
import { printArrayInitializer, printList } from "./helpers.js";
|
||||
export default {
|
||||
arrayInitializer(path, print, options) {
|
||||
return printArrayInitializer(path, print, options, "variableInitializerList");
|
||||
},
|
||||
variableInitializerList(path, print) {
|
||||
return printList(path, print, "variableInitializer");
|
||||
}
|
||||
};
|
||||
117
frontend/src/common/prettier/plugins/java/printers/blocks-and-statements.d.ts
vendored
Normal file
117
frontend/src/common/prettier/plugins/java/printers/blocks-and-statements.d.ts
vendored
Normal file
@@ -0,0 +1,117 @@
|
||||
import { builders } from "prettier/doc";
|
||||
import { printSingle } from "./helpers.js";
|
||||
declare const _default: {
|
||||
block(path: import("prettier").AstPath<import("java-parser").BlockCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Group | "{}" | (string | builders.Indent | builders.Hardline)[];
|
||||
blockStatements(path: import("prettier").AstPath<import("java-parser").BlockStatementsCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
blockStatement: typeof printSingle;
|
||||
localVariableDeclarationStatement(path: import("prettier").AstPath<import("java-parser").LocalVariableDeclarationStatementCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
localVariableDeclaration(path: import("prettier").AstPath<import("java-parser").LocalVariableDeclarationCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
localVariableType: typeof printSingle;
|
||||
statement: typeof printSingle;
|
||||
statementWithoutTrailingSubstatement: typeof printSingle;
|
||||
emptyStatement(): string;
|
||||
labeledStatement(path: import("prettier").AstPath<import("java-parser").LabeledStatementCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
expressionStatement(path: import("prettier").AstPath<import("java-parser").ExpressionStatementCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
statementExpression: typeof printSingle;
|
||||
ifStatement(path: import("prettier").AstPath<import("java-parser").IfStatementCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
assertStatement(path: import("prettier").AstPath<import("java-parser").AssertStatementCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
switchStatement(path: import("prettier").AstPath<import("java-parser").SwitchStatementCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
switchBlock(path: import("prettier").AstPath<import("java-parser").SwitchBlockCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Group | "{}" | (string | builders.Indent | builders.Hardline)[];
|
||||
switchBlockStatementGroup(path: import("prettier").AstPath<import("java-parser").SwitchBlockStatementGroupCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
switchLabel(path: import("prettier").AstPath<import("java-parser").SwitchLabelCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): "default" | builders.Group | builders.Doc[];
|
||||
switchRule(path: import("prettier").AstPath<import("java-parser").SwitchRuleCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
caseConstant: typeof printSingle;
|
||||
casePattern: typeof printSingle;
|
||||
whileStatement(path: import("prettier").AstPath<import("java-parser").WhileStatementCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
doStatement(path: import("prettier").AstPath<import("java-parser").DoStatementCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): (string | builders.Group | builders.Doc[])[];
|
||||
forStatement: typeof printSingle;
|
||||
basicForStatement(path: import("prettier").AstPath<import("java-parser").BasicForStatementCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
forInit: typeof printSingle;
|
||||
forUpdate: typeof printSingle;
|
||||
statementExpressionList(path: import("prettier").AstPath<import("java-parser").StatementExpressionListCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Group;
|
||||
enhancedForStatement(path: import("prettier").AstPath<import("java-parser").EnhancedForStatementCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Group;
|
||||
breakStatement(path: import("prettier").AstPath<import("java-parser").BreakStatementCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[] | "break;";
|
||||
continueStatement(path: import("prettier").AstPath<import("java-parser").ContinueStatementCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[] | "continue;";
|
||||
returnStatement(path: import("prettier").AstPath<import("java-parser").ReturnStatementCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
throwStatement(path: import("prettier").AstPath<import("java-parser").ThrowStatementCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
synchronizedStatement(path: import("prettier").AstPath<import("java-parser").SynchronizedStatementCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
tryStatement(path: import("prettier").AstPath<import("java-parser").TryStatementCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc;
|
||||
catches(path: import("prettier").AstPath<import("java-parser").CatchesCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
catchClause(path: import("prettier").AstPath<import("java-parser").CatchClauseCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
catchFormalParameter(path: import("prettier").AstPath<import("java-parser").CatchFormalParameterCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
catchType(path: import("prettier").AstPath<import("java-parser").CatchTypeCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
finally(path: import("prettier").AstPath<import("java-parser").FinallyCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
tryWithResourcesStatement(path: import("prettier").AstPath<import("java-parser").TryWithResourcesStatementCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
resourceSpecification(path: import("prettier").AstPath<import("java-parser").ResourceSpecificationCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Group | "()";
|
||||
resourceList(path: import("prettier").AstPath<import("java-parser").ResourceListCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
resource: typeof printSingle;
|
||||
yieldStatement(path: import("prettier").AstPath<import("java-parser").YieldStatementCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
variableAccess: typeof printSingle;
|
||||
};
|
||||
export default _default;
|
||||
@@ -0,0 +1,337 @@
|
||||
import { builders } from "prettier/doc";
|
||||
import { call, definedKeys, indentInParentheses, isBinaryExpression, isEmptyStatement, lineEndWithComments, lineStartWithComments, map, onlyDefinedKey, printBlock, printDanglingComments, printSingle, printWithModifiers } from "./helpers.js";
|
||||
const { group, hardline, ifBreak, indent, join, line, softline } = builders;
|
||||
export default {
|
||||
block(path, print) {
|
||||
const statements = path.node.children.blockStatements
|
||||
? call(path, print, "blockStatements")
|
||||
: [];
|
||||
return printBlock(path, statements.length ? [statements] : []);
|
||||
},
|
||||
blockStatements(path, print) {
|
||||
return join(hardline, map(path, statementPath => {
|
||||
const { node, previous } = statementPath;
|
||||
const statement = print(statementPath);
|
||||
return previous &&
|
||||
lineStartWithComments(node) > lineEndWithComments(previous) + 1
|
||||
? [hardline, statement]
|
||||
: statement;
|
||||
}, "blockStatement").filter(doc => doc !== ""));
|
||||
},
|
||||
blockStatement: printSingle,
|
||||
localVariableDeclarationStatement(path, print) {
|
||||
return [call(path, print, "localVariableDeclaration"), ";"];
|
||||
},
|
||||
localVariableDeclaration(path, print) {
|
||||
const declaration = join(" ", [
|
||||
call(path, print, "localVariableType"),
|
||||
call(path, print, "variableDeclaratorList")
|
||||
]);
|
||||
return printWithModifiers(path, print, "variableModifier", declaration);
|
||||
},
|
||||
localVariableType: printSingle,
|
||||
statement: printSingle,
|
||||
statementWithoutTrailingSubstatement: printSingle,
|
||||
emptyStatement() {
|
||||
return "";
|
||||
},
|
||||
labeledStatement(path, print) {
|
||||
return [
|
||||
call(path, print, "Identifier"),
|
||||
": ",
|
||||
call(path, print, "statement")
|
||||
];
|
||||
},
|
||||
expressionStatement(path, print) {
|
||||
return [call(path, print, "statementExpression"), ";"];
|
||||
},
|
||||
statementExpression: printSingle,
|
||||
ifStatement(path, print) {
|
||||
var _a;
|
||||
const { children } = path.node;
|
||||
const hasEmptyStatement = isEmptyStatement(children.statement[0]);
|
||||
const statements = map(path, print, "statement");
|
||||
const statement = [
|
||||
"if ",
|
||||
indentInParentheses(call(path, print, "expression")),
|
||||
hasEmptyStatement ? ";" : [" ", statements[0]]
|
||||
];
|
||||
if (children.Else) {
|
||||
const danglingComments = printDanglingComments(path);
|
||||
if (danglingComments.length) {
|
||||
statement.push(hardline, ...danglingComments, hardline);
|
||||
}
|
||||
else {
|
||||
const elseHasBlock = ((_a = children.statement[0].children
|
||||
.statementWithoutTrailingSubstatement) === null || _a === void 0 ? void 0 : _a[0].children.block) !==
|
||||
undefined;
|
||||
statement.push(elseHasBlock ? " " : hardline);
|
||||
}
|
||||
const elseHasEmptyStatement = isEmptyStatement(children.statement[1]);
|
||||
statement.push("else", elseHasEmptyStatement ? ";" : [" ", statements[1]]);
|
||||
}
|
||||
return statement;
|
||||
},
|
||||
assertStatement(path, print) {
|
||||
return ["assert ", ...join([" : "], map(path, print, "expression")), ";"];
|
||||
},
|
||||
switchStatement(path, print) {
|
||||
return join(" ", [
|
||||
"switch",
|
||||
indentInParentheses(call(path, print, "expression")),
|
||||
call(path, print, "switchBlock")
|
||||
]);
|
||||
},
|
||||
switchBlock(path, print) {
|
||||
const { children } = path.node;
|
||||
const caseKeys = definedKeys(children, [
|
||||
"switchBlockStatementGroup",
|
||||
"switchRule"
|
||||
]);
|
||||
const cases = caseKeys.length === 1 ? map(path, print, caseKeys[0]) : [];
|
||||
return printBlock(path, cases);
|
||||
},
|
||||
switchBlockStatementGroup(path, print) {
|
||||
var _a, _b;
|
||||
const { children } = path.node;
|
||||
const switchLabel = call(path, print, "switchLabel");
|
||||
if (!children.blockStatements) {
|
||||
return [switchLabel, ":"];
|
||||
}
|
||||
const blockStatements = call(path, print, "blockStatements");
|
||||
const statements = children.blockStatements[0].children.blockStatement;
|
||||
const onlyStatementIsBlock = statements.length === 1 &&
|
||||
((_b = (_a = statements[0].children.statement) === null || _a === void 0 ? void 0 : _a[0].children.statementWithoutTrailingSubstatement) === null || _b === void 0 ? void 0 : _b[0].children.block) !== undefined;
|
||||
return [
|
||||
switchLabel,
|
||||
":",
|
||||
onlyStatementIsBlock
|
||||
? [" ", blockStatements]
|
||||
: indent([hardline, blockStatements])
|
||||
];
|
||||
},
|
||||
switchLabel(path, print) {
|
||||
var _a, _b;
|
||||
const { children } = path.node;
|
||||
if (!((_b = (_a = children.caseConstant) !== null && _a !== void 0 ? _a : children.casePattern) !== null && _b !== void 0 ? _b : children.Null)) {
|
||||
return "default";
|
||||
}
|
||||
const values = [];
|
||||
if (children.Null) {
|
||||
values.push("null");
|
||||
if (children.Default) {
|
||||
values.push("default");
|
||||
}
|
||||
}
|
||||
else {
|
||||
const valuesKey = onlyDefinedKey(children, [
|
||||
"caseConstant",
|
||||
"casePattern"
|
||||
]);
|
||||
values.push(...map(path, print, valuesKey));
|
||||
}
|
||||
const hasMultipleValues = values.length > 1;
|
||||
const label = hasMultipleValues
|
||||
? ["case", indent([line, ...join([",", line], values)])]
|
||||
: ["case ", values[0]];
|
||||
return children.guard
|
||||
? [
|
||||
group([...label, hasMultipleValues ? line : " "]),
|
||||
call(path, print, "guard")
|
||||
]
|
||||
: group(label);
|
||||
},
|
||||
switchRule(path, print) {
|
||||
const { children } = path.node;
|
||||
const bodyKey = onlyDefinedKey(children, [
|
||||
"block",
|
||||
"expression",
|
||||
"throwStatement"
|
||||
]);
|
||||
const parts = [
|
||||
call(path, print, "switchLabel"),
|
||||
" -> ",
|
||||
call(path, print, bodyKey)
|
||||
];
|
||||
if (children.Semicolon) {
|
||||
parts.push(";");
|
||||
}
|
||||
return parts;
|
||||
},
|
||||
caseConstant: printSingle,
|
||||
casePattern: printSingle,
|
||||
whileStatement(path, print) {
|
||||
const statement = call(path, print, "statement");
|
||||
const hasEmptyStatement = isEmptyStatement(path.node.children.statement[0]);
|
||||
return [
|
||||
"while ",
|
||||
indentInParentheses(call(path, print, "expression")),
|
||||
...[hasEmptyStatement ? ";" : " ", statement]
|
||||
];
|
||||
},
|
||||
doStatement(path, print) {
|
||||
const hasEmptyStatement = isEmptyStatement(path.node.children.statement[0]);
|
||||
return [
|
||||
"do",
|
||||
hasEmptyStatement ? ";" : [" ", call(path, print, "statement")],
|
||||
" while ",
|
||||
indentInParentheses(call(path, print, "expression")),
|
||||
";"
|
||||
];
|
||||
},
|
||||
forStatement: printSingle,
|
||||
basicForStatement(path, print) {
|
||||
const { children } = path.node;
|
||||
const danglingComments = printDanglingComments(path);
|
||||
if (danglingComments.length) {
|
||||
danglingComments.push(hardline);
|
||||
}
|
||||
const expressions = ["forInit", "expression", "forUpdate"].map(expressionKey => expressionKey in children ? call(path, print, expressionKey) : "");
|
||||
const hasEmptyStatement = isEmptyStatement(children.statement[0]);
|
||||
return [
|
||||
...danglingComments,
|
||||
"for ",
|
||||
expressions.some(expression => expression !== "")
|
||||
? indentInParentheses(join([";", line], expressions))
|
||||
: "(;;)",
|
||||
hasEmptyStatement ? ";" : [" ", call(path, print, "statement")]
|
||||
];
|
||||
},
|
||||
forInit: printSingle,
|
||||
forUpdate: printSingle,
|
||||
statementExpressionList(path, print) {
|
||||
return group(map(path, print, "statementExpression").map((expression, index) => index === 0 ? expression : [",", indent([line, expression])]));
|
||||
},
|
||||
enhancedForStatement(path, print) {
|
||||
var _a;
|
||||
const statementNode = path.node.children.statement[0];
|
||||
const forStatement = [
|
||||
printDanglingComments(path),
|
||||
"for ",
|
||||
"(",
|
||||
call(path, print, "localVariableDeclaration"),
|
||||
" : ",
|
||||
call(path, print, "expression"),
|
||||
")"
|
||||
];
|
||||
if (isEmptyStatement(statementNode)) {
|
||||
forStatement.push(";");
|
||||
}
|
||||
else {
|
||||
const hasStatementBlock = ((_a = statementNode.children.statementWithoutTrailingSubstatement) === null || _a === void 0 ? void 0 : _a[0].children.block) !== undefined;
|
||||
const statement = call(path, print, "statement");
|
||||
forStatement.push(hasStatementBlock ? [" ", statement] : indent([line, statement]));
|
||||
}
|
||||
return group(forStatement);
|
||||
},
|
||||
breakStatement(path, print) {
|
||||
return path.node.children.Identifier
|
||||
? ["break ", call(path, print, "Identifier"), ";"]
|
||||
: "break;";
|
||||
},
|
||||
continueStatement(path, print) {
|
||||
return path.node.children.Identifier
|
||||
? ["continue ", call(path, print, "Identifier"), ";"]
|
||||
: "continue;";
|
||||
},
|
||||
returnStatement(path, print) {
|
||||
const { children } = path.node;
|
||||
const statement = ["return"];
|
||||
if (children.expression) {
|
||||
statement.push(" ");
|
||||
const expression = call(path, print, "expression");
|
||||
if (isBinaryExpression(children.expression[0])) {
|
||||
statement.push(group([
|
||||
ifBreak("("),
|
||||
indent([softline, expression]),
|
||||
softline,
|
||||
ifBreak(")")
|
||||
]));
|
||||
}
|
||||
else {
|
||||
statement.push(expression);
|
||||
}
|
||||
}
|
||||
statement.push(";");
|
||||
return statement;
|
||||
},
|
||||
throwStatement(path, print) {
|
||||
return ["throw ", call(path, print, "expression"), ";"];
|
||||
},
|
||||
synchronizedStatement(path, print) {
|
||||
return [
|
||||
"synchronized ",
|
||||
indentInParentheses(call(path, print, "expression")),
|
||||
" ",
|
||||
call(path, print, "block")
|
||||
];
|
||||
},
|
||||
tryStatement(path, print) {
|
||||
const { children } = path.node;
|
||||
if (children.tryWithResourcesStatement) {
|
||||
return call(path, print, "tryWithResourcesStatement");
|
||||
}
|
||||
const blocks = ["try", call(path, print, "block")];
|
||||
if (children.catches) {
|
||||
blocks.push(call(path, print, "catches"));
|
||||
}
|
||||
if (children.finally) {
|
||||
blocks.push(call(path, print, "finally"));
|
||||
}
|
||||
return join(" ", blocks);
|
||||
},
|
||||
catches(path, print) {
|
||||
return join(" ", map(path, print, "catchClause"));
|
||||
},
|
||||
catchClause(path, print) {
|
||||
return [
|
||||
"catch ",
|
||||
indentInParentheses(call(path, print, "catchFormalParameter")),
|
||||
" ",
|
||||
call(path, print, "block")
|
||||
];
|
||||
},
|
||||
catchFormalParameter(path, print) {
|
||||
return join(" ", [
|
||||
...map(path, print, "variableModifier"),
|
||||
call(path, print, "catchType"),
|
||||
call(path, print, "variableDeclaratorId")
|
||||
]);
|
||||
},
|
||||
catchType(path, print) {
|
||||
return join([line, "| "], [call(path, print, "unannClassType"), ...map(path, print, "classType")]);
|
||||
},
|
||||
finally(path, print) {
|
||||
return ["finally ", call(path, print, "block")];
|
||||
},
|
||||
tryWithResourcesStatement(path, print) {
|
||||
const { children } = path.node;
|
||||
const blocks = [
|
||||
"try",
|
||||
call(path, print, "resourceSpecification"),
|
||||
call(path, print, "block")
|
||||
];
|
||||
if (children.catches) {
|
||||
blocks.push(call(path, print, "catches"));
|
||||
}
|
||||
if (children.finally) {
|
||||
blocks.push(call(path, print, "finally"));
|
||||
}
|
||||
return join(" ", blocks);
|
||||
},
|
||||
resourceSpecification(path, print) {
|
||||
const resources = [call(path, print, "resourceList")];
|
||||
if (path.node.children.Semicolon) {
|
||||
resources.push(ifBreak(";"));
|
||||
}
|
||||
return indentInParentheses(resources);
|
||||
},
|
||||
resourceList(path, print) {
|
||||
return join([";", line], map(path, print, "resource"));
|
||||
},
|
||||
resource: printSingle,
|
||||
yieldStatement(path, print) {
|
||||
return ["yield ", call(path, print, "expression"), ";"];
|
||||
},
|
||||
variableAccess: printSingle
|
||||
};
|
||||
157
frontend/src/common/prettier/plugins/java/printers/classes.d.ts
vendored
Normal file
157
frontend/src/common/prettier/plugins/java/printers/classes.d.ts
vendored
Normal file
@@ -0,0 +1,157 @@
|
||||
import type { ClassBodyCstNode, EnumBodyDeclarationsCstNode } from "java-parser";
|
||||
import type { AstPath } from "prettier";
|
||||
import { builders } from "prettier/doc";
|
||||
import { printClassPermits, printClassType, printSingle, type JavaPrintFn } from "./helpers.js";
|
||||
declare const _default: {
|
||||
classDeclaration(path: AstPath<import("java-parser").ClassDeclarationCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
normalClassDeclaration(path: AstPath<import("java-parser").NormalClassDeclarationCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
classModifier: typeof printSingle;
|
||||
typeParameters(path: AstPath<import("java-parser").TypeParametersCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Group;
|
||||
typeParameterList(path: AstPath<import("java-parser").TypeParameterListCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
classExtends(path: AstPath<import("java-parser").ClassExtendsCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
classImplements(path: AstPath<import("java-parser").ClassImplementsCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Group;
|
||||
classPermits: typeof printClassPermits;
|
||||
interfaceTypeList(path: AstPath<import("java-parser").InterfaceTypeListCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Group;
|
||||
classBody(path: AstPath<ClassBodyCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Group | "{}" | (string | builders.Indent | builders.Hardline)[];
|
||||
classBodyDeclaration: typeof printSingle;
|
||||
classMemberDeclaration(path: AstPath<import("java-parser").ClassMemberDeclarationCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc;
|
||||
fieldDeclaration(path: AstPath<import("java-parser").FieldDeclarationCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
fieldModifier: typeof printSingle;
|
||||
variableDeclaratorList(path: AstPath<import("java-parser").VariableDeclaratorListCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Group | builders.Doc[];
|
||||
variableDeclarator(path: AstPath<import("java-parser").VariableDeclaratorCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc;
|
||||
variableDeclaratorId(path: AstPath<import("java-parser").VariableDeclaratorIdCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc;
|
||||
variableInitializer: typeof printSingle;
|
||||
unannType: typeof printSingle;
|
||||
unannPrimitiveTypeWithOptionalDimsSuffix(path: AstPath<import("java-parser").UnannPrimitiveTypeWithOptionalDimsSuffixCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc;
|
||||
unannPrimitiveType: typeof printSingle;
|
||||
unannReferenceType(path: AstPath<import("java-parser").UnannReferenceTypeCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc;
|
||||
unannClassOrInterfaceType: typeof printSingle;
|
||||
unannClassType: typeof printClassType;
|
||||
unannInterfaceType: typeof printSingle;
|
||||
unannTypeVariable: typeof printSingle;
|
||||
methodDeclaration(path: AstPath<import("java-parser").MethodDeclarationCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
methodModifier: typeof printSingle;
|
||||
methodHeader(path: AstPath<import("java-parser").MethodHeaderCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Group;
|
||||
result: typeof printSingle;
|
||||
methodDeclarator(path: AstPath<import("java-parser").MethodDeclaratorCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
receiverParameter(path: AstPath<import("java-parser").ReceiverParameterCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
formalParameterList(path: AstPath<import("java-parser").FormalParameterListCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
formalParameter: typeof printSingle;
|
||||
variableParaRegularParameter(path: AstPath<import("java-parser").VariableParaRegularParameterCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
variableArityParameter(path: AstPath<import("java-parser").VariableArityParameterCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
variableModifier: typeof printSingle;
|
||||
throws(path: AstPath<import("java-parser").ThrowsCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
exceptionTypeList(path: AstPath<import("java-parser").ExceptionTypeListCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
exceptionType: typeof printSingle;
|
||||
methodBody: typeof printSingle;
|
||||
instanceInitializer: typeof printSingle;
|
||||
staticInitializer(path: AstPath<import("java-parser").StaticInitializerCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
constructorDeclaration(path: AstPath<import("java-parser").ConstructorDeclarationCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
constructorModifier: typeof printSingle;
|
||||
constructorDeclarator(path: AstPath<import("java-parser").ConstructorDeclaratorCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
simpleTypeName: typeof printSingle;
|
||||
constructorBody(path: AstPath<import("java-parser").ConstructorBodyCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Group | "{}" | (string | builders.Indent | builders.Hardline)[];
|
||||
explicitConstructorInvocation: typeof printSingle;
|
||||
unqualifiedExplicitConstructorInvocation(path: AstPath<import("java-parser").UnqualifiedExplicitConstructorInvocationCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
qualifiedExplicitConstructorInvocation(path: AstPath<import("java-parser").QualifiedExplicitConstructorInvocationCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
enumDeclaration(path: AstPath<import("java-parser").EnumDeclarationCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
enumBody(path: AstPath<import("java-parser").EnumBodyCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn, options: import("./helpers.js").JavaParserOptions): builders.Group | "{}" | (string | builders.Indent | builders.Hardline)[];
|
||||
enumConstantList(path: AstPath<import("java-parser").EnumConstantListCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
enumConstant(path: AstPath<import("java-parser").EnumConstantCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
enumConstantModifier: typeof printSingle;
|
||||
enumBodyDeclarations(path: AstPath<EnumBodyDeclarationsCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
recordDeclaration(path: AstPath<import("java-parser").RecordDeclarationCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
recordHeader(path: AstPath<import("java-parser").RecordHeaderCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Group | "()";
|
||||
recordComponentList(path: AstPath<import("java-parser").RecordComponentListCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
recordComponent(path: AstPath<import("java-parser").RecordComponentCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Group;
|
||||
variableArityRecordComponent(path: AstPath<import("java-parser").VariableArityRecordComponentCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
recordComponentModifier: typeof printSingle;
|
||||
recordBody(path: AstPath<import("java-parser").RecordBodyCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Group | "{}" | (string | builders.Indent | builders.Hardline)[];
|
||||
recordBodyDeclaration: typeof printSingle;
|
||||
compactConstructorDeclaration(path: AstPath<import("java-parser").CompactConstructorDeclarationCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
};
|
||||
export default _default;
|
||||
446
frontend/src/common/prettier/plugins/java/printers/classes.js
Normal file
446
frontend/src/common/prettier/plugins/java/printers/classes.js
Normal file
@@ -0,0 +1,446 @@
|
||||
import { builders } from "prettier/doc";
|
||||
import { call, each, hasDeclarationAnnotations, hasLeadingComments, indentInParentheses, isBinaryExpression, lineEndWithComments, lineStartWithComments, map, onlyDefinedKey, printBlock, printClassPermits, printClassType, printDanglingComments, printList, printSingle, printWithModifiers } from "./helpers.js";
|
||||
const { group, hardline, indent, indentIfBreak, join, line, softline } = builders;
|
||||
export default {
|
||||
classDeclaration(path, print) {
|
||||
const declarationKey = onlyDefinedKey(path.node.children, [
|
||||
"enumDeclaration",
|
||||
"normalClassDeclaration",
|
||||
"recordDeclaration"
|
||||
]);
|
||||
const declaration = call(path, print, declarationKey);
|
||||
return printWithModifiers(path, print, "classModifier", declaration, true);
|
||||
},
|
||||
normalClassDeclaration(path, print) {
|
||||
const { classExtends, classImplements, classPermits, typeParameters } = path.node.children;
|
||||
const header = ["class ", call(path, print, "typeIdentifier")];
|
||||
if (typeParameters) {
|
||||
header.push(call(path, print, "typeParameters"));
|
||||
}
|
||||
if (classExtends) {
|
||||
header.push(indent([line, call(path, print, "classExtends")]));
|
||||
}
|
||||
if (classImplements) {
|
||||
header.push(indent([line, call(path, print, "classImplements")]));
|
||||
}
|
||||
if (classPermits) {
|
||||
header.push(indent([line, call(path, print, "classPermits")]));
|
||||
}
|
||||
return [group(header), " ", call(path, print, "classBody")];
|
||||
},
|
||||
classModifier: printSingle,
|
||||
typeParameters(path, print) {
|
||||
return group([
|
||||
"<",
|
||||
indent([softline, call(path, print, "typeParameterList")]),
|
||||
softline,
|
||||
">"
|
||||
]);
|
||||
},
|
||||
typeParameterList(path, print) {
|
||||
return printList(path, print, "typeParameter");
|
||||
},
|
||||
classExtends(path, print) {
|
||||
return ["extends ", call(path, print, "classType")];
|
||||
},
|
||||
classImplements(path, print) {
|
||||
return group([
|
||||
"implements",
|
||||
indent([line, call(path, print, "interfaceTypeList")])
|
||||
]);
|
||||
},
|
||||
classPermits: printClassPermits,
|
||||
interfaceTypeList(path, print) {
|
||||
return group(printList(path, print, "interfaceType"));
|
||||
},
|
||||
classBody(path, print) {
|
||||
return printBlock(path, printClassBodyDeclarations(path, print));
|
||||
},
|
||||
classBodyDeclaration: printSingle,
|
||||
classMemberDeclaration(path, print) {
|
||||
const { children } = path.node;
|
||||
return children.Semicolon
|
||||
? ""
|
||||
: call(path, print, onlyDefinedKey(children));
|
||||
},
|
||||
fieldDeclaration(path, print) {
|
||||
const declaration = [
|
||||
call(path, print, "unannType"),
|
||||
" ",
|
||||
call(path, print, "variableDeclaratorList"),
|
||||
";"
|
||||
];
|
||||
return printWithModifiers(path, print, "fieldModifier", declaration);
|
||||
},
|
||||
fieldModifier: printSingle,
|
||||
variableDeclaratorList(path, print) {
|
||||
var _a;
|
||||
const declarators = map(path, print, "variableDeclarator");
|
||||
return declarators.length > 1 &&
|
||||
path.node.children.variableDeclarator.some(({ children }) => children.Equals)
|
||||
? group(indent(join([",", line], declarators)), {
|
||||
shouldBreak: ((_a = path.getNode(4)) === null || _a === void 0 ? void 0 : _a.name) !== "forInit"
|
||||
})
|
||||
: join(", ", declarators);
|
||||
},
|
||||
variableDeclarator(path, print) {
|
||||
var _a, _b;
|
||||
const { children } = path.node;
|
||||
const variableInitializer = (_a = children.variableInitializer) === null || _a === void 0 ? void 0 : _a[0];
|
||||
const declaratorId = call(path, print, "variableDeclaratorId");
|
||||
if (!variableInitializer) {
|
||||
return declaratorId;
|
||||
}
|
||||
const expression = (_b = variableInitializer.children.expression) === null || _b === void 0 ? void 0 : _b[0];
|
||||
const declarator = [declaratorId, " ", call(path, print, "Equals")];
|
||||
const initializer = call(path, print, "variableInitializer");
|
||||
if (hasLeadingComments(variableInitializer) ||
|
||||
(expression && isBinaryExpression(expression))) {
|
||||
declarator.push(group(indent([line, initializer])));
|
||||
}
|
||||
else {
|
||||
const groupId = Symbol("assignment");
|
||||
declarator.push(group(indent(line), { id: groupId }), indentIfBreak(initializer, { groupId }));
|
||||
}
|
||||
return group(declarator);
|
||||
},
|
||||
variableDeclaratorId(path, print) {
|
||||
const { dims, Underscore } = path.node.children;
|
||||
if (Underscore) {
|
||||
return "_";
|
||||
}
|
||||
const identifier = call(path, print, "Identifier");
|
||||
return dims ? [identifier, call(path, print, "dims")] : identifier;
|
||||
},
|
||||
variableInitializer: printSingle,
|
||||
unannType: printSingle,
|
||||
unannPrimitiveTypeWithOptionalDimsSuffix(path, print) {
|
||||
const type = call(path, print, "unannPrimitiveType");
|
||||
return path.node.children.dims ? [type, call(path, print, "dims")] : type;
|
||||
},
|
||||
unannPrimitiveType: printSingle,
|
||||
unannReferenceType(path, print) {
|
||||
const type = call(path, print, "unannClassOrInterfaceType");
|
||||
return path.node.children.dims ? [type, call(path, print, "dims")] : type;
|
||||
},
|
||||
unannClassOrInterfaceType: printSingle,
|
||||
unannClassType: printClassType,
|
||||
unannInterfaceType: printSingle,
|
||||
unannTypeVariable: printSingle,
|
||||
methodDeclaration(path, print) {
|
||||
const declaration = [
|
||||
call(path, print, "methodHeader"),
|
||||
path.node.children.methodBody[0].children.Semicolon ? "" : " ",
|
||||
call(path, print, "methodBody")
|
||||
];
|
||||
return printWithModifiers(path, print, "methodModifier", declaration);
|
||||
},
|
||||
methodModifier: printSingle,
|
||||
methodHeader(path, print) {
|
||||
const { typeParameters, annotation, throws } = path.node.children;
|
||||
const header = [];
|
||||
if (typeParameters) {
|
||||
header.push(call(path, print, "typeParameters"));
|
||||
}
|
||||
if (annotation) {
|
||||
header.push(join(line, map(path, print, "annotation")));
|
||||
}
|
||||
header.push(call(path, print, "result"), call(path, print, "methodDeclarator"));
|
||||
return throws
|
||||
? group([
|
||||
...join(" ", header),
|
||||
group(indent([line, call(path, print, "throws")]))
|
||||
])
|
||||
: group(join(" ", header));
|
||||
},
|
||||
result: printSingle,
|
||||
methodDeclarator(path, print) {
|
||||
const { dims, formalParameterList, receiverParameter } = path.node.children;
|
||||
const declarator = [call(path, print, "Identifier")];
|
||||
const parameters = [];
|
||||
if (receiverParameter) {
|
||||
parameters.push(call(path, print, "receiverParameter"));
|
||||
}
|
||||
if (formalParameterList) {
|
||||
parameters.push(call(path, print, "formalParameterList"));
|
||||
}
|
||||
const items = parameters.length
|
||||
? join([",", line], parameters)
|
||||
: printDanglingComments(path);
|
||||
declarator.push(items.length ? indentInParentheses(items) : "()");
|
||||
if (dims) {
|
||||
declarator.push(call(path, print, "dims"));
|
||||
}
|
||||
return declarator;
|
||||
},
|
||||
receiverParameter(path, print) {
|
||||
return join(" ", [
|
||||
...map(path, print, "annotation"),
|
||||
call(path, print, "unannType"),
|
||||
path.node.children.Identifier
|
||||
? [call(path, print, "Identifier"), ".this"]
|
||||
: "this"
|
||||
]);
|
||||
},
|
||||
formalParameterList(path, print) {
|
||||
return printList(path, print, "formalParameter");
|
||||
},
|
||||
formalParameter: printSingle,
|
||||
variableParaRegularParameter(path, print) {
|
||||
return join(" ", [
|
||||
...map(path, print, "variableModifier"),
|
||||
call(path, print, "unannType"),
|
||||
call(path, print, "variableDeclaratorId")
|
||||
]);
|
||||
},
|
||||
variableArityParameter(path, print) {
|
||||
const type = join(" ", [
|
||||
...map(path, print, "variableModifier"),
|
||||
call(path, print, "unannType"),
|
||||
...map(path, print, "annotation")
|
||||
]);
|
||||
return [type, "... ", call(path, print, "Identifier")];
|
||||
},
|
||||
variableModifier: printSingle,
|
||||
throws(path, print) {
|
||||
return ["throws ", call(path, print, "exceptionTypeList")];
|
||||
},
|
||||
exceptionTypeList(path, print) {
|
||||
return join(", ", map(path, print, "exceptionType"));
|
||||
},
|
||||
exceptionType: printSingle,
|
||||
methodBody: printSingle,
|
||||
instanceInitializer: printSingle,
|
||||
staticInitializer(path, print) {
|
||||
return ["static ", call(path, print, "block")];
|
||||
},
|
||||
constructorDeclaration(path, print) {
|
||||
const declaration = [call(path, print, "constructorDeclarator")];
|
||||
if (path.node.children.throws) {
|
||||
declaration.push(group(indent([line, call(path, print, "throws")])));
|
||||
}
|
||||
declaration.push(" ", call(path, print, "constructorBody"));
|
||||
return printWithModifiers(path, print, "constructorModifier", declaration, true);
|
||||
},
|
||||
constructorModifier: printSingle,
|
||||
constructorDeclarator(path, print) {
|
||||
const { children } = path.node;
|
||||
const parameters = [];
|
||||
if (children.receiverParameter) {
|
||||
parameters.push(call(path, print, "receiverParameter"));
|
||||
}
|
||||
if (children.formalParameterList) {
|
||||
parameters.push(call(path, print, "formalParameterList"));
|
||||
}
|
||||
const header = [call(path, print, "simpleTypeName")];
|
||||
header.push(parameters.length
|
||||
? indentInParentheses(join([",", line], parameters))
|
||||
: "()");
|
||||
return children.typeParameters
|
||||
? [call(path, print, "typeParameters"), " ", ...header]
|
||||
: header;
|
||||
},
|
||||
simpleTypeName: printSingle,
|
||||
constructorBody(path, print) {
|
||||
const { children } = path.node;
|
||||
const statements = [];
|
||||
if (children.explicitConstructorInvocation) {
|
||||
statements.push(call(path, print, "explicitConstructorInvocation"));
|
||||
}
|
||||
if (children.blockStatements) {
|
||||
statements.push(call(path, print, "blockStatements"));
|
||||
}
|
||||
return printBlock(path, statements);
|
||||
},
|
||||
explicitConstructorInvocation: printSingle,
|
||||
unqualifiedExplicitConstructorInvocation(path, print) {
|
||||
const { children } = path.node;
|
||||
const invocation = [];
|
||||
if (children.typeArguments) {
|
||||
invocation.push(call(path, print, "typeArguments"));
|
||||
}
|
||||
invocation.push(children.Super ? "super" : "this");
|
||||
if (children.argumentList) {
|
||||
invocation.push(group(["(", call(path, print, "argumentList"), ")"]));
|
||||
}
|
||||
else {
|
||||
invocation.push(indentInParentheses(printDanglingComments(path), { shouldBreak: true }));
|
||||
}
|
||||
invocation.push(";");
|
||||
return invocation;
|
||||
},
|
||||
qualifiedExplicitConstructorInvocation(path, print) {
|
||||
const { children } = path.node;
|
||||
const invocation = [call(path, print, "expressionName"), "."];
|
||||
if (children.typeArguments) {
|
||||
invocation.push(call(path, print, "typeArguments"));
|
||||
}
|
||||
invocation.push("super");
|
||||
if (children.argumentList) {
|
||||
invocation.push(group(["(", call(path, print, "argumentList"), ")"]));
|
||||
}
|
||||
else {
|
||||
invocation.push(indentInParentheses(printDanglingComments(path), { shouldBreak: true }));
|
||||
}
|
||||
invocation.push(";");
|
||||
return invocation;
|
||||
},
|
||||
enumDeclaration(path, print) {
|
||||
const header = ["enum", call(path, print, "typeIdentifier")];
|
||||
if (path.node.children.classImplements) {
|
||||
header.push(call(path, print, "classImplements"));
|
||||
}
|
||||
return join(" ", [...header, call(path, print, "enumBody")]);
|
||||
},
|
||||
enumBody(path, print, options) {
|
||||
var _a;
|
||||
const { children } = path.node;
|
||||
const contents = [];
|
||||
const hasNonEmptyDeclaration = ((_a = children.enumBodyDeclarations) !== null && _a !== void 0 ? _a : [])
|
||||
.flatMap(({ children }) => { var _a; return (_a = children.classBodyDeclaration) !== null && _a !== void 0 ? _a : []; })
|
||||
.some(({ children }) => { var _a; return !((_a = children.classMemberDeclaration) === null || _a === void 0 ? void 0 : _a[0].children.Semicolon); });
|
||||
if (children.enumConstantList) {
|
||||
contents.push(call(path, print, "enumConstantList"));
|
||||
if (!hasNonEmptyDeclaration && options.trailingComma !== "none") {
|
||||
contents.push(",");
|
||||
}
|
||||
}
|
||||
if (hasNonEmptyDeclaration) {
|
||||
contents.push(";", hardline, call(path, print, "enumBodyDeclarations"));
|
||||
}
|
||||
return printBlock(path, contents.length ? [contents] : []);
|
||||
},
|
||||
enumConstantList(path, print) {
|
||||
return join([",", hardline], map(path, constantPath => {
|
||||
const constant = print(constantPath);
|
||||
const { node, previous } = constantPath;
|
||||
return !previous ||
|
||||
lineStartWithComments(node) <= lineEndWithComments(previous) + 1
|
||||
? constant
|
||||
: [hardline, constant];
|
||||
}, "enumConstant"));
|
||||
},
|
||||
enumConstant(path, print) {
|
||||
const { argumentList, classBody } = path.node.children;
|
||||
const initializer = [call(path, print, "Identifier")];
|
||||
if (argumentList) {
|
||||
initializer.push(group(["(", call(path, print, "argumentList"), ")"]));
|
||||
}
|
||||
if (classBody) {
|
||||
initializer.push(" ", call(path, print, "classBody"));
|
||||
}
|
||||
return printWithModifiers(path, print, "enumConstantModifier", initializer);
|
||||
},
|
||||
enumConstantModifier: printSingle,
|
||||
enumBodyDeclarations(path, print) {
|
||||
return join(hardline, printClassBodyDeclarations(path, print));
|
||||
},
|
||||
recordDeclaration(path, print) {
|
||||
const { children } = path.node;
|
||||
const header = ["record ", call(path, print, "typeIdentifier")];
|
||||
if (children.typeParameters) {
|
||||
header.push(call(path, print, "typeParameters"));
|
||||
}
|
||||
header.push(call(path, print, "recordHeader"));
|
||||
if (children.classImplements) {
|
||||
header.push(" ", call(path, print, "classImplements"));
|
||||
}
|
||||
return [group(header), " ", call(path, print, "recordBody")];
|
||||
},
|
||||
recordHeader(path, print) {
|
||||
return path.node.children.recordComponentList
|
||||
? indentInParentheses(call(path, print, "recordComponentList"))
|
||||
: indentInParentheses(printDanglingComments(path), { shouldBreak: true });
|
||||
},
|
||||
recordComponentList(path, print) {
|
||||
return join([",", line], map(path, componentPath => {
|
||||
const { node, previous } = componentPath;
|
||||
const blankLine = previous &&
|
||||
lineStartWithComments(node) > lineEndWithComments(previous) + 1;
|
||||
const component = print(componentPath);
|
||||
return blankLine ? [softline, component] : component;
|
||||
}, "recordComponent"));
|
||||
},
|
||||
recordComponent(path, print) {
|
||||
const { children } = path.node;
|
||||
const component = [call(path, print, "unannType")];
|
||||
if (children.Identifier ||
|
||||
children.variableArityRecordComponent[0].children.annotation) {
|
||||
component.push(" ");
|
||||
}
|
||||
const suffixKey = onlyDefinedKey(children, [
|
||||
"Identifier",
|
||||
"variableArityRecordComponent"
|
||||
]);
|
||||
component.push(call(path, print, suffixKey));
|
||||
return group(join(line, [...map(path, print, "recordComponentModifier"), component]));
|
||||
},
|
||||
variableArityRecordComponent(path, print) {
|
||||
return [
|
||||
...join(" ", map(path, print, "annotation")),
|
||||
"... ",
|
||||
call(path, print, "Identifier")
|
||||
];
|
||||
},
|
||||
recordComponentModifier: printSingle,
|
||||
recordBody(path, print) {
|
||||
const declarations = [];
|
||||
let previousRequiresPadding = false;
|
||||
each(path, declarationPath => {
|
||||
var _a, _b, _c, _d;
|
||||
const declaration = print(declarationPath);
|
||||
if (declaration === "") {
|
||||
return;
|
||||
}
|
||||
const { node, previous } = declarationPath;
|
||||
const fieldDeclaration = (_c = (_b = (_a = node.children.classBodyDeclaration) === null || _a === void 0 ? void 0 : _a[0].children.classMemberDeclaration) === null || _b === void 0 ? void 0 : _b[0].children.fieldDeclaration) === null || _c === void 0 ? void 0 : _c[0].children;
|
||||
const currentRequiresPadding = !fieldDeclaration ||
|
||||
hasDeclarationAnnotations((_d = fieldDeclaration.fieldModifier) !== null && _d !== void 0 ? _d : []);
|
||||
const blankLine = declarations.length > 0 &&
|
||||
(previousRequiresPadding ||
|
||||
currentRequiresPadding ||
|
||||
lineStartWithComments(node) > lineEndWithComments(previous) + 1);
|
||||
declarations.push(blankLine ? [hardline, declaration] : declaration);
|
||||
previousRequiresPadding = currentRequiresPadding;
|
||||
}, "recordBodyDeclaration");
|
||||
return printBlock(path, declarations);
|
||||
},
|
||||
recordBodyDeclaration: printSingle,
|
||||
compactConstructorDeclaration(path, print) {
|
||||
const declaration = [
|
||||
call(path, print, "simpleTypeName"),
|
||||
" ",
|
||||
call(path, print, "constructorBody")
|
||||
];
|
||||
return printWithModifiers(path, print, "constructorModifier", declaration, true);
|
||||
}
|
||||
};
|
||||
function printClassBodyDeclarations(path, print) {
|
||||
var _a;
|
||||
if (!path.node.children.classBodyDeclaration) {
|
||||
return [];
|
||||
}
|
||||
const declarations = [];
|
||||
let previousRequiresPadding = path.node.name === "enumBodyDeclarations" ||
|
||||
((_a = path.grandparent) === null || _a === void 0 ? void 0 : _a.name) ===
|
||||
"normalClassDeclaration";
|
||||
each(path, declarationPath => {
|
||||
var _a, _b, _c;
|
||||
const declaration = print(declarationPath);
|
||||
if (declaration === "") {
|
||||
return;
|
||||
}
|
||||
const { node, previous } = declarationPath;
|
||||
const fieldDeclaration = (_b = (_a = node.children.classMemberDeclaration) === null || _a === void 0 ? void 0 : _a[0].children.fieldDeclaration) === null || _b === void 0 ? void 0 : _b[0].children;
|
||||
const currentRequiresPadding = fieldDeclaration
|
||||
? hasDeclarationAnnotations((_c = fieldDeclaration.fieldModifier) !== null && _c !== void 0 ? _c : [])
|
||||
: true;
|
||||
const blankLine = previousRequiresPadding ||
|
||||
(declarations.length > 0 &&
|
||||
(currentRequiresPadding ||
|
||||
lineStartWithComments(node) > lineEndWithComments(previous) + 1));
|
||||
declarations.push(blankLine ? [hardline, declaration] : declaration);
|
||||
previousRequiresPadding = currentRequiresPadding;
|
||||
}, "classBodyDeclaration");
|
||||
return declarations;
|
||||
}
|
||||
134
frontend/src/common/prettier/plugins/java/printers/expressions.d.ts
vendored
Normal file
134
frontend/src/common/prettier/plugins/java/printers/expressions.d.ts
vendored
Normal file
@@ -0,0 +1,134 @@
|
||||
import type { StringTemplateCstNode, TextBlockTemplateCstNode } from "java-parser";
|
||||
import type { AstPath } from "prettier";
|
||||
import { builders } from "prettier/doc";
|
||||
import type { JavaComment } from "../comments.js";
|
||||
import { printSingle, type JavaPrintFn } from "./helpers.js";
|
||||
declare const _default: {
|
||||
expression: typeof printSingle;
|
||||
lambdaExpression(path: AstPath<import("java-parser").LambdaExpressionCstNode & {
|
||||
comments?: JavaComment[];
|
||||
}>, print: JavaPrintFn, _: import("./helpers.js").JavaParserOptions, args?: unknown): builders.Doc[];
|
||||
lambdaParameters(path: AstPath<import("java-parser").LambdaParametersCstNode & {
|
||||
comments?: JavaComment[];
|
||||
}>, print: JavaPrintFn, options: import("./helpers.js").JavaParserOptions): builders.Doc;
|
||||
lambdaParametersWithBraces(path: AstPath<import("java-parser").LambdaParametersWithBracesCstNode & {
|
||||
comments?: JavaComment[];
|
||||
}>, print: JavaPrintFn, options: import("./helpers.js").JavaParserOptions): builders.Doc;
|
||||
lambdaParameterList: typeof printSingle;
|
||||
conciseLambdaParameterList(path: AstPath<import("java-parser").ConciseLambdaParameterListCstNode & {
|
||||
comments?: JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
normalLambdaParameterList(path: AstPath<import("java-parser").NormalLambdaParameterListCstNode & {
|
||||
comments?: JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
normalLambdaParameter: typeof printSingle;
|
||||
regularLambdaParameter(path: AstPath<import("java-parser").RegularLambdaParameterCstNode & {
|
||||
comments?: JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
lambdaParameterType: typeof printSingle;
|
||||
conciseLambdaParameter: typeof printSingle;
|
||||
lambdaBody: typeof printSingle;
|
||||
conditionalExpression(path: AstPath<import("java-parser").ConditionalExpressionCstNode & {
|
||||
comments?: JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc;
|
||||
binaryExpression(path: AstPath<import("java-parser").BinaryExpressionCstNode & {
|
||||
comments?: JavaComment[];
|
||||
}>, print: JavaPrintFn, options: import("./helpers.js").JavaParserOptions): builders.Doc;
|
||||
unaryExpression(path: AstPath<import("java-parser").UnaryExpressionCstNode & {
|
||||
comments?: JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
unaryExpressionNotPlusMinus(path: AstPath<import("java-parser").UnaryExpressionNotPlusMinusCstNode & {
|
||||
comments?: JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
primary(path: AstPath<import("java-parser").PrimaryCstNode & {
|
||||
comments?: JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc;
|
||||
primaryPrefix: typeof printSingle;
|
||||
primarySuffix(path: AstPath<import("java-parser").PrimarySuffixCstNode & {
|
||||
comments?: JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc;
|
||||
fqnOrRefType(path: AstPath<import("java-parser").FqnOrRefTypeCstNode & {
|
||||
comments?: JavaComment[];
|
||||
}>, print: JavaPrintFn, _: import("./helpers.js").JavaParserOptions, args: unknown): builders.Doc[];
|
||||
fqnOrRefTypePartFirst(path: AstPath<import("java-parser").FqnOrRefTypePartFirstCstNode & {
|
||||
comments?: JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
fqnOrRefTypePartRest(path: AstPath<import("java-parser").FqnOrRefTypePartRestCstNode & {
|
||||
comments?: JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
fqnOrRefTypePartCommon(path: AstPath<import("java-parser").FqnOrRefTypePartCommonCstNode & {
|
||||
comments?: JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc;
|
||||
parenthesisExpression(path: AstPath<import("java-parser").ParenthesisExpressionCstNode & {
|
||||
comments?: JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Group | "()" | (string | builders.Indent)[];
|
||||
castExpression: typeof printSingle;
|
||||
primitiveCastExpression(path: AstPath<import("java-parser").PrimitiveCastExpressionCstNode & {
|
||||
comments?: JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
referenceTypeCastExpression(path: AstPath<import("java-parser").ReferenceTypeCastExpressionCstNode & {
|
||||
comments?: JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
newExpression: typeof printSingle;
|
||||
unqualifiedClassInstanceCreationExpression(path: AstPath<import("java-parser").UnqualifiedClassInstanceCreationExpressionCstNode & {
|
||||
comments?: JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
classOrInterfaceTypeToInstantiate(path: AstPath<import("java-parser").ClassOrInterfaceTypeToInstantiateCstNode & {
|
||||
comments?: JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
typeArgumentsOrDiamond: typeof printSingle;
|
||||
diamond(): string;
|
||||
methodInvocationSuffix(path: AstPath<import("java-parser").MethodInvocationSuffixCstNode & {
|
||||
comments?: JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Group | "()";
|
||||
argumentList(path: AstPath<import("java-parser").ArgumentListCstNode & {
|
||||
comments?: JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Group | (builders.Indent | builders.Softline)[] | (builders.BreakParent | builders.Group)[];
|
||||
arrayCreationExpression(path: AstPath<import("java-parser").ArrayCreationExpressionCstNode & {
|
||||
comments?: JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
arrayCreationExpressionWithoutInitializerSuffix(path: AstPath<import("java-parser").ArrayCreationExpressionWithoutInitializerSuffixCstNode & {
|
||||
comments?: JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc;
|
||||
arrayCreationWithInitializerSuffix(path: AstPath<import("java-parser").ArrayCreationWithInitializerSuffixCstNode & {
|
||||
comments?: JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
dimExprs(path: AstPath<import("java-parser").DimExprsCstNode & {
|
||||
comments?: JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
dimExpr(path: AstPath<import("java-parser").DimExprCstNode & {
|
||||
comments?: JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
classLiteralSuffix(path: AstPath<import("java-parser").ClassLiteralSuffixCstNode & {
|
||||
comments?: JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
arrayAccessSuffix(path: AstPath<import("java-parser").ArrayAccessSuffixCstNode & {
|
||||
comments?: JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
methodReferenceSuffix(path: AstPath<import("java-parser").MethodReferenceSuffixCstNode & {
|
||||
comments?: JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
templateArgument: typeof printSingle;
|
||||
template: typeof printSingle;
|
||||
stringTemplate(path: AstPath<StringTemplateCstNode & {
|
||||
comments?: JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Indent;
|
||||
textBlockTemplate(path: AstPath<TextBlockTemplateCstNode & {
|
||||
comments?: JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Indent;
|
||||
embeddedExpression: typeof printSingle;
|
||||
pattern: typeof printSingle;
|
||||
typePattern: typeof printSingle;
|
||||
recordPattern(path: AstPath<import("java-parser").RecordPatternCstNode & {
|
||||
comments?: JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
componentPatternList(path: AstPath<import("java-parser").ComponentPatternListCstNode & {
|
||||
comments?: JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
componentPattern: typeof printSingle;
|
||||
matchAllPattern: typeof printSingle;
|
||||
guard(path: AstPath<import("java-parser").GuardCstNode & {
|
||||
comments?: JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
};
|
||||
export default _default;
|
||||
@@ -0,0 +1,598 @@
|
||||
import { builders, utils } from "prettier/doc";
|
||||
import { call, definedKeys, each, findBaseIndent, flatMap, hasLeadingComments, indentInParentheses, isBinaryExpression, isNonTerminal, isTerminal, map, onlyDefinedKey, printDanglingComments, printList, printName, printSingle } from "./helpers.js";
|
||||
const { breakParent, conditionalGroup, group, hardline, ifBreak, indent, indentIfBreak, join, line, lineSuffixBoundary, softline } = builders;
|
||||
const { removeLines, willBreak } = utils;
|
||||
export default {
|
||||
expression: printSingle,
|
||||
lambdaExpression(path, print, _, args = {}) {
|
||||
var _a;
|
||||
const hug = (_a = args.hug) !== null && _a !== void 0 ? _a : false;
|
||||
const parameters = call(path, print, "lambdaParameters");
|
||||
const expression = [hug ? removeLines(parameters) : parameters, " ->"];
|
||||
const lambdaExpression = path.node.children.lambdaBody[0].children.expression;
|
||||
const body = call(path, print, "lambdaBody");
|
||||
if (lambdaExpression) {
|
||||
const suffix = indent([line, body]);
|
||||
expression.push(group(hug ? [suffix, softline] : suffix));
|
||||
}
|
||||
else {
|
||||
expression.push(" ", body);
|
||||
}
|
||||
return expression;
|
||||
},
|
||||
lambdaParameters(path, print, options) {
|
||||
const parameters = printSingle(path, print);
|
||||
return !path.node.children.lambdaParametersWithBraces &&
|
||||
options.arrowParens === "always"
|
||||
? ["(", parameters, ")"]
|
||||
: parameters;
|
||||
},
|
||||
lambdaParametersWithBraces(path, print, options) {
|
||||
var _a;
|
||||
const { lambdaParameterList } = path.node.children;
|
||||
if (!lambdaParameterList) {
|
||||
return "()";
|
||||
}
|
||||
const { conciseLambdaParameterList, normalLambdaParameterList } = lambdaParameterList[0].children;
|
||||
const parameterCount = ((_a = conciseLambdaParameterList === null || conciseLambdaParameterList === void 0 ? void 0 : conciseLambdaParameterList[0].children.conciseLambdaParameter) !== null && _a !== void 0 ? _a : normalLambdaParameterList === null || normalLambdaParameterList === void 0 ? void 0 : normalLambdaParameterList[0].children.normalLambdaParameter).length;
|
||||
const parameters = call(path, print, "lambdaParameterList");
|
||||
if (parameterCount > 1) {
|
||||
return indentInParentheses(parameters);
|
||||
}
|
||||
return conciseLambdaParameterList && options.arrowParens === "avoid"
|
||||
? parameters
|
||||
: ["(", parameters, ")"];
|
||||
},
|
||||
lambdaParameterList: printSingle,
|
||||
conciseLambdaParameterList(path, print) {
|
||||
return printList(path, print, "conciseLambdaParameter");
|
||||
},
|
||||
normalLambdaParameterList(path, print) {
|
||||
return printList(path, print, "normalLambdaParameter");
|
||||
},
|
||||
normalLambdaParameter: printSingle,
|
||||
regularLambdaParameter(path, print) {
|
||||
return join(" ", [
|
||||
...map(path, print, "variableModifier"),
|
||||
call(path, print, "lambdaParameterType"),
|
||||
call(path, print, "variableDeclaratorId")
|
||||
]);
|
||||
},
|
||||
lambdaParameterType: printSingle,
|
||||
conciseLambdaParameter: printSingle,
|
||||
lambdaBody: printSingle,
|
||||
conditionalExpression(path, print) {
|
||||
var _a;
|
||||
const binaryExpression = call(path, print, "binaryExpression");
|
||||
if (!path.node.children.QuestionMark) {
|
||||
return binaryExpression;
|
||||
}
|
||||
const expressions = map(path, print, "expression");
|
||||
const contents = indent(join(line, [
|
||||
binaryExpression,
|
||||
["? ", expressions[0]],
|
||||
[": ", expressions[1]]
|
||||
]));
|
||||
const isNestedTernary = ((_a = path.getNode(4)) === null || _a === void 0 ? void 0 : _a.name) ===
|
||||
"conditionalExpression";
|
||||
return isNestedTernary ? contents : group(contents);
|
||||
},
|
||||
binaryExpression(path, print, options) {
|
||||
var _a, _b;
|
||||
const { children } = path.node;
|
||||
const operands = flatMap(path, print, definedKeys(children, [
|
||||
"expression",
|
||||
"pattern",
|
||||
"referenceType",
|
||||
"unaryExpression"
|
||||
]));
|
||||
const operators = flatMap(path, operatorPath => {
|
||||
const { node } = operatorPath;
|
||||
let image;
|
||||
if (isTerminal(node)) {
|
||||
image = node.image;
|
||||
}
|
||||
else if (node.children.Less) {
|
||||
image = "<<";
|
||||
}
|
||||
else {
|
||||
image = node.children.Greater.length === 2 ? ">>" : ">>>";
|
||||
}
|
||||
return { image, doc: print(operatorPath) };
|
||||
}, definedKeys(children, [
|
||||
"AssignmentOperator",
|
||||
"BinaryOperator",
|
||||
"Instanceof",
|
||||
"shiftOperator"
|
||||
]));
|
||||
const hasNonAssignmentOperators = (operators.length > 0 && !children.AssignmentOperator) ||
|
||||
(children.expression !== undefined &&
|
||||
isBinaryExpression(children.expression[0]));
|
||||
const isInList = ((_a = path.getNode(4)) === null || _a === void 0 ? void 0 : _a.name) === "elementValue" ||
|
||||
((_b = path.getNode(6)) === null || _b === void 0 ? void 0 : _b.name) === "argumentList";
|
||||
return binary(operands, operators, {
|
||||
hasNonAssignmentOperators,
|
||||
isInList,
|
||||
isRoot: true,
|
||||
operatorPosition: options.experimentalOperatorPosition
|
||||
});
|
||||
},
|
||||
unaryExpression(path, print) {
|
||||
return [
|
||||
...map(path, print, "UnaryPrefixOperator"),
|
||||
call(path, print, "primary"),
|
||||
...map(path, print, "UnarySuffixOperator")
|
||||
];
|
||||
},
|
||||
unaryExpressionNotPlusMinus(path, print) {
|
||||
const { children } = path.node;
|
||||
const expression = [];
|
||||
if (children.UnaryPrefixOperatorNotPlusMinus) {
|
||||
expression.push(...map(path, print, "UnaryPrefixOperatorNotPlusMinus"));
|
||||
}
|
||||
expression.push(call(path, print, "primary"));
|
||||
if (children.UnarySuffixOperator) {
|
||||
expression.push(...map(path, print, "UnarySuffixOperator"));
|
||||
}
|
||||
return join(" ", expression);
|
||||
},
|
||||
primary(path, print) {
|
||||
var _a, _b;
|
||||
const { children } = path.node;
|
||||
if (!children.primarySuffix) {
|
||||
return call(path, print, "primaryPrefix");
|
||||
}
|
||||
const methodInvocations = children.primarySuffix
|
||||
.filter(({ children }) => children.methodInvocationSuffix)
|
||||
.map(({ children }) => children.methodInvocationSuffix[0].children);
|
||||
const hasLambdaMethodParameter = methodInvocations.some(({ argumentList }) => argumentList === null || argumentList === void 0 ? void 0 : argumentList[0].children.expression.some(({ children }) => children.lambdaExpression));
|
||||
const prefixIsCallExpression = children.primaryPrefix[0].children.newExpression;
|
||||
const callExpressionCount = methodInvocations.length +
|
||||
(prefixIsCallExpression ? 1 : 0) +
|
||||
children.primarySuffix.filter(({ children }) => children.unqualifiedClassInstanceCreationExpression).length;
|
||||
const fqnOrRefType = (_a = children.primaryPrefix[0].children.fqnOrRefType) === null || _a === void 0 ? void 0 : _a[0].children;
|
||||
const prefixIsMethodInvocation = (fqnOrRefType === null || fqnOrRefType === void 0 ? void 0 : fqnOrRefType.fqnOrRefTypePartRest) !== undefined &&
|
||||
((_b = children.primarySuffix) === null || _b === void 0 ? void 0 : _b[0].children.methodInvocationSuffix) !== undefined;
|
||||
const prefixIsStaticMethodInvocation = prefixIsMethodInvocation && isCapitalizedIdentifier(fqnOrRefType);
|
||||
const prefixIsInstanceMethodInvocation = prefixIsMethodInvocation && !prefixIsStaticMethodInvocation;
|
||||
const mustBreakForCallExpressions = methodInvocations.length > 2 && hasLambdaMethodParameter;
|
||||
const separator = mustBreakForCallExpressions ? hardline : softline;
|
||||
const prefix = [
|
||||
call(path, prefixPath => print(prefixPath, {
|
||||
lastSeparator: prefixIsStaticMethodInvocation ||
|
||||
(prefixIsInstanceMethodInvocation && callExpressionCount === 1)
|
||||
? ""
|
||||
: separator
|
||||
}), "primaryPrefix")
|
||||
];
|
||||
const canBreakForCallExpressions = callExpressionCount > 2 ||
|
||||
(callExpressionCount === 2 && prefixIsInstanceMethodInvocation) ||
|
||||
willBreak(prefix);
|
||||
const suffixes = [];
|
||||
each(path, suffixPath => {
|
||||
const { node, previous } = suffixPath;
|
||||
const suffix = print(suffixPath);
|
||||
if (node.children.Dot) {
|
||||
if ((canBreakForCallExpressions &&
|
||||
((!previous && prefixIsCallExpression) ||
|
||||
(previous === null || previous === void 0 ? void 0 : previous.children.methodInvocationSuffix) ||
|
||||
(previous === null || previous === void 0 ? void 0 : previous.children.unqualifiedClassInstanceCreationExpression))) ||
|
||||
(!node.children.templateArgument && willBreak(suffix))) {
|
||||
suffixes.push(separator);
|
||||
}
|
||||
suffixes.push(suffix);
|
||||
}
|
||||
else if (previous) {
|
||||
suffixes.push(suffix);
|
||||
}
|
||||
else {
|
||||
prefix.push(prefixIsInstanceMethodInvocation && callExpressionCount >= 2
|
||||
? indent(suffix)
|
||||
: suffix);
|
||||
}
|
||||
}, "primarySuffix");
|
||||
const hasSuffixComments = children.primarySuffix.some(suffix => hasLeadingComments(suffix));
|
||||
return group(canBreakForCallExpressions || hasSuffixComments
|
||||
? [prefix, indent(suffixes)]
|
||||
: [prefix, ...suffixes]);
|
||||
},
|
||||
primaryPrefix: printSingle,
|
||||
primarySuffix(path, print) {
|
||||
const { children } = path.node;
|
||||
if (!children.Dot) {
|
||||
return printSingle(path, print);
|
||||
}
|
||||
const suffix = ["."];
|
||||
if (children.This) {
|
||||
suffix.push("this");
|
||||
}
|
||||
else if (children.Identifier) {
|
||||
if (children.typeArguments) {
|
||||
suffix.push(call(path, print, "typeArguments"));
|
||||
}
|
||||
suffix.push(call(path, print, "Identifier"));
|
||||
}
|
||||
else {
|
||||
const suffixKey = onlyDefinedKey(children, [
|
||||
"templateArgument",
|
||||
"unqualifiedClassInstanceCreationExpression"
|
||||
]);
|
||||
suffix.push(call(path, print, suffixKey));
|
||||
}
|
||||
return suffix;
|
||||
},
|
||||
fqnOrRefType(path, print, _, args) {
|
||||
var _a;
|
||||
const lastSeparator = (_a = args.lastSeparator) !== null && _a !== void 0 ? _a : "";
|
||||
const fqnOrRefType = [
|
||||
call(path, print, "fqnOrRefTypePartFirst"),
|
||||
...map(path, partPath => {
|
||||
const part = print(partPath);
|
||||
return partPath.isLast
|
||||
? [willBreak(part) ? hardline : lastSeparator, part]
|
||||
: part;
|
||||
}, "fqnOrRefTypePartRest")
|
||||
];
|
||||
fqnOrRefType.push(indent(fqnOrRefType.pop()));
|
||||
return path.node.children.dims
|
||||
? [fqnOrRefType, call(path, print, "dims")]
|
||||
: fqnOrRefType;
|
||||
},
|
||||
fqnOrRefTypePartFirst(path, print) {
|
||||
return join(" ", [
|
||||
...map(path, print, "annotation"),
|
||||
call(path, print, "fqnOrRefTypePartCommon")
|
||||
]);
|
||||
},
|
||||
fqnOrRefTypePartRest(path, print) {
|
||||
const common = call(path, print, "fqnOrRefTypePartCommon");
|
||||
const type = path.node.children.typeArguments
|
||||
? [call(path, print, "typeArguments"), common]
|
||||
: common;
|
||||
return [".", ...join(" ", [...map(path, print, "annotation"), type])];
|
||||
},
|
||||
fqnOrRefTypePartCommon(path, print) {
|
||||
const { children } = path.node;
|
||||
const keywordKey = onlyDefinedKey(children, ["Identifier", "Super"]);
|
||||
const keyword = call(path, print, keywordKey);
|
||||
return children.typeArguments
|
||||
? [keyword, call(path, print, "typeArguments")]
|
||||
: keyword;
|
||||
},
|
||||
parenthesisExpression(path, print) {
|
||||
var _a;
|
||||
const expression = call(path, print, "expression");
|
||||
const ancestorName = (_a = path.getNode(14)) === null || _a === void 0 ? void 0 : _a.name;
|
||||
const binaryExpression = path.getNode(8);
|
||||
return ancestorName &&
|
||||
["guard", "returnStatement"].includes(ancestorName) &&
|
||||
binaryExpression &&
|
||||
binaryExpression.name === "binaryExpression" &&
|
||||
Object.keys(binaryExpression.children).length === 1
|
||||
? indentInParentheses(expression)
|
||||
: ["(", indent(expression), ")"];
|
||||
},
|
||||
castExpression: printSingle,
|
||||
primitiveCastExpression(path, print) {
|
||||
return [
|
||||
"(",
|
||||
call(path, print, "primitiveType"),
|
||||
") ",
|
||||
call(path, print, "unaryExpression")
|
||||
];
|
||||
},
|
||||
referenceTypeCastExpression(path, print) {
|
||||
const { children } = path.node;
|
||||
const type = call(path, print, "referenceType");
|
||||
const cast = children.additionalBound
|
||||
? indentInParentheses(join(line, [type, ...map(path, print, "additionalBound")]))
|
||||
: ["(", type, ")"];
|
||||
const expressionKey = onlyDefinedKey(children, [
|
||||
"lambdaExpression",
|
||||
"unaryExpressionNotPlusMinus"
|
||||
]);
|
||||
return [cast, " ", call(path, print, expressionKey)];
|
||||
},
|
||||
newExpression: printSingle,
|
||||
unqualifiedClassInstanceCreationExpression(path, print) {
|
||||
const { children } = path.node;
|
||||
const expression = ["new "];
|
||||
if (children.typeArguments) {
|
||||
expression.push(call(path, print, "typeArguments"));
|
||||
}
|
||||
expression.push(call(path, print, "classOrInterfaceTypeToInstantiate"), children.argumentList
|
||||
? group(["(", call(path, print, "argumentList"), ")"])
|
||||
: "()");
|
||||
if (children.classBody) {
|
||||
expression.push(" ", call(path, print, "classBody"));
|
||||
}
|
||||
return expression;
|
||||
},
|
||||
classOrInterfaceTypeToInstantiate(path, print) {
|
||||
const { children } = path.node;
|
||||
const type = children.annotation
|
||||
? flatMap(path, childPath => [
|
||||
print(childPath),
|
||||
isNonTerminal(childPath.node) ? " " : "."
|
||||
], ["annotation", "Identifier"])
|
||||
: printName(path, print);
|
||||
if (children.typeArgumentsOrDiamond) {
|
||||
type.push(call(path, print, "typeArgumentsOrDiamond"));
|
||||
}
|
||||
return type;
|
||||
},
|
||||
typeArgumentsOrDiamond: printSingle,
|
||||
diamond() {
|
||||
return "<>";
|
||||
},
|
||||
methodInvocationSuffix(path, print) {
|
||||
return path.node.children.argumentList
|
||||
? group(["(", call(path, print, "argumentList"), ")"])
|
||||
: indentInParentheses(printDanglingComments(path), { shouldBreak: true });
|
||||
},
|
||||
argumentList(path, print) {
|
||||
var _a, _b, _c, _d;
|
||||
const expressions = path.node.children.expression;
|
||||
const lastExpression = expressions.at(-1);
|
||||
const lastExpressionLambdaBodyExpression = (_b = (_a = lastExpression.children.lambdaExpression) === null || _a === void 0 ? void 0 : _a[0].children.lambdaBody[0].children.expression) === null || _b === void 0 ? void 0 : _b[0].children;
|
||||
const lastExpressionLambdaBodyTernaryExpression = (_c = lastExpressionLambdaBodyExpression === null || lastExpressionLambdaBodyExpression === void 0 ? void 0 : lastExpressionLambdaBodyExpression.conditionalExpression) === null || _c === void 0 ? void 0 : _c[0].children;
|
||||
const isHuggable = !lastExpression.comments &&
|
||||
(!lastExpressionLambdaBodyExpression ||
|
||||
(lastExpressionLambdaBodyTernaryExpression === null || lastExpressionLambdaBodyTernaryExpression === void 0 ? void 0 : lastExpressionLambdaBodyTernaryExpression.QuestionMark) !== undefined ||
|
||||
((_d = lastExpressionLambdaBodyTernaryExpression === null || lastExpressionLambdaBodyTernaryExpression === void 0 ? void 0 : lastExpressionLambdaBodyTernaryExpression.binaryExpression) === null || _d === void 0 ? void 0 : _d[0].children.unaryExpression.length) === 1) &&
|
||||
expressions.findIndex(({ children }) => children.lambdaExpression) ===
|
||||
expressions.length - 1;
|
||||
const args = map(path, print, "expression");
|
||||
const allArgsExpandable = [
|
||||
indent([softline, ...join([",", line], args)]),
|
||||
softline
|
||||
];
|
||||
if (!isHuggable || willBreak(args.at(-1)[0])) {
|
||||
return allArgsExpandable;
|
||||
}
|
||||
const headArgs = args.slice(0, -1);
|
||||
const huggedLastArg = path.call(argPath => print(argPath, { hug: true }), "children", "expression", args.length - 1);
|
||||
const lastArgExpanded = join(", ", [
|
||||
...headArgs,
|
||||
group(huggedLastArg, { shouldBreak: true })
|
||||
]);
|
||||
if (willBreak(huggedLastArg)) {
|
||||
return [
|
||||
breakParent,
|
||||
conditionalGroup([lastArgExpanded, allArgsExpandable])
|
||||
];
|
||||
}
|
||||
return conditionalGroup([
|
||||
join(", ", [...headArgs, huggedLastArg]),
|
||||
lastArgExpanded,
|
||||
allArgsExpandable
|
||||
]);
|
||||
},
|
||||
arrayCreationExpression(path, print) {
|
||||
const { children } = path.node;
|
||||
const typeKey = onlyDefinedKey(children, [
|
||||
"classOrInterfaceType",
|
||||
"primitiveType"
|
||||
]);
|
||||
const suffixKey = onlyDefinedKey(children, [
|
||||
"arrayCreationExpressionWithoutInitializerSuffix",
|
||||
"arrayCreationWithInitializerSuffix"
|
||||
]);
|
||||
return ["new ", call(path, print, typeKey), call(path, print, suffixKey)];
|
||||
},
|
||||
arrayCreationExpressionWithoutInitializerSuffix(path, print) {
|
||||
const expressions = call(path, print, "dimExprs");
|
||||
return path.node.children.dims
|
||||
? [expressions, call(path, print, "dims")]
|
||||
: expressions;
|
||||
},
|
||||
arrayCreationWithInitializerSuffix(path, print) {
|
||||
return [
|
||||
call(path, print, "dims"),
|
||||
" ",
|
||||
call(path, print, "arrayInitializer")
|
||||
];
|
||||
},
|
||||
dimExprs(path, print) {
|
||||
return map(path, print, "dimExpr");
|
||||
},
|
||||
dimExpr(path, print) {
|
||||
return join(" ", [
|
||||
...map(path, print, "annotation"),
|
||||
["[", call(path, print, "expression"), "]"]
|
||||
]);
|
||||
},
|
||||
classLiteralSuffix(path, print) {
|
||||
const lSquares = map(path, print, "LSquare");
|
||||
const rSquares = map(path, print, "RSquare");
|
||||
return [
|
||||
...lSquares.flatMap((lSquare, index) => [lSquare, rSquares[index]]),
|
||||
".class"
|
||||
];
|
||||
},
|
||||
arrayAccessSuffix(path, print) {
|
||||
return ["[", call(path, print, "expression"), "]"];
|
||||
},
|
||||
methodReferenceSuffix(path, print) {
|
||||
const { children } = path.node;
|
||||
const reference = ["::"];
|
||||
if (children.typeArguments) {
|
||||
reference.push(call(path, print, "typeArguments"));
|
||||
}
|
||||
reference.push(call(path, print, onlyDefinedKey(children, ["Identifier", "New"])));
|
||||
return reference;
|
||||
},
|
||||
templateArgument: printSingle,
|
||||
template: printSingle,
|
||||
stringTemplate(path, print) {
|
||||
return printTemplate(path, print, "StringTemplateBegin", "StringTemplateMid", "StringTemplateEnd");
|
||||
},
|
||||
textBlockTemplate(path, print) {
|
||||
return printTemplate(path, print, "TextBlockTemplateBegin", "TextBlockTemplateMid", "TextBlockTemplateEnd");
|
||||
},
|
||||
embeddedExpression: printSingle,
|
||||
pattern: printSingle,
|
||||
typePattern: printSingle,
|
||||
recordPattern(path, print) {
|
||||
const patterns = path.node.children.componentPatternList
|
||||
? indentInParentheses(call(path, print, "componentPatternList"))
|
||||
: "()";
|
||||
return [call(path, print, "referenceType"), patterns];
|
||||
},
|
||||
componentPatternList(path, print) {
|
||||
return printList(path, print, "componentPattern");
|
||||
},
|
||||
componentPattern: printSingle,
|
||||
matchAllPattern: printSingle,
|
||||
guard(path, print) {
|
||||
var _a;
|
||||
const expression = call(path, print, "expression");
|
||||
const hasParentheses = ((_a = path.node.children.expression[0].children.conditionalExpression) === null || _a === void 0 ? void 0 : _a[0].children.binaryExpression[0].children.unaryExpression[0].children.primary[0].children.primaryPrefix[0].children.parenthesisExpression) !==
|
||||
undefined;
|
||||
return [
|
||||
"when ",
|
||||
hasParentheses
|
||||
? expression
|
||||
: group([
|
||||
ifBreak("("),
|
||||
indent([softline, expression]),
|
||||
softline,
|
||||
ifBreak(")")
|
||||
])
|
||||
];
|
||||
}
|
||||
};
|
||||
function binary(operands, operators, { hasNonAssignmentOperators = false, isInList = false, isRoot = false, operatorPosition }) {
|
||||
let levelOperator;
|
||||
let levelPrecedence;
|
||||
let level = [];
|
||||
while (operators.length) {
|
||||
const nextOperator = operators[0].image;
|
||||
const nextPrecedence = getOperatorPrecedence(nextOperator);
|
||||
if (levelPrecedence === undefined || nextPrecedence === levelPrecedence) {
|
||||
const { image: operator, doc: operatorDoc } = operators.shift();
|
||||
level.push(operands.shift());
|
||||
if (levelOperator !== undefined &&
|
||||
needsParentheses(levelOperator, operator)) {
|
||||
level = [["(", group(indent(level)), ")"]];
|
||||
}
|
||||
const parts = [" ", operatorDoc, line];
|
||||
if (operatorPosition === "start" && !isAssignmentOperator(operator)) {
|
||||
parts.reverse();
|
||||
}
|
||||
level.push(parts);
|
||||
levelOperator = operator;
|
||||
levelPrecedence = nextPrecedence;
|
||||
}
|
||||
else if (nextPrecedence < levelPrecedence) {
|
||||
if (!isRoot) {
|
||||
break;
|
||||
}
|
||||
level.push(operands.shift());
|
||||
const content = group(indent(level));
|
||||
operands.unshift(levelOperator !== undefined &&
|
||||
needsParentheses(levelOperator, nextOperator)
|
||||
? ["(", content, ")"]
|
||||
: content);
|
||||
level = [];
|
||||
levelOperator = undefined;
|
||||
levelPrecedence = undefined;
|
||||
}
|
||||
else {
|
||||
const content = binary(operands, operators, { operatorPosition });
|
||||
operands.unshift(levelOperator !== undefined &&
|
||||
needsParentheses(nextOperator, levelOperator)
|
||||
? ["(", indent(content), ")"]
|
||||
: content);
|
||||
}
|
||||
}
|
||||
level.push(operands.shift());
|
||||
if (!levelOperator ||
|
||||
(!isInList &&
|
||||
!isAssignmentOperator(levelOperator) &&
|
||||
levelOperator !== "instanceof")) {
|
||||
return group(level);
|
||||
}
|
||||
if (!isRoot || hasNonAssignmentOperators) {
|
||||
return group(indent(level));
|
||||
}
|
||||
const groupId = Symbol("assignment");
|
||||
return group([
|
||||
level[0],
|
||||
group(indent(level[1]), { id: groupId }),
|
||||
indentIfBreak(level[2], { groupId })
|
||||
]);
|
||||
}
|
||||
const precedencesByOperator = new Map([
|
||||
["||"],
|
||||
["&&"],
|
||||
["|"],
|
||||
["^"],
|
||||
["&"],
|
||||
["==", "!="],
|
||||
["<", ">", "<=", ">=", "instanceof"],
|
||||
["<<", ">>", ">>>"],
|
||||
["+", "-"],
|
||||
["*", "/", "%"]
|
||||
].flatMap((operators, index) => operators.map(operator => [operator, index])));
|
||||
function getOperatorPrecedence(operator) {
|
||||
var _a;
|
||||
return (_a = precedencesByOperator.get(operator)) !== null && _a !== void 0 ? _a : -1;
|
||||
}
|
||||
function needsParentheses(operator, parentOperator) {
|
||||
return ((operator === "&&" && parentOperator === "||") ||
|
||||
(["|", "^", "&", "<<", ">>", ">>>"].includes(parentOperator) &&
|
||||
getOperatorPrecedence(operator) >
|
||||
getOperatorPrecedence(parentOperator)) ||
|
||||
[operator, parentOperator].every(o => ["==", "!="].includes(o)) ||
|
||||
[operator, parentOperator].every(o => ["<<", ">>", ">>>"].includes(o)) ||
|
||||
(operator === "*" && parentOperator === "/") ||
|
||||
(operator === "/" && parentOperator === "*") ||
|
||||
(operator === "%" && ["+", "-", "*", "/"].includes(parentOperator)) ||
|
||||
(["*", "/"].includes(operator) && parentOperator === "%"));
|
||||
}
|
||||
const assignmentOperators = new Set([
|
||||
"=",
|
||||
"*=",
|
||||
"/=",
|
||||
"%=",
|
||||
"+=",
|
||||
"-=",
|
||||
"<<=",
|
||||
">>=",
|
||||
">>>=",
|
||||
"&=",
|
||||
"^=",
|
||||
"|="
|
||||
]);
|
||||
function isAssignmentOperator(operator) {
|
||||
return assignmentOperators.has(operator);
|
||||
}
|
||||
function isCapitalizedIdentifier(fqnOrRefType) {
|
||||
var _a, _b, _c;
|
||||
const nextToLastIdentifier = (_c = (_b = [
|
||||
fqnOrRefType.fqnOrRefTypePartFirst[0],
|
||||
...((_a = fqnOrRefType.fqnOrRefTypePartRest) !== null && _a !== void 0 ? _a : [])
|
||||
].at(-2)) === null || _b === void 0 ? void 0 : _b.children.fqnOrRefTypePartCommon[0].children.Identifier) === null || _c === void 0 ? void 0 : _c[0].image;
|
||||
return /^\p{Uppercase_Letter}/u.test(nextToLastIdentifier !== null && nextToLastIdentifier !== void 0 ? nextToLastIdentifier : "");
|
||||
}
|
||||
function printTemplate(path, print, beginKey, midKey, endKey) {
|
||||
const begin = call(path, ({ node }) => node.image, beginKey);
|
||||
const mids = map(path, ({ node }) => node.image, midKey);
|
||||
const end = call(path, ({ node }) => node.image, endKey);
|
||||
const lines = [begin, ...mids, end].join("").split("\n").slice(1);
|
||||
const baseIndent = findBaseIndent(lines);
|
||||
const prefix = "\n" + " ".repeat(baseIndent);
|
||||
const parts = [begin, ...mids, end].map(image => join(hardline, image.split(prefix)));
|
||||
return indent([
|
||||
parts[0],
|
||||
...map(path, (expressionPath, index) => {
|
||||
const expression = group([
|
||||
indent([softline, print(expressionPath), lineSuffixBoundary]),
|
||||
softline
|
||||
]);
|
||||
return index === 0 ? expression : [parts[index], expression];
|
||||
}, "embeddedExpression"),
|
||||
parts.at(-1)
|
||||
]);
|
||||
}
|
||||
71
frontend/src/common/prettier/plugins/java/printers/helpers.d.ts
vendored
Normal file
71
frontend/src/common/prettier/plugins/java/printers/helpers.d.ts
vendored
Normal file
@@ -0,0 +1,71 @@
|
||||
import type { AnnotationCstNode, ClassPermitsCstNode, ClassTypeCtx, CstElement, CstNode, ExpressionCstNode, InterfacePermitsCstNode, IToken, StatementCstNode } from "java-parser";
|
||||
import type { AstPath, Doc, ParserOptions } from "prettier";
|
||||
import { builders } from "prettier/doc";
|
||||
import type { JavaComment } from "../comments.js";
|
||||
export declare function onlyDefinedKey<T extends Record<string, any>, K extends Key<T> & string>(obj: T, options?: K[]): K;
|
||||
export declare function definedKeys<T extends Record<string, any>, K extends Key<T> & string>(obj: T, options?: K[]): K[];
|
||||
export declare function printWithModifiers<T extends CstNode, P extends IterProperties<T["children"]>>(path: AstPath<T>, print: JavaPrintFn, modifierChild: P, contents: Doc, noTypeAnnotations?: boolean): builders.Doc[];
|
||||
export declare function hasDeclarationAnnotations(modifiers: ModifierNode[]): boolean;
|
||||
export declare function call<T extends CstNode, U, P extends IterProperties<T["children"]>>(path: AstPath<T>, callback: MapCallback<IndexValue<IndexValue<T, "children">, P>, U>, child: P): U;
|
||||
export declare function each<T extends CstNode, P extends IterProperties<T["children"]>>(path: AstPath<T>, callback: MapCallback<IndexValue<IndexValue<T, "children">, P>, void>, child: P): void;
|
||||
export declare function map<T extends CstNode, U, P extends IterProperties<T["children"]>>(path: AstPath<T>, callback: MapCallback<IndexValue<IndexValue<T, "children">, P>, U>, child: P): U[];
|
||||
export declare function flatMap<T extends CstNode, U, P extends IterProperties<T["children"]>>(path: AstPath<T>, callback: MapCallback<IndexValue<IndexValue<T, "children">, P>, U>, children: P[]): U[];
|
||||
export declare function printSingle(path: AstPath<JavaNonTerminal>, print: JavaPrintFn, _?: JavaParserOptions, args?: unknown): builders.Doc;
|
||||
export declare function lineStartWithComments(node: JavaNonTerminal): number;
|
||||
export declare function lineEndWithComments(node: JavaNonTerminal): number;
|
||||
export declare function printDanglingComments(path: AstPath<JavaNonTerminal>): builders.Doc[];
|
||||
export declare function printComment(node: JavaTerminal): string | builders.Doc[];
|
||||
export declare function hasLeadingComments(node: JavaNode): boolean | undefined;
|
||||
export declare function indentInParentheses(contents: Doc, opts?: {
|
||||
shouldBreak?: boolean;
|
||||
}): builders.Group | "()";
|
||||
export declare function printArrayInitializer<T extends JavaNonTerminal, P extends IterProperties<T["children"]>>(path: AstPath<T>, print: JavaPrintFn, options: JavaParserOptions, child: P): builders.Group | "{}";
|
||||
export declare function printBlock(path: AstPath<JavaNonTerminal>, contents: Doc[]): builders.Group | "{}" | (string | builders.Indent | builders.Hardline)[];
|
||||
export declare function printName(path: AstPath<JavaNonTerminal & {
|
||||
children: {
|
||||
Identifier: IToken[];
|
||||
};
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
export declare function printList<T extends JavaNonTerminal, P extends IterProperties<T["children"]>>(path: AstPath<T>, print: JavaPrintFn, child: P): builders.Doc[];
|
||||
export declare function printClassPermits(path: AstPath<ClassPermitsCstNode | InterfacePermitsCstNode>, print: JavaPrintFn): builders.Group;
|
||||
export declare function printClassType(path: AstPath<JavaNonTerminal & {
|
||||
children: ClassTypeCtx;
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
export declare function isBinaryExpression(expression: ExpressionCstNode): boolean;
|
||||
export declare function findBaseIndent(lines: string[]): number;
|
||||
export declare function isEmptyStatement(statement: StatementCstNode): boolean;
|
||||
export declare function isNonTerminal(node: CstElement): node is JavaNonTerminal;
|
||||
export declare function isTerminal(node: CstElement): node is IToken;
|
||||
export type JavaNode = CstElement & {
|
||||
comments?: JavaComment[];
|
||||
};
|
||||
export type JavaNonTerminal = Exclude<JavaNode, IToken>;
|
||||
export type JavaTerminal = Exclude<JavaNode, CstNode>;
|
||||
export type JavaNodePrinters = {
|
||||
[T in JavaNonTerminal["name"]]: JavaNodePrinter<T>;
|
||||
};
|
||||
export type JavaNodePrinter<T> = (path: AstPath<Extract<JavaNonTerminal, {
|
||||
name: T;
|
||||
}>>, print: JavaPrintFn, options: JavaParserOptions, args?: unknown) => Doc;
|
||||
export type JavaPrintFn = (path: AstPath<JavaNode>, args?: unknown) => Doc;
|
||||
export type JavaParserOptions = ParserOptions<JavaNode> & {
|
||||
entrypoint?: string;
|
||||
};
|
||||
export type IterProperties<T> = T extends any[] ? IndexProperties<T> : ArrayProperties<T>;
|
||||
type Key<T> = T extends T ? keyof T : never;
|
||||
type ModifierNode = JavaNonTerminal & {
|
||||
children: {
|
||||
annotation?: AnnotationCstNode[];
|
||||
};
|
||||
};
|
||||
type IsTuple<T> = T extends [] ? true : T extends [infer First, ...infer Remain] ? IsTuple<Remain> : false;
|
||||
type IndexProperties<T extends {
|
||||
length: number;
|
||||
}> = IsTuple<T> extends true ? Exclude<Partial<T>["length"], T["length"]> : number;
|
||||
type ArrayProperties<T> = {
|
||||
[K in keyof T]: NonNullable<T[K]> extends readonly any[] ? K : never;
|
||||
}[keyof T];
|
||||
type ArrayElement<T> = T extends Array<infer E> ? E : never;
|
||||
type MapCallback<T, U> = (path: AstPath<ArrayElement<T>>, index: number, value: any) => U;
|
||||
type IndexValue<T, P> = T extends any[] ? P extends number ? T[P] : never : P extends keyof T ? T[P] : never;
|
||||
export {};
|
||||
239
frontend/src/common/prettier/plugins/java/printers/helpers.js
Normal file
239
frontend/src/common/prettier/plugins/java/printers/helpers.js
Normal file
@@ -0,0 +1,239 @@
|
||||
import { builders } from "prettier/doc";
|
||||
import parser from "../parser.js";
|
||||
const { group, hardline, ifBreak, indent, join, line, softline } = builders;
|
||||
export function onlyDefinedKey(obj, options) {
|
||||
const keys = definedKeys(obj, options);
|
||||
if (keys.length === 1) {
|
||||
return keys[0];
|
||||
}
|
||||
throw new Error(keys.length > 1
|
||||
? `More than one defined key found: ${keys}`
|
||||
: "No defined keys found");
|
||||
}
|
||||
export function definedKeys(obj, options) {
|
||||
return (options !== null && options !== void 0 ? options : Object.keys(obj)).filter(key => obj[key] !== undefined);
|
||||
}
|
||||
const indexByModifier = [
|
||||
"public",
|
||||
"protected",
|
||||
"private",
|
||||
"abstract",
|
||||
"default",
|
||||
"static",
|
||||
"final",
|
||||
"transient",
|
||||
"volatile",
|
||||
"synchronized",
|
||||
"native",
|
||||
"sealed",
|
||||
"non-sealed",
|
||||
"strictfp"
|
||||
].reduce((map, name, index) => map.set(name, index), new Map());
|
||||
export function printWithModifiers(path, print, modifierChild, contents, noTypeAnnotations = false) {
|
||||
const declarationAnnotations = [];
|
||||
const otherModifiers = [];
|
||||
const typeAnnotations = [];
|
||||
each(path, modifierPath => {
|
||||
const { children } = modifierPath.node;
|
||||
const modifier = print(modifierPath);
|
||||
if (children.annotation) {
|
||||
(otherModifiers.length ? typeAnnotations : declarationAnnotations).push(modifier);
|
||||
}
|
||||
else {
|
||||
otherModifiers.push(modifier);
|
||||
declarationAnnotations.push(...typeAnnotations);
|
||||
typeAnnotations.length = 0;
|
||||
}
|
||||
}, modifierChild);
|
||||
if (noTypeAnnotations) {
|
||||
declarationAnnotations.push(...typeAnnotations);
|
||||
typeAnnotations.length = 0;
|
||||
}
|
||||
otherModifiers.sort((a, b) => indexByModifier.get(a) - indexByModifier.get(b));
|
||||
return join(hardline, [
|
||||
...declarationAnnotations,
|
||||
join(" ", [...otherModifiers, ...typeAnnotations, contents])
|
||||
]);
|
||||
}
|
||||
export function hasDeclarationAnnotations(modifiers) {
|
||||
let hasAnnotation = false;
|
||||
let hasNonAnnotation = false;
|
||||
for (const modifier of modifiers) {
|
||||
if (modifier.children.annotation) {
|
||||
hasAnnotation = true;
|
||||
}
|
||||
else if (hasAnnotation) {
|
||||
return true;
|
||||
}
|
||||
else {
|
||||
hasNonAnnotation = true;
|
||||
}
|
||||
}
|
||||
return hasAnnotation && !hasNonAnnotation;
|
||||
}
|
||||
export function call(path, callback, child) {
|
||||
return path.map(callback, "children", child)[0];
|
||||
}
|
||||
export function each(path, callback, child) {
|
||||
if (path.node.children[child]) {
|
||||
path.each(callback, "children", child);
|
||||
}
|
||||
}
|
||||
export function map(path, callback, child) {
|
||||
return path.node.children[child] ? path.map(callback, "children", child) : [];
|
||||
}
|
||||
export function flatMap(path, callback, children) {
|
||||
return children
|
||||
.flatMap(child => map(path, callback, child).map((doc, index) => {
|
||||
const node = path.node.children[child][index];
|
||||
return {
|
||||
doc,
|
||||
startOffset: parser.locStart(node)
|
||||
};
|
||||
}))
|
||||
.sort((a, b) => a.startOffset - b.startOffset)
|
||||
.map(({ doc }) => doc);
|
||||
}
|
||||
export function printSingle(path, print, _, args) {
|
||||
return call(path, childPath => print(childPath, args), onlyDefinedKey(path.node.children));
|
||||
}
|
||||
export function lineStartWithComments(node) {
|
||||
const { comments, location } = node;
|
||||
return comments
|
||||
? Math.min(location.startLine, comments[0].startLine)
|
||||
: location.startLine;
|
||||
}
|
||||
export function lineEndWithComments(node) {
|
||||
const { comments, location } = node;
|
||||
return comments
|
||||
? Math.max(location.endLine, comments.at(-1).endLine)
|
||||
: location.endLine;
|
||||
}
|
||||
export function printDanglingComments(path) {
|
||||
if (!path.node.comments) {
|
||||
return [];
|
||||
}
|
||||
const comments = [];
|
||||
path.each(commentPath => {
|
||||
const comment = commentPath.node;
|
||||
if (comment.leading || comment.trailing) {
|
||||
return;
|
||||
}
|
||||
comment.printed = true;
|
||||
comments.push(printComment(comment));
|
||||
}, "comments");
|
||||
return join(hardline, comments);
|
||||
}
|
||||
export function printComment(node) {
|
||||
const { image } = node;
|
||||
const lines = image.split("\n").map(line => line.trim());
|
||||
return lines.length > 1 &&
|
||||
lines[0].startsWith("/*") &&
|
||||
lines.slice(1).every(line => line.startsWith("*")) &&
|
||||
lines.at(-1).endsWith("*/")
|
||||
? join(hardline, lines.map((line, index) => (index === 0 ? line : ` ${line}`)))
|
||||
: image;
|
||||
}
|
||||
export function hasLeadingComments(node) {
|
||||
var _a;
|
||||
return (_a = node.comments) === null || _a === void 0 ? void 0 : _a.some(({ leading }) => leading);
|
||||
}
|
||||
export function indentInParentheses(contents, opts) {
|
||||
return !Array.isArray(contents) || contents.length
|
||||
? group(["(", indent([softline, contents]), softline, ")"], opts)
|
||||
: "()";
|
||||
}
|
||||
export function printArrayInitializer(path, print, options, child) {
|
||||
const list = [];
|
||||
if (child && child in path.node.children) {
|
||||
list.push(call(path, print, child));
|
||||
if (options.trailingComma !== "none") {
|
||||
list.push(ifBreak(","));
|
||||
}
|
||||
}
|
||||
list.push(...printDanglingComments(path));
|
||||
return list.length ? group(["{", indent([line, ...list]), line, "}"]) : "{}";
|
||||
}
|
||||
export function printBlock(path, contents) {
|
||||
if (!contents.length) {
|
||||
const danglingComments = printDanglingComments(path);
|
||||
return danglingComments.length
|
||||
? ["{", indent([hardline, ...danglingComments]), hardline, "}"]
|
||||
: "{}";
|
||||
}
|
||||
return group([
|
||||
"{",
|
||||
indent([hardline, ...join(hardline, contents)]),
|
||||
hardline,
|
||||
"}"
|
||||
]);
|
||||
}
|
||||
export function printName(path, print) {
|
||||
return join(".", map(path, print, "Identifier"));
|
||||
}
|
||||
export function printList(path, print, child) {
|
||||
return join([",", line], map(path, print, child));
|
||||
}
|
||||
export function printClassPermits(path, print) {
|
||||
return group([
|
||||
"permits",
|
||||
indent([line, group(printList(path, print, "typeName"))])
|
||||
]);
|
||||
}
|
||||
export function printClassType(path, print) {
|
||||
const { children } = path.node;
|
||||
return definedKeys(children, ["annotation", "Identifier", "typeArguments"])
|
||||
.flatMap(child => children[child].map((node, index) => ({
|
||||
child,
|
||||
index,
|
||||
startOffset: parser.locStart(node)
|
||||
})))
|
||||
.sort((a, b) => a.startOffset - b.startOffset)
|
||||
.flatMap(({ child, index: childIndex }, index, array) => {
|
||||
const node = children[child][childIndex];
|
||||
const next = array.at(index + 1);
|
||||
const nextNode = next && children[next.child][next.index];
|
||||
const docs = [path.call(print, "children", child, childIndex)];
|
||||
if (nextNode) {
|
||||
if (isNonTerminal(node)) {
|
||||
docs.push(node.name === "annotation" ? " " : ".");
|
||||
}
|
||||
else if (isTerminal(nextNode) || nextNode.name === "annotation") {
|
||||
docs.push(".");
|
||||
}
|
||||
}
|
||||
return docs;
|
||||
});
|
||||
}
|
||||
export function isBinaryExpression(expression) {
|
||||
var _a;
|
||||
const conditionalExpression = (_a = expression.children.conditionalExpression) === null || _a === void 0 ? void 0 : _a[0].children;
|
||||
if (!conditionalExpression) {
|
||||
return false;
|
||||
}
|
||||
const isTernary = conditionalExpression.QuestionMark !== undefined;
|
||||
if (isTernary) {
|
||||
return false;
|
||||
}
|
||||
const hasNonAssignmentOperators = Object.values(conditionalExpression.binaryExpression[0].children).some(child => {
|
||||
var _a;
|
||||
return isTerminal(child[0]) &&
|
||||
!((_a = child[0].tokenType.CATEGORIES) === null || _a === void 0 ? void 0 : _a.some(category => category.name === "AssignmentOperator"));
|
||||
});
|
||||
return hasNonAssignmentOperators;
|
||||
}
|
||||
export function findBaseIndent(lines) {
|
||||
return lines.length
|
||||
? Math.min(...lines.map(line => line.search(/\S/)).filter(indent => indent >= 0))
|
||||
: 0;
|
||||
}
|
||||
export function isEmptyStatement(statement) {
|
||||
var _a;
|
||||
return (((_a = statement.children.statementWithoutTrailingSubstatement) === null || _a === void 0 ? void 0 : _a[0].children.emptyStatement) !== undefined);
|
||||
}
|
||||
export function isNonTerminal(node) {
|
||||
return !isTerminal(node);
|
||||
}
|
||||
export function isTerminal(node) {
|
||||
return "tokenType" in node;
|
||||
}
|
||||
2
frontend/src/common/prettier/plugins/java/printers/index.d.ts
vendored
Normal file
2
frontend/src/common/prettier/plugins/java/printers/index.d.ts
vendored
Normal file
@@ -0,0 +1,2 @@
|
||||
import type { JavaNodePrinter, JavaNodePrinters } from "./helpers.js";
|
||||
export declare function printerForNodeType<T extends keyof JavaNodePrinters>(type: T): JavaNodePrinter<T>;
|
||||
13
frontend/src/common/prettier/plugins/java/printers/index.js
Normal file
13
frontend/src/common/prettier/plugins/java/printers/index.js
Normal file
@@ -0,0 +1,13 @@
|
||||
import arrays from "./arrays.js";
|
||||
import blocksAndStatements from "./blocks-and-statements.js";
|
||||
import classes from "./classes.js";
|
||||
import expressions from "./expressions.js";
|
||||
import interfaces from "./interfaces.js";
|
||||
import lexicalStructure from "./lexical-structure.js";
|
||||
import names from "./names.js";
|
||||
import packagesAndModules from "./packages-and-modules.js";
|
||||
import typesValuesAndVariables from "./types-values-and-variables.js";
|
||||
const printersByNodeType = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, arrays), blocksAndStatements), classes), expressions), interfaces), lexicalStructure), names), packagesAndModules), typesValuesAndVariables);
|
||||
export function printerForNodeType(type) {
|
||||
return printersByNodeType[type];
|
||||
}
|
||||
62
frontend/src/common/prettier/plugins/java/printers/interfaces.d.ts
vendored
Normal file
62
frontend/src/common/prettier/plugins/java/printers/interfaces.d.ts
vendored
Normal file
@@ -0,0 +1,62 @@
|
||||
import { builders } from "prettier/doc";
|
||||
import { printClassPermits, printSingle } from "./helpers.js";
|
||||
declare const _default: {
|
||||
interfaceDeclaration(path: import("prettier").AstPath<import("java-parser").InterfaceDeclarationCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
normalInterfaceDeclaration(path: import("prettier").AstPath<import("java-parser").NormalInterfaceDeclarationCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
interfaceModifier: typeof printSingle;
|
||||
interfaceExtends(path: import("prettier").AstPath<import("java-parser").InterfaceExtendsCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Group;
|
||||
interfacePermits: typeof printClassPermits;
|
||||
interfaceBody(path: import("prettier").AstPath<import("java-parser").InterfaceBodyCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Group | "{}" | (string | builders.Indent | builders.Hardline)[];
|
||||
interfaceMemberDeclaration(path: import("prettier").AstPath<import("java-parser").InterfaceMemberDeclarationCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc;
|
||||
constantDeclaration(path: import("prettier").AstPath<import("java-parser").ConstantDeclarationCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
constantModifier: typeof printSingle;
|
||||
interfaceMethodDeclaration(path: import("prettier").AstPath<import("java-parser").InterfaceMethodDeclarationCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
interfaceMethodModifier: typeof printSingle;
|
||||
annotationInterfaceDeclaration(path: import("prettier").AstPath<import("java-parser").AnnotationInterfaceDeclarationCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
annotationInterfaceBody(path: import("prettier").AstPath<import("java-parser").AnnotationInterfaceBodyCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Group | "{}" | (string | builders.Indent | builders.Hardline)[];
|
||||
annotationInterfaceMemberDeclaration(path: import("prettier").AstPath<import("java-parser").AnnotationInterfaceMemberDeclarationCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc;
|
||||
annotationInterfaceElementDeclaration(path: import("prettier").AstPath<import("java-parser").AnnotationInterfaceElementDeclarationCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
annotationInterfaceElementModifier: typeof printSingle;
|
||||
defaultValue(path: import("prettier").AstPath<import("java-parser").DefaultValueCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
annotation(path: import("prettier").AstPath<import("java-parser").AnnotationCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
elementValuePairList(path: import("prettier").AstPath<import("java-parser").ElementValuePairListCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
elementValuePair(path: import("prettier").AstPath<import("java-parser").ElementValuePairCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
elementValue: typeof printSingle;
|
||||
elementValueArrayInitializer(path: import("prettier").AstPath<import("java-parser").ElementValueArrayInitializerCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn, options: import("./helpers.js").JavaParserOptions): builders.Group | "{}";
|
||||
elementValueList(path: import("prettier").AstPath<import("java-parser").ElementValueListCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Group;
|
||||
};
|
||||
export default _default;
|
||||
157
frontend/src/common/prettier/plugins/java/printers/interfaces.js
Normal file
157
frontend/src/common/prettier/plugins/java/printers/interfaces.js
Normal file
@@ -0,0 +1,157 @@
|
||||
import { builders } from "prettier/doc";
|
||||
import { call, each, hasDeclarationAnnotations, indentInParentheses, lineEndWithComments, lineStartWithComments, onlyDefinedKey, printArrayInitializer, printBlock, printClassPermits, printList, printSingle, printWithModifiers } from "./helpers.js";
|
||||
const { group, hardline, indent, join, line } = builders;
|
||||
export default {
|
||||
interfaceDeclaration(path, print) {
|
||||
const declarationKey = onlyDefinedKey(path.node.children, [
|
||||
"annotationInterfaceDeclaration",
|
||||
"normalInterfaceDeclaration"
|
||||
]);
|
||||
return printWithModifiers(path, print, "interfaceModifier", call(path, print, declarationKey), true);
|
||||
},
|
||||
normalInterfaceDeclaration(path, print) {
|
||||
const { interfaceExtends, interfacePermits, typeParameters } = path.node.children;
|
||||
const header = ["interface ", call(path, print, "typeIdentifier")];
|
||||
if (typeParameters) {
|
||||
header.push(call(path, print, "typeParameters"));
|
||||
}
|
||||
if (interfaceExtends) {
|
||||
header.push(indent([line, call(path, print, "interfaceExtends")]));
|
||||
}
|
||||
if (interfacePermits) {
|
||||
header.push(indent([line, call(path, print, "interfacePermits")]));
|
||||
}
|
||||
return [group(header), " ", call(path, print, "interfaceBody")];
|
||||
},
|
||||
interfaceModifier: printSingle,
|
||||
interfaceExtends(path, print) {
|
||||
return group([
|
||||
"extends",
|
||||
indent([line, call(path, print, "interfaceTypeList")])
|
||||
]);
|
||||
},
|
||||
interfacePermits: printClassPermits,
|
||||
interfaceBody(path, print) {
|
||||
const declarations = [];
|
||||
let previousRequiresPadding = false;
|
||||
each(path, declarationPath => {
|
||||
var _a, _b, _c, _d;
|
||||
const declaration = print(declarationPath);
|
||||
if (declaration === "") {
|
||||
return;
|
||||
}
|
||||
const { node, previous } = declarationPath;
|
||||
const constantDeclaration = (_a = node.children.constantDeclaration) === null || _a === void 0 ? void 0 : _a[0].children;
|
||||
const methodDeclaration = (_b = node.children.interfaceMethodDeclaration) === null || _b === void 0 ? void 0 : _b[0].children;
|
||||
const currentRequiresPadding = (!constantDeclaration && !methodDeclaration) ||
|
||||
(methodDeclaration === null || methodDeclaration === void 0 ? void 0 : methodDeclaration.methodBody[0].children.block) !== undefined ||
|
||||
hasDeclarationAnnotations((_d = (_c = constantDeclaration === null || constantDeclaration === void 0 ? void 0 : constantDeclaration.constantModifier) !== null && _c !== void 0 ? _c : methodDeclaration === null || methodDeclaration === void 0 ? void 0 : methodDeclaration.interfaceMethodModifier) !== null && _d !== void 0 ? _d : []);
|
||||
const blankLine = declarations.length > 0 &&
|
||||
(previousRequiresPadding ||
|
||||
currentRequiresPadding ||
|
||||
lineStartWithComments(node) > lineEndWithComments(previous) + 1);
|
||||
declarations.push(blankLine ? [hardline, declaration] : declaration);
|
||||
previousRequiresPadding = currentRequiresPadding;
|
||||
}, "interfaceMemberDeclaration");
|
||||
return printBlock(path, declarations);
|
||||
},
|
||||
interfaceMemberDeclaration(path, print) {
|
||||
const { children } = path.node;
|
||||
return children.Semicolon
|
||||
? ""
|
||||
: call(path, print, onlyDefinedKey(children));
|
||||
},
|
||||
constantDeclaration(path, print) {
|
||||
const declaration = [
|
||||
call(path, print, "unannType"),
|
||||
" ",
|
||||
call(path, print, "variableDeclaratorList"),
|
||||
";"
|
||||
];
|
||||
return printWithModifiers(path, print, "constantModifier", declaration);
|
||||
},
|
||||
constantModifier: printSingle,
|
||||
interfaceMethodDeclaration(path, print) {
|
||||
const declaration = [
|
||||
call(path, print, "methodHeader"),
|
||||
path.node.children.methodBody[0].children.Semicolon ? "" : " ",
|
||||
call(path, print, "methodBody")
|
||||
];
|
||||
return printWithModifiers(path, print, "interfaceMethodModifier", declaration);
|
||||
},
|
||||
interfaceMethodModifier: printSingle,
|
||||
annotationInterfaceDeclaration(path, print) {
|
||||
return join(" ", [
|
||||
"@interface",
|
||||
call(path, print, "typeIdentifier"),
|
||||
call(path, print, "annotationInterfaceBody")
|
||||
]);
|
||||
},
|
||||
annotationInterfaceBody(path, print) {
|
||||
const declarations = [];
|
||||
each(path, declarationPath => {
|
||||
const declaration = print(declarationPath);
|
||||
if (declaration === "") {
|
||||
return;
|
||||
}
|
||||
declarations.push(declarationPath.isFirst ? declaration : [hardline, declaration]);
|
||||
}, "annotationInterfaceMemberDeclaration");
|
||||
return printBlock(path, declarations);
|
||||
},
|
||||
annotationInterfaceMemberDeclaration(path, print) {
|
||||
const { children } = path.node;
|
||||
return children.Semicolon
|
||||
? ""
|
||||
: call(path, print, onlyDefinedKey(children));
|
||||
},
|
||||
annotationInterfaceElementDeclaration(path, print) {
|
||||
const { dims, defaultValue } = path.node.children;
|
||||
const declaration = [
|
||||
call(path, print, "unannType"),
|
||||
" ",
|
||||
call(path, print, "Identifier"),
|
||||
"()"
|
||||
];
|
||||
if (dims) {
|
||||
declaration.push(call(path, print, "dims"));
|
||||
}
|
||||
if (defaultValue) {
|
||||
declaration.push(" ", call(path, print, "defaultValue"));
|
||||
}
|
||||
declaration.push(";");
|
||||
return printWithModifiers(path, print, "annotationInterfaceElementModifier", declaration);
|
||||
},
|
||||
annotationInterfaceElementModifier: printSingle,
|
||||
defaultValue(path, print) {
|
||||
return ["default ", call(path, print, "elementValue")];
|
||||
},
|
||||
annotation(path, print) {
|
||||
const { children } = path.node;
|
||||
const annotation = ["@", call(path, print, "typeName")];
|
||||
if (children.elementValue || children.elementValuePairList) {
|
||||
const valuesKey = onlyDefinedKey(children, [
|
||||
"elementValue",
|
||||
"elementValuePairList"
|
||||
]);
|
||||
annotation.push(indentInParentheses(call(path, print, valuesKey)));
|
||||
}
|
||||
return annotation;
|
||||
},
|
||||
elementValuePairList(path, print) {
|
||||
return printList(path, print, "elementValuePair");
|
||||
},
|
||||
elementValuePair(path, print) {
|
||||
return join(" ", [
|
||||
call(path, print, "Identifier"),
|
||||
call(path, print, "Equals"),
|
||||
call(path, print, "elementValue")
|
||||
]);
|
||||
},
|
||||
elementValue: printSingle,
|
||||
elementValueArrayInitializer(path, print, options) {
|
||||
return printArrayInitializer(path, print, options, "elementValueList");
|
||||
},
|
||||
elementValueList(path, print) {
|
||||
return group(printList(path, print, "elementValue"));
|
||||
}
|
||||
};
|
||||
14
frontend/src/common/prettier/plugins/java/printers/lexical-structure.d.ts
vendored
Normal file
14
frontend/src/common/prettier/plugins/java/printers/lexical-structure.d.ts
vendored
Normal file
@@ -0,0 +1,14 @@
|
||||
import { builders } from "prettier/doc";
|
||||
import { printSingle } from "./helpers.js";
|
||||
declare const _default: {
|
||||
literal(path: import("prettier").AstPath<import("java-parser").LiteralCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc;
|
||||
integerLiteral: typeof printSingle;
|
||||
floatingPointLiteral: typeof printSingle;
|
||||
booleanLiteral: typeof printSingle;
|
||||
shiftOperator(path: import("prettier").AstPath<import("java-parser").ShiftOperatorCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
};
|
||||
export default _default;
|
||||
@@ -0,0 +1,29 @@
|
||||
import { builders } from "prettier/doc";
|
||||
import { findBaseIndent, map, onlyDefinedKey, printSingle } from "./helpers.js";
|
||||
const { hardline, indent, join } = builders;
|
||||
export default {
|
||||
literal(path, print) {
|
||||
const { TextBlock } = path.node.children;
|
||||
if (!TextBlock) {
|
||||
return printSingle(path, print);
|
||||
}
|
||||
const [open, ...lines] = TextBlock[0].image.split("\n");
|
||||
const baseIndent = findBaseIndent(lines);
|
||||
const textBlock = join(hardline, [
|
||||
open,
|
||||
...lines.map(line => line.slice(baseIndent))
|
||||
]);
|
||||
const ancestor = path.getNode(14);
|
||||
return (ancestor === null || ancestor === void 0 ? void 0 : ancestor.name) === "variableInitializer" ||
|
||||
((ancestor === null || ancestor === void 0 ? void 0 : ancestor.name) === "binaryExpression" &&
|
||||
ancestor.children.AssignmentOperator)
|
||||
? indent(textBlock)
|
||||
: textBlock;
|
||||
},
|
||||
integerLiteral: printSingle,
|
||||
floatingPointLiteral: printSingle,
|
||||
booleanLiteral: printSingle,
|
||||
shiftOperator(path, print) {
|
||||
return map(path, print, onlyDefinedKey(path.node.children));
|
||||
}
|
||||
};
|
||||
12
frontend/src/common/prettier/plugins/java/printers/names.d.ts
vendored
Normal file
12
frontend/src/common/prettier/plugins/java/printers/names.d.ts
vendored
Normal file
@@ -0,0 +1,12 @@
|
||||
import { printName, printSingle } from "./helpers.js";
|
||||
declare const _default: {
|
||||
typeIdentifier: typeof printSingle;
|
||||
moduleName: typeof printName;
|
||||
packageName: typeof printName;
|
||||
typeName: typeof printName;
|
||||
expressionName: typeof printName;
|
||||
methodName: typeof printSingle;
|
||||
packageOrTypeName: typeof printName;
|
||||
ambiguousName: typeof printName;
|
||||
};
|
||||
export default _default;
|
||||
11
frontend/src/common/prettier/plugins/java/printers/names.js
Normal file
11
frontend/src/common/prettier/plugins/java/printers/names.js
Normal file
@@ -0,0 +1,11 @@
|
||||
import { printName, printSingle } from "./helpers.js";
|
||||
export default {
|
||||
typeIdentifier: printSingle,
|
||||
moduleName: printName,
|
||||
packageName: printName,
|
||||
typeName: printName,
|
||||
expressionName: printName,
|
||||
methodName: printSingle,
|
||||
packageOrTypeName: printName,
|
||||
ambiguousName: printName
|
||||
};
|
||||
46
frontend/src/common/prettier/plugins/java/printers/packages-and-modules.d.ts
vendored
Normal file
46
frontend/src/common/prettier/plugins/java/printers/packages-and-modules.d.ts
vendored
Normal file
@@ -0,0 +1,46 @@
|
||||
import type { ExportsModuleDirectiveCstNode, ImportDeclarationCstNode, OpensModuleDirectiveCstNode } from "java-parser";
|
||||
import type { AstPath } from "prettier";
|
||||
import { builders } from "prettier/doc";
|
||||
import { printSingle, type JavaPrintFn } from "./helpers.js";
|
||||
declare const _default: {
|
||||
compilationUnit(path: AstPath<import("java-parser").CompilationUnitCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
ordinaryCompilationUnit(path: AstPath<import("java-parser").OrdinaryCompilationUnitCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
modularCompilationUnit(path: AstPath<import("java-parser").ModularCompilationUnitCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
packageDeclaration(path: AstPath<import("java-parser").PackageDeclarationCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
packageModifier: typeof printSingle;
|
||||
importDeclaration(path: AstPath<ImportDeclarationCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc;
|
||||
typeDeclaration(path: AstPath<import("java-parser").TypeDeclarationCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc;
|
||||
moduleDeclaration(path: AstPath<import("java-parser").ModuleDeclarationCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
moduleDirective: typeof printSingle;
|
||||
requiresModuleDirective(path: AstPath<import("java-parser").RequiresModuleDirectiveCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
exportsModuleDirective(path: AstPath<ExportsModuleDirectiveCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
opensModuleDirective(path: AstPath<OpensModuleDirectiveCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
usesModuleDirective(path: AstPath<import("java-parser").UsesModuleDirectiveCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
providesModuleDirective(path: AstPath<import("java-parser").ProvidesModuleDirectiveCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: JavaPrintFn): builders.Doc[];
|
||||
requiresModifier: typeof printSingle;
|
||||
};
|
||||
export default _default;
|
||||
@@ -0,0 +1,169 @@
|
||||
import { builders } from "prettier/doc";
|
||||
import { call, lineEndWithComments, lineStartWithComments, map, printBlock, printDanglingComments, printName, printSingle } from "./helpers.js";
|
||||
const { group, hardline, indent, join, line } = builders;
|
||||
export default {
|
||||
compilationUnit(path, print) {
|
||||
return [...printDanglingComments(path), printSingle(path, print), hardline];
|
||||
},
|
||||
ordinaryCompilationUnit(path, print) {
|
||||
const { children } = path.node;
|
||||
const declarations = [];
|
||||
if (children.packageDeclaration) {
|
||||
declarations.push(call(path, print, "packageDeclaration"));
|
||||
}
|
||||
if (children.importDeclaration) {
|
||||
const staticCount = sortImports(children.importDeclaration);
|
||||
const importDeclarations = map(path, print, "importDeclaration").filter(doc => doc !== "");
|
||||
const staticDeclarations = importDeclarations.slice(0, staticCount);
|
||||
const nonStaticDeclarations = importDeclarations.slice(staticCount);
|
||||
declarations.push(...[staticDeclarations, nonStaticDeclarations]
|
||||
.filter(({ length }) => length)
|
||||
.map(declarations => join(hardline, declarations)));
|
||||
}
|
||||
if (children.typeDeclaration) {
|
||||
declarations.push(...map(path, print, "typeDeclaration").filter(declaration => declaration !== ""));
|
||||
}
|
||||
return join([hardline, hardline], declarations);
|
||||
},
|
||||
modularCompilationUnit(path, print) {
|
||||
const { children } = path.node;
|
||||
const declarations = [];
|
||||
if (children.importDeclaration) {
|
||||
const staticCount = sortImports(children.importDeclaration);
|
||||
const importDeclarations = map(path, print, "importDeclaration").filter(doc => doc !== "");
|
||||
const staticDeclarations = importDeclarations.slice(0, staticCount);
|
||||
const nonStaticDeclarations = importDeclarations.slice(staticCount);
|
||||
declarations.push(...[staticDeclarations, nonStaticDeclarations]
|
||||
.filter(({ length }) => length)
|
||||
.map(declarations => join(hardline, declarations)));
|
||||
}
|
||||
declarations.push(call(path, print, "moduleDeclaration"));
|
||||
return join([hardline, hardline], declarations);
|
||||
},
|
||||
packageDeclaration(path, print) {
|
||||
return join(hardline, [
|
||||
...map(path, print, "packageModifier"),
|
||||
["package ", printName(path, print), ";"]
|
||||
]);
|
||||
},
|
||||
packageModifier: printSingle,
|
||||
importDeclaration(path, print) {
|
||||
const { children } = path.node;
|
||||
if (children.emptyStatement) {
|
||||
return call(path, print, "emptyStatement");
|
||||
}
|
||||
const declaration = ["import "];
|
||||
if (children.Static) {
|
||||
declaration.push("static ");
|
||||
}
|
||||
declaration.push(call(path, print, "packageOrTypeName"));
|
||||
if (children.Star) {
|
||||
declaration.push(".*");
|
||||
}
|
||||
declaration.push(";");
|
||||
return declaration;
|
||||
},
|
||||
typeDeclaration(path, print) {
|
||||
return path.node.children.Semicolon ? "" : printSingle(path, print);
|
||||
},
|
||||
moduleDeclaration(path, print) {
|
||||
const { annotation, Open } = path.node.children;
|
||||
const prefix = [];
|
||||
if (annotation) {
|
||||
prefix.push(...map(path, print, "annotation"));
|
||||
}
|
||||
if (Open) {
|
||||
prefix.push("open");
|
||||
}
|
||||
const declarations = map(path, declarationPath => {
|
||||
const declaration = print(declarationPath);
|
||||
const { node, previous } = declarationPath;
|
||||
return !previous ||
|
||||
lineStartWithComments(node) <= lineEndWithComments(previous) + 1
|
||||
? declaration
|
||||
: [hardline, declaration];
|
||||
}, "moduleDirective");
|
||||
return join(" ", [
|
||||
...prefix,
|
||||
"module",
|
||||
printName(path, print),
|
||||
printBlock(path, declarations)
|
||||
]);
|
||||
},
|
||||
moduleDirective: printSingle,
|
||||
requiresModuleDirective(path, print) {
|
||||
return join(" ", [
|
||||
"requires",
|
||||
...map(path, print, "requiresModifier"),
|
||||
[call(path, print, "moduleName"), ";"]
|
||||
]);
|
||||
},
|
||||
exportsModuleDirective(path, print) {
|
||||
return printToModuleNamesDirective(path, print, "exports");
|
||||
},
|
||||
opensModuleDirective(path, print) {
|
||||
return printToModuleNamesDirective(path, print, "opens");
|
||||
},
|
||||
usesModuleDirective(path, print) {
|
||||
return ["uses ", call(path, print, "typeName"), ";"];
|
||||
},
|
||||
providesModuleDirective(path, print) {
|
||||
const [firstTypeName, ...restTypeNames] = map(path, print, "typeName");
|
||||
return [
|
||||
"provides ",
|
||||
firstTypeName,
|
||||
group(indent([
|
||||
line,
|
||||
group(indent(["with", line, ...join([",", line], restTypeNames)]))
|
||||
])),
|
||||
";"
|
||||
];
|
||||
},
|
||||
requiresModifier: printSingle
|
||||
};
|
||||
function sortImports(importDeclarations) {
|
||||
importDeclarations.sort(({ children: a }, { children: b }) => {
|
||||
if (a.Static && !b.Static) {
|
||||
return -1;
|
||||
}
|
||||
else if (b.Static && !a.Static) {
|
||||
return 1;
|
||||
}
|
||||
if (!b.packageOrTypeName) {
|
||||
if (a.packageOrTypeName) {
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
else if (!a.packageOrTypeName) {
|
||||
return 1;
|
||||
}
|
||||
return compareFqn(a.packageOrTypeName[0], b.packageOrTypeName[0]);
|
||||
});
|
||||
return importDeclarations.reduce((staticCount, importDeclaration) => importDeclaration.children.Static ? staticCount + 1 : staticCount, 0);
|
||||
}
|
||||
function compareFqn(a, b) {
|
||||
const identifiersA = a.children.Identifier;
|
||||
const identifiersB = b.children.Identifier;
|
||||
const minParts = Math.min(identifiersA.length, identifiersB.length);
|
||||
for (let i = 0; i < minParts; i++) {
|
||||
const imageA = identifiersA[i].image;
|
||||
const imageB = identifiersB[i].image;
|
||||
if (imageA < imageB) {
|
||||
return -1;
|
||||
}
|
||||
else if (imageA > imageB) {
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return identifiersA.length - identifiersB.length;
|
||||
}
|
||||
function printToModuleNamesDirective(path, print, prefix) {
|
||||
const directive = [prefix, " ", call(path, print, "packageName")];
|
||||
if (path.node.children.moduleName) {
|
||||
const moduleNames = join([",", line], map(path, print, "moduleName"));
|
||||
directive.push(group(indent([line, group(indent(["to", line, ...moduleNames]))])));
|
||||
}
|
||||
directive.push(";");
|
||||
return directive;
|
||||
}
|
||||
46
frontend/src/common/prettier/plugins/java/printers/types-values-and-variables.d.ts
vendored
Normal file
46
frontend/src/common/prettier/plugins/java/printers/types-values-and-variables.d.ts
vendored
Normal file
@@ -0,0 +1,46 @@
|
||||
import { builders } from "prettier/doc";
|
||||
import { printClassType, printSingle } from "./helpers.js";
|
||||
declare const _default: {
|
||||
primitiveType(path: import("prettier").AstPath<import("java-parser").PrimitiveTypeCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
numericType: typeof printSingle;
|
||||
integralType: typeof printSingle;
|
||||
floatingPointType: typeof printSingle;
|
||||
referenceType(path: import("prettier").AstPath<import("java-parser").ReferenceTypeCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
classOrInterfaceType: typeof printSingle;
|
||||
classType: typeof printClassType;
|
||||
interfaceType: typeof printSingle;
|
||||
typeVariable(path: import("prettier").AstPath<import("java-parser").TypeVariableCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
dims(path: import("prettier").AstPath<import("java-parser").DimsCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
typeParameter(path: import("prettier").AstPath<import("java-parser").TypeParameterCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
typeParameterModifier: typeof printSingle;
|
||||
typeBound(path: import("prettier").AstPath<import("java-parser").TypeBoundCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
additionalBound(path: import("prettier").AstPath<import("java-parser").AdditionalBoundCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
typeArguments(path: import("prettier").AstPath<import("java-parser").TypeArgumentsCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Group;
|
||||
typeArgumentList(path: import("prettier").AstPath<import("java-parser").TypeArgumentListCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
typeArgument: typeof printSingle;
|
||||
wildcard(path: import("prettier").AstPath<import("java-parser").WildcardCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
wildcardBounds(path: import("prettier").AstPath<import("java-parser").WildcardBoundsCstNode & {
|
||||
comments?: import("../comments.js").JavaComment[];
|
||||
}>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
|
||||
};
|
||||
export default _default;
|
||||
@@ -0,0 +1,90 @@
|
||||
import { builders } from "prettier/doc";
|
||||
import { call, definedKeys, flatMap, isNonTerminal, map, onlyDefinedKey, printClassType, printList, printSingle } from "./helpers.js";
|
||||
const { group, indent, join, line, softline } = builders;
|
||||
export default {
|
||||
primitiveType(path, print) {
|
||||
const { children } = path.node;
|
||||
const typeKey = onlyDefinedKey(children, ["Boolean", "numericType"]);
|
||||
return join(" ", [
|
||||
...map(path, print, "annotation"),
|
||||
call(path, print, typeKey)
|
||||
]);
|
||||
},
|
||||
numericType: printSingle,
|
||||
integralType: printSingle,
|
||||
floatingPointType: printSingle,
|
||||
referenceType(path, print) {
|
||||
const { children } = path.node;
|
||||
const typeKey = onlyDefinedKey(children, [
|
||||
"primitiveType",
|
||||
"classOrInterfaceType"
|
||||
]);
|
||||
const type = call(path, print, typeKey);
|
||||
return join(" ", [
|
||||
...map(path, print, "annotation"),
|
||||
children.dims ? [type, call(path, print, "dims")] : type
|
||||
]);
|
||||
},
|
||||
classOrInterfaceType: printSingle,
|
||||
classType: printClassType,
|
||||
interfaceType: printSingle,
|
||||
typeVariable(path, print) {
|
||||
return join(" ", [
|
||||
...map(path, print, "annotation"),
|
||||
call(path, print, "Identifier")
|
||||
]);
|
||||
},
|
||||
dims(path, print) {
|
||||
return flatMap(path, childPath => {
|
||||
const child = print(childPath);
|
||||
return isNonTerminal(childPath.node) ? [child, " "] : child;
|
||||
}, definedKeys(path.node.children, ["annotation", "LSquare", "RSquare"]));
|
||||
},
|
||||
typeParameter(path, print) {
|
||||
const parameter = [
|
||||
...map(path, print, "typeParameterModifier"),
|
||||
call(path, print, "typeIdentifier")
|
||||
];
|
||||
if (path.node.children.typeBound) {
|
||||
parameter.push(call(path, print, "typeBound"));
|
||||
}
|
||||
return join(" ", parameter);
|
||||
},
|
||||
typeParameterModifier: printSingle,
|
||||
typeBound(path, print) {
|
||||
const bound = ["extends ", call(path, print, "classOrInterfaceType")];
|
||||
if (path.node.children.additionalBound) {
|
||||
bound.push(group(indent([line, ...join(line, map(path, print, "additionalBound"))])));
|
||||
}
|
||||
return bound;
|
||||
},
|
||||
additionalBound(path, print) {
|
||||
return ["& ", call(path, print, "interfaceType")];
|
||||
},
|
||||
typeArguments(path, print) {
|
||||
return group([
|
||||
"<",
|
||||
indent([softline, call(path, print, "typeArgumentList")]),
|
||||
softline,
|
||||
">"
|
||||
]);
|
||||
},
|
||||
typeArgumentList(path, print) {
|
||||
return printList(path, print, "typeArgument");
|
||||
},
|
||||
typeArgument: printSingle,
|
||||
wildcard(path, print) {
|
||||
const wildcard = [...map(path, print, "annotation"), "?"];
|
||||
if (path.node.children.wildcardBounds) {
|
||||
wildcard.push(call(path, print, "wildcardBounds"));
|
||||
}
|
||||
return join(" ", wildcard);
|
||||
},
|
||||
wildcardBounds(path, print) {
|
||||
return [
|
||||
path.node.children.Extends ? "extends" : "super",
|
||||
" ",
|
||||
call(path, print, "referenceType")
|
||||
];
|
||||
}
|
||||
};
|
||||
4
frontend/src/common/prettier/plugins/php/index.d.ts
vendored
Normal file
4
frontend/src/common/prettier/plugins/php/index.d.ts
vendored
Normal file
@@ -0,0 +1,4 @@
|
||||
import type { Plugin } from "prettier";
|
||||
|
||||
declare const plugin: Plugin;
|
||||
export default plugin;
|
||||
19
frontend/src/common/prettier/plugins/php/index.mjs
Normal file
19
frontend/src/common/prettier/plugins/php/index.mjs
Normal file
@@ -0,0 +1,19 @@
|
||||
export {
|
||||
languages,
|
||||
printers,
|
||||
parsers,
|
||||
options,
|
||||
defaultOptions
|
||||
} from './src/index.mjs';
|
||||
|
||||
import { languages, printers, parsers, options, defaultOptions } from './src/index.mjs';
|
||||
|
||||
const phpPlugin = {
|
||||
languages,
|
||||
printers,
|
||||
parsers,
|
||||
options,
|
||||
defaultOptions
|
||||
};
|
||||
|
||||
export default phpPlugin;
|
||||
111
frontend/src/common/prettier/plugins/php/src/clean.mjs
Normal file
111
frontend/src/common/prettier/plugins/php/src/clean.mjs
Normal file
@@ -0,0 +1,111 @@
|
||||
import { printNumber, normalizeMagicMethodName } from "./util.mjs";
|
||||
|
||||
const ignoredProperties = new Set([
|
||||
"loc",
|
||||
"range",
|
||||
"raw",
|
||||
"comments",
|
||||
"leadingComments",
|
||||
"trailingComments",
|
||||
"parenthesizedExpression",
|
||||
"parent",
|
||||
"prev",
|
||||
"start",
|
||||
"end",
|
||||
"tokens",
|
||||
"errors",
|
||||
"extra",
|
||||
]);
|
||||
|
||||
/**
|
||||
* This function takes the existing ast node and a copy, by reference
|
||||
* We use it for testing, so that we can compare pre-post versions of the AST,
|
||||
* excluding things we don't care about (like node location, case that will be
|
||||
* changed by the printer, etc.)
|
||||
*/
|
||||
function clean(node, newObj) {
|
||||
if (node.kind === "string") {
|
||||
// TODO if options are available in this method, replace with
|
||||
// newObj.isDoubleQuote = !useSingleQuote(node, options);
|
||||
delete newObj.isDoubleQuote;
|
||||
}
|
||||
|
||||
if (["array", "list"].includes(node.kind)) {
|
||||
// TODO if options are available in this method, assign instead of delete
|
||||
delete newObj.shortForm;
|
||||
}
|
||||
|
||||
if (node.kind === "inline") {
|
||||
if (node.value.includes("___PSEUDO_INLINE_PLACEHOLDER___")) {
|
||||
return null;
|
||||
}
|
||||
|
||||
newObj.value = newObj.value.replace(/\n/g, "");
|
||||
}
|
||||
|
||||
// continue ((2)); -> continue 2;
|
||||
// continue 1; -> continue;
|
||||
if ((node.kind === "continue" || node.kind === "break") && node.level) {
|
||||
const { level } = newObj;
|
||||
|
||||
if (level.kind === "number") {
|
||||
newObj.level = level.value === "1" ? null : level;
|
||||
}
|
||||
}
|
||||
|
||||
// if () {{ }} -> if () {}
|
||||
if (node.kind === "block") {
|
||||
if (node.children.length === 1 && node.children[0].kind === "block") {
|
||||
while (newObj.children[0].kind === "block") {
|
||||
newObj.children = newObj.children[0].children;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Normalize numbers
|
||||
if (node.kind === "number") {
|
||||
newObj.value = printNumber(node.value);
|
||||
}
|
||||
|
||||
const statements = ["foreach", "for", "if", "while", "do"];
|
||||
|
||||
if (statements.includes(node.kind)) {
|
||||
if (node.body && node.body.kind !== "block") {
|
||||
newObj.body = {
|
||||
kind: "block",
|
||||
children: [newObj.body],
|
||||
};
|
||||
} else {
|
||||
newObj.body = newObj.body ? newObj.body : null;
|
||||
}
|
||||
|
||||
if (node.alternate && node.alternate.kind !== "block") {
|
||||
newObj.alternate = {
|
||||
kind: "block",
|
||||
children: [newObj.alternate],
|
||||
};
|
||||
} else {
|
||||
newObj.alternate = newObj.alternate ? newObj.alternate : null;
|
||||
}
|
||||
}
|
||||
|
||||
if (node.kind === "usegroup" && typeof node.name === "string") {
|
||||
newObj.name = newObj.name.replace(/^\\/, "");
|
||||
}
|
||||
|
||||
if (node.kind === "useitem") {
|
||||
newObj.name = newObj.name.replace(/^\\/, "");
|
||||
}
|
||||
|
||||
if (node.kind === "method" && node.name.kind === "identifier") {
|
||||
newObj.name.name = normalizeMagicMethodName(newObj.name.name);
|
||||
}
|
||||
|
||||
if (node.kind === "noop") {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
clean.ignoredProperties = ignoredProperties;
|
||||
|
||||
export default clean;
|
||||
1044
frontend/src/common/prettier/plugins/php/src/comments.mjs
Normal file
1044
frontend/src/common/prettier/plugins/php/src/comments.mjs
Normal file
File diff suppressed because it is too large
Load Diff
173
frontend/src/common/prettier/plugins/php/src/index.mjs
Normal file
173
frontend/src/common/prettier/plugins/php/src/index.mjs
Normal file
@@ -0,0 +1,173 @@
|
||||
import { doc } from "prettier";
|
||||
import LINGUIST_LANGUAGES_PHP from "linguist-languages/data/PHP";
|
||||
import LINGUIST_LANGUAGES_HTML_PHP from "linguist-languages/data/HTML_2b_PHP";
|
||||
import parse from "./parser.mjs";
|
||||
import print from "./printer.mjs";
|
||||
import clean from "./clean.mjs";
|
||||
import options from "./options.mjs";
|
||||
import {
|
||||
handleOwnLineComment,
|
||||
handleEndOfLineComment,
|
||||
handleRemainingComment,
|
||||
getCommentChildNodes,
|
||||
canAttachComment,
|
||||
isBlockComment,
|
||||
} from "./comments.mjs";
|
||||
import { hasPragma, insertPragma } from "./pragma.mjs";
|
||||
import { locStart, locEnd } from "./loc.mjs";
|
||||
|
||||
const { join, hardline } = doc.builders;
|
||||
|
||||
function createLanguage(linguistData, { extend, override }) {
|
||||
const language = {};
|
||||
|
||||
for (const key in linguistData) {
|
||||
const newKey = key === "languageId" ? "linguistLanguageId" : key;
|
||||
language[newKey] = linguistData[key];
|
||||
}
|
||||
|
||||
if (extend) {
|
||||
for (const key in extend) {
|
||||
language[key] = (language[key] || []).concat(extend[key]);
|
||||
}
|
||||
}
|
||||
|
||||
for (const key in override) {
|
||||
language[key] = override[key];
|
||||
}
|
||||
|
||||
return language;
|
||||
}
|
||||
|
||||
const languages = [
|
||||
createLanguage(LINGUIST_LANGUAGES_PHP, {
|
||||
override: {
|
||||
parsers: ["php"],
|
||||
vscodeLanguageIds: ["php"],
|
||||
},
|
||||
}),
|
||||
createLanguage(LINGUIST_LANGUAGES_HTML_PHP, {
|
||||
override: {
|
||||
parsers: ["php"],
|
||||
vscodeLanguageIds: ["php"],
|
||||
},
|
||||
}),
|
||||
];
|
||||
|
||||
const parsers = {
|
||||
php: {
|
||||
parse,
|
||||
astFormat: "php",
|
||||
locStart,
|
||||
locEnd,
|
||||
hasPragma,
|
||||
},
|
||||
};
|
||||
|
||||
const ignoredKeys = new Set([
|
||||
"kind",
|
||||
"loc",
|
||||
"errors",
|
||||
"extra",
|
||||
"comments",
|
||||
"leadingComments",
|
||||
"enclosingNode",
|
||||
"precedingNode",
|
||||
"followingNode",
|
||||
]);
|
||||
function getVisitorKeys(node, nonTraversableKeys) {
|
||||
return Object.keys(node).filter(
|
||||
(key) => !nonTraversableKeys.has(key) && !ignoredKeys.has(key)
|
||||
);
|
||||
}
|
||||
|
||||
const printers = {
|
||||
php: {
|
||||
print,
|
||||
getVisitorKeys,
|
||||
insertPragma,
|
||||
massageAstNode: clean,
|
||||
getCommentChildNodes,
|
||||
canAttachComment,
|
||||
isBlockComment,
|
||||
handleComments: {
|
||||
ownLine: handleOwnLineComment,
|
||||
endOfLine: handleEndOfLineComment,
|
||||
remaining: handleRemainingComment,
|
||||
},
|
||||
willPrintOwnComments(path) {
|
||||
const { node } = path;
|
||||
|
||||
return node && node.kind === "noop";
|
||||
},
|
||||
printComment(path) {
|
||||
const comment = path.node;
|
||||
|
||||
switch (comment.kind) {
|
||||
case "commentblock": {
|
||||
// for now, don't touch single line block comments
|
||||
if (!comment.value.includes("\n")) {
|
||||
return comment.value;
|
||||
}
|
||||
|
||||
const lines = comment.value.split("\n");
|
||||
// if this is a block comment, handle indentation
|
||||
if (
|
||||
lines
|
||||
.slice(1, lines.length - 1)
|
||||
.every((line) => line.trim()[0] === "*")
|
||||
) {
|
||||
return join(
|
||||
hardline,
|
||||
lines.map(
|
||||
(line, index) =>
|
||||
(index > 0 ? " " : "") +
|
||||
(index < lines.length - 1 ? line.trim() : line.trimLeft())
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
// otherwise we can't be sure about indentation, so just print as is
|
||||
return comment.value;
|
||||
}
|
||||
case "commentline": {
|
||||
return comment.value.trimRight();
|
||||
}
|
||||
/* c8 ignore next 2 */
|
||||
default:
|
||||
throw new Error(`Not a comment: ${JSON.stringify(comment)}`);
|
||||
}
|
||||
},
|
||||
hasPrettierIgnore(path) {
|
||||
const isSimpleIgnore = (comment) =>
|
||||
comment.value.includes("prettier-ignore") &&
|
||||
!comment.value.includes("prettier-ignore-start") &&
|
||||
!comment.value.includes("prettier-ignore-end");
|
||||
|
||||
const { node, parent: parentNode } = path;
|
||||
|
||||
return (
|
||||
(node &&
|
||||
node.kind !== "classconstant" &&
|
||||
node.comments &&
|
||||
node.comments.length > 0 &&
|
||||
node.comments.some(isSimpleIgnore)) ||
|
||||
// For proper formatting, the classconstant ignore formatting should
|
||||
// run on the "constant" child
|
||||
(node &&
|
||||
node.kind === "constant" &&
|
||||
parentNode &&
|
||||
parentNode.kind === "classconstant" &&
|
||||
parentNode.comments &&
|
||||
parentNode.comments.length > 0 &&
|
||||
parentNode.comments.some(isSimpleIgnore))
|
||||
);
|
||||
},
|
||||
},
|
||||
};
|
||||
|
||||
const defaultOptions = {
|
||||
tabWidth: 4,
|
||||
};
|
||||
|
||||
export { languages, printers, parsers, options, defaultOptions };
|
||||
4
frontend/src/common/prettier/plugins/php/src/loc.mjs
Normal file
4
frontend/src/common/prettier/plugins/php/src/loc.mjs
Normal file
@@ -0,0 +1,4 @@
|
||||
const loc = (prop) => (node) => node.loc?.[prop]?.offset;
|
||||
|
||||
export const locStart = loc("start");
|
||||
export const locEnd = loc("end");
|
||||
250
frontend/src/common/prettier/plugins/php/src/needs-parens.mjs
Normal file
250
frontend/src/common/prettier/plugins/php/src/needs-parens.mjs
Normal file
@@ -0,0 +1,250 @@
|
||||
import { getPrecedence, shouldFlatten, isBitwiseOperator } from "./util.mjs";
|
||||
|
||||
function needsParens(path, options) {
|
||||
const { parent } = path;
|
||||
|
||||
if (!parent) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const { key, node } = path;
|
||||
|
||||
if (
|
||||
[
|
||||
// No need parens for top level children of this nodes
|
||||
"program",
|
||||
"expressionstatement",
|
||||
"namespace",
|
||||
"declare",
|
||||
"block",
|
||||
|
||||
// No need parens
|
||||
"include",
|
||||
"print",
|
||||
"return",
|
||||
"echo",
|
||||
].includes(parent.kind)
|
||||
) {
|
||||
return false;
|
||||
}
|
||||
|
||||
switch (node.kind) {
|
||||
case "pre":
|
||||
case "post":
|
||||
if (parent.kind === "unary") {
|
||||
return (
|
||||
node.kind === "pre" &&
|
||||
((node.type === "+" && parent.type === "+") ||
|
||||
(node.type === "-" && parent.type === "-"))
|
||||
);
|
||||
}
|
||||
// else fallthrough
|
||||
case "unary":
|
||||
switch (parent.kind) {
|
||||
case "unary":
|
||||
return (
|
||||
node.type === parent.type &&
|
||||
(node.type === "+" || node.type === "-")
|
||||
);
|
||||
case "propertylookup":
|
||||
case "nullsafepropertylookup":
|
||||
case "staticlookup":
|
||||
case "offsetlookup":
|
||||
case "call":
|
||||
return key === "what";
|
||||
case "bin":
|
||||
return parent.type === "**" && key === "left";
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
case "bin": {
|
||||
switch (parent.kind) {
|
||||
case "assign":
|
||||
case "retif":
|
||||
return ["and", "xor", "or"].includes(node.type);
|
||||
case "silent":
|
||||
case "cast":
|
||||
// TODO: bug https://github.com/glayzzle/php-parser/issues/172
|
||||
return node.parenthesizedExpression;
|
||||
case "pre":
|
||||
case "post":
|
||||
case "unary":
|
||||
return true;
|
||||
case "call":
|
||||
case "propertylookup":
|
||||
case "nullsafepropertylookup":
|
||||
case "staticlookup":
|
||||
case "offsetlookup":
|
||||
return key === "what";
|
||||
case "bin": {
|
||||
const po = parent.type;
|
||||
const pp = getPrecedence(po);
|
||||
const no = node.type;
|
||||
const np = getPrecedence(no);
|
||||
|
||||
if (pp > np) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (po === "||" && no === "&&") {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (pp === np && key === "right") {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (pp === np && !shouldFlatten(po, no)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (pp < np && no === "%") {
|
||||
return po === "+" || po === "-";
|
||||
}
|
||||
|
||||
// Add parenthesis when working with bitwise operators
|
||||
// It's not stricly needed but helps with code understanding
|
||||
if (isBitwiseOperator(po)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
case "propertylookup":
|
||||
case "nullsafepropertylookup":
|
||||
case "staticlookup": {
|
||||
switch (parent.kind) {
|
||||
case "call":
|
||||
return key === "what" && node.parenthesizedExpression;
|
||||
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
case "clone":
|
||||
case "new": {
|
||||
const requiresParens =
|
||||
node.kind === "clone" ||
|
||||
(node.kind === "new" && options.phpVersion < 8.4);
|
||||
switch (parent.kind) {
|
||||
case "propertylookup":
|
||||
case "nullsafepropertylookup":
|
||||
case "staticlookup":
|
||||
case "offsetlookup":
|
||||
case "call":
|
||||
return key === "what" && requiresParens;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
case "yield": {
|
||||
switch (parent.kind) {
|
||||
case "propertylookup":
|
||||
case "nullsafepropertylookup":
|
||||
case "staticlookup":
|
||||
case "offsetlookup":
|
||||
case "call":
|
||||
return key === "what";
|
||||
|
||||
case "retif":
|
||||
return key === "test";
|
||||
|
||||
default:
|
||||
return !!(node.key || node.value);
|
||||
}
|
||||
}
|
||||
case "assign": {
|
||||
if (
|
||||
parent.kind === "for" &&
|
||||
(parent.init.includes(node) || parent.increment.includes(node))
|
||||
) {
|
||||
return false;
|
||||
} else if (parent.kind === "assign") {
|
||||
return false;
|
||||
} else if (parent.kind === "static") {
|
||||
return false;
|
||||
} else if (
|
||||
["if", "do", "while", "foreach", "switch"].includes(parent.kind)
|
||||
) {
|
||||
return false;
|
||||
} else if (parent.kind === "silent") {
|
||||
return false;
|
||||
} else if (parent.kind === "call") {
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
case "retif":
|
||||
switch (parent.kind) {
|
||||
case "cast":
|
||||
return true;
|
||||
case "unary":
|
||||
case "bin":
|
||||
case "retif":
|
||||
if (key === "test" && !parent.trueExpr) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
case "propertylookup":
|
||||
case "nullsafepropertylookup":
|
||||
case "staticlookup":
|
||||
case "offsetlookup":
|
||||
case "call":
|
||||
return key === "what";
|
||||
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
case "closure":
|
||||
switch (parent.kind) {
|
||||
case "call":
|
||||
return key === "what";
|
||||
|
||||
// https://github.com/prettier/plugin-php/issues/1675
|
||||
case "propertylookup":
|
||||
case "nullsafepropertylookup":
|
||||
return true;
|
||||
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
case "silence":
|
||||
case "cast":
|
||||
// TODO: bug https://github.com/glayzzle/php-parser/issues/172
|
||||
return node.parenthesizedExpression;
|
||||
// else fallthrough
|
||||
case "string":
|
||||
case "array":
|
||||
switch (parent.kind) {
|
||||
case "propertylookup":
|
||||
case "nullsafepropertylookup":
|
||||
case "staticlookup":
|
||||
case "offsetlookup":
|
||||
case "call":
|
||||
if (
|
||||
["string", "array"].includes(node.kind) &&
|
||||
parent.kind === "offsetlookup"
|
||||
) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return key === "what";
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
case "print":
|
||||
case "include":
|
||||
return parent.kind === "bin";
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
export default needsParens;
|
||||
69
frontend/src/common/prettier/plugins/php/src/options.mjs
Normal file
69
frontend/src/common/prettier/plugins/php/src/options.mjs
Normal file
@@ -0,0 +1,69 @@
|
||||
const CATEGORY_PHP = "PHP";
|
||||
|
||||
// prettier-ignore
|
||||
const SUPPORTED_PHP_VERSIONS = [
|
||||
5.0, 5.1, 5.2, 5.3, 5.4, 5.5, 5.6,
|
||||
7.0, 7.1, 7.2, 7.3, 7.4,
|
||||
8.0, 8.1, 8.2, 8.3, 8.4,
|
||||
];
|
||||
|
||||
export const LATEST_SUPPORTED_PHP_VERSION = Math.max(...SUPPORTED_PHP_VERSIONS);
|
||||
|
||||
/**
|
||||
* Resolve the PHP version to a number based on the provided options.
|
||||
*/
|
||||
export function resolvePhpVersion(options) {
|
||||
if (!options) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (options.phpVersion === "auto" || options.phpVersion === "composer") {
|
||||
options.phpVersion = LATEST_SUPPORTED_PHP_VERSION;
|
||||
} else {
|
||||
options.phpVersion = parseFloat(options.phpVersion);
|
||||
}
|
||||
}
|
||||
|
||||
export default {
|
||||
phpVersion: {
|
||||
since: "0.13.0",
|
||||
category: CATEGORY_PHP,
|
||||
type: "choice",
|
||||
default: "auto",
|
||||
description: "Minimum target PHP version.",
|
||||
choices: [
|
||||
...SUPPORTED_PHP_VERSIONS.map((v) => ({ value: v.toFixed(1) })),
|
||||
{
|
||||
value: "auto",
|
||||
description: `Use latest PHP Version (${LATEST_SUPPORTED_PHP_VERSION})`,
|
||||
},
|
||||
],
|
||||
},
|
||||
trailingCommaPHP: {
|
||||
since: "0.0.0",
|
||||
category: CATEGORY_PHP,
|
||||
type: "boolean",
|
||||
default: true,
|
||||
description: "Print trailing commas wherever possible when multi-line.",
|
||||
},
|
||||
braceStyle: {
|
||||
since: "0.10.0",
|
||||
category: CATEGORY_PHP,
|
||||
type: "choice",
|
||||
default: "per-cs",
|
||||
description:
|
||||
"Print one space or newline for code blocks (classes and functions).",
|
||||
choices: [
|
||||
{ value: "psr-2", description: "(deprecated) Use per-cs" },
|
||||
{ value: "per-cs", description: "Use the PER Coding Style brace style." },
|
||||
{ value: "1tbs", description: "Use 1tbs brace style." },
|
||||
],
|
||||
},
|
||||
singleQuote: {
|
||||
since: "0.0.0",
|
||||
category: CATEGORY_PHP,
|
||||
type: "boolean",
|
||||
default: false,
|
||||
description: "Use single quotes instead of double quotes.",
|
||||
},
|
||||
};
|
||||
67
frontend/src/common/prettier/plugins/php/src/parser.mjs
Normal file
67
frontend/src/common/prettier/plugins/php/src/parser.mjs
Normal file
@@ -0,0 +1,67 @@
|
||||
import engine from "php-parser";
|
||||
import { LATEST_SUPPORTED_PHP_VERSION } from "./options.mjs";
|
||||
import { resolvePhpVersion } from "./options.mjs";
|
||||
|
||||
function parse(text, opts) {
|
||||
const inMarkdown = opts && opts.parentParser === "markdown";
|
||||
|
||||
if (!text && inMarkdown) {
|
||||
return "";
|
||||
}
|
||||
resolvePhpVersion(opts);
|
||||
|
||||
// Todo https://github.com/glayzzle/php-parser/issues/170
|
||||
text = text.replace(/\?>\n<\?/g, "?>\n___PSEUDO_INLINE_PLACEHOLDER___<?");
|
||||
|
||||
// initialize a new parser instance
|
||||
const parser = new engine({
|
||||
parser: {
|
||||
extractDoc: true,
|
||||
version: `${LATEST_SUPPORTED_PHP_VERSION}`,
|
||||
},
|
||||
ast: {
|
||||
withPositions: true,
|
||||
withSource: true,
|
||||
},
|
||||
});
|
||||
|
||||
const hasOpenPHPTag = text.indexOf("<?php") !== -1;
|
||||
const parseAsEval = inMarkdown && !hasOpenPHPTag;
|
||||
|
||||
let ast;
|
||||
try {
|
||||
ast = parseAsEval ? parser.parseEval(text) : parser.parseCode(text);
|
||||
} catch (err) {
|
||||
if (err instanceof SyntaxError && "lineNumber" in err) {
|
||||
err.loc = {
|
||||
start: {
|
||||
line: err.lineNumber,
|
||||
column: err.columnNumber,
|
||||
},
|
||||
};
|
||||
|
||||
delete err.lineNumber;
|
||||
delete err.columnNumber;
|
||||
}
|
||||
|
||||
throw err;
|
||||
}
|
||||
|
||||
ast.extra = {
|
||||
parseAsEval,
|
||||
};
|
||||
|
||||
// https://github.com/glayzzle/php-parser/issues/155
|
||||
// currently inline comments include the line break at the end, we need to
|
||||
// strip those out and update the end location for each comment manually
|
||||
ast.comments.forEach((comment) => {
|
||||
if (comment.value[comment.value.length - 1] === "\n") {
|
||||
comment.value = comment.value.slice(0, -1);
|
||||
comment.loc.end.offset = comment.loc.end.offset - 1;
|
||||
}
|
||||
});
|
||||
|
||||
return ast;
|
||||
}
|
||||
|
||||
export default parse;
|
||||
92
frontend/src/common/prettier/plugins/php/src/pragma.mjs
Normal file
92
frontend/src/common/prettier/plugins/php/src/pragma.mjs
Normal file
@@ -0,0 +1,92 @@
|
||||
import { memoize } from "./util.mjs";
|
||||
import parse from "./parser.mjs";
|
||||
|
||||
const reHasPragma = /@prettier|@format/;
|
||||
|
||||
const getPageLevelDocBlock = memoize((text) => {
|
||||
const parsed = parse(text);
|
||||
|
||||
const [firstChild] = parsed.children;
|
||||
const [firstDocBlock] = parsed.comments.filter(
|
||||
(el) => el.kind === "commentblock"
|
||||
);
|
||||
|
||||
if (
|
||||
firstChild &&
|
||||
firstDocBlock &&
|
||||
firstDocBlock.loc.start.line < firstChild.loc.start.line
|
||||
) {
|
||||
return firstDocBlock;
|
||||
}
|
||||
});
|
||||
|
||||
function hasPragma(text) {
|
||||
// fast path optimization - check if the pragma shows up in the file at all
|
||||
if (!reHasPragma.test(text)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const pageLevelDocBlock = getPageLevelDocBlock(text);
|
||||
|
||||
if (pageLevelDocBlock) {
|
||||
const { value } = pageLevelDocBlock;
|
||||
|
||||
return reHasPragma.test(value);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
function injectPragma(docblock) {
|
||||
let lines = docblock.split("\n");
|
||||
|
||||
if (lines.length === 1) {
|
||||
// normalize to multiline for simplicity
|
||||
const [, line] = /\/*\*\*(.*)\*\//.exec(lines[0]);
|
||||
|
||||
lines = ["/**", ` * ${line.trim()}`, " */"];
|
||||
}
|
||||
|
||||
// find the first @pragma
|
||||
// if there happens to be one on the opening line, just put it on the next line.
|
||||
const pragmaIndex = lines.findIndex((line) => /@\S/.test(line)) || 1;
|
||||
|
||||
// not found => index == -1, which conveniently will splice 1 from the end.
|
||||
lines.splice(pragmaIndex, 0, " * @format");
|
||||
|
||||
return lines.join("\n");
|
||||
}
|
||||
|
||||
function insertPragma(text) {
|
||||
const pageLevelDocBlock = getPageLevelDocBlock(text);
|
||||
|
||||
if (pageLevelDocBlock) {
|
||||
const {
|
||||
start: { offset: startOffset },
|
||||
end: { offset: endOffset },
|
||||
} = pageLevelDocBlock.loc;
|
||||
const before = text.substring(0, startOffset);
|
||||
const after = text.substring(endOffset);
|
||||
|
||||
return `${before}${injectPragma(pageLevelDocBlock.value, text)}${after}`;
|
||||
}
|
||||
|
||||
const openTag = "<?php";
|
||||
|
||||
if (!text.startsWith(openTag)) {
|
||||
// bail out
|
||||
return text;
|
||||
}
|
||||
|
||||
const splitAt = openTag.length;
|
||||
const phpTag = text.substring(0, splitAt);
|
||||
const after = text.substring(splitAt);
|
||||
|
||||
return `${phpTag}
|
||||
/**
|
||||
* @format
|
||||
*/
|
||||
${after}`;
|
||||
}
|
||||
|
||||
export { hasPragma, insertPragma };
|
||||
2899
frontend/src/common/prettier/plugins/php/src/printer.mjs
Normal file
2899
frontend/src/common/prettier/plugins/php/src/printer.mjs
Normal file
File diff suppressed because it is too large
Load Diff
743
frontend/src/common/prettier/plugins/php/src/util.mjs
Normal file
743
frontend/src/common/prettier/plugins/php/src/util.mjs
Normal file
@@ -0,0 +1,743 @@
|
||||
import { util as prettierUtil } from "prettier";
|
||||
import { locStart } from "./loc.mjs";
|
||||
|
||||
const { hasNewline, skipEverythingButNewLine, skipNewline } = prettierUtil;
|
||||
|
||||
function printNumber(rawNumber) {
|
||||
return (
|
||||
rawNumber
|
||||
.toLowerCase()
|
||||
// Remove unnecessary plus and zeroes from scientific notation.
|
||||
.replace(/^([+-]?[\d.]+e)(?:\+|(-))?0*(\d)/, "$1$2$3")
|
||||
// Remove unnecessary scientific notation (1e0).
|
||||
.replace(/^([+-]?[\d.]+)e[+-]?0+$/, "$1")
|
||||
// Make sure numbers always start with a digit.
|
||||
.replace(/^([+-])?\./, "$10.")
|
||||
// Remove extraneous trailing decimal zeroes.
|
||||
.replace(/(\.\d+?)0+(?=e|$)/, "$1")
|
||||
// Remove unnecessary .e notation
|
||||
.replace(/\.(?=e)/, "")
|
||||
);
|
||||
}
|
||||
|
||||
// http://php.net/manual/en/language.operators.precedence.php
|
||||
const PRECEDENCE = new Map(
|
||||
[
|
||||
["or"],
|
||||
["xor"],
|
||||
["and"],
|
||||
[
|
||||
"=",
|
||||
"+=",
|
||||
"-=",
|
||||
"*=",
|
||||
"**=",
|
||||
"/=",
|
||||
".=",
|
||||
"%=",
|
||||
"&=",
|
||||
"|=",
|
||||
"^=",
|
||||
"<<=",
|
||||
">>=",
|
||||
],
|
||||
["??"],
|
||||
["||"],
|
||||
["&&"],
|
||||
["|"],
|
||||
["^"],
|
||||
["&"],
|
||||
["==", "===", "!=", "!==", "<>", "<=>"],
|
||||
["<", ">", "<=", ">="],
|
||||
[">>", "<<"],
|
||||
["+", "-", "."],
|
||||
["*", "/", "%"],
|
||||
["!"],
|
||||
["instanceof"],
|
||||
["++", "--", "~"],
|
||||
["**"],
|
||||
].flatMap((operators, index) =>
|
||||
operators.map((operator) => [operator, index])
|
||||
)
|
||||
);
|
||||
function getPrecedence(operator) {
|
||||
return PRECEDENCE.get(operator);
|
||||
}
|
||||
|
||||
const equalityOperators = ["==", "!=", "===", "!==", "<>", "<=>"];
|
||||
const multiplicativeOperators = ["*", "/", "%"];
|
||||
const bitshiftOperators = [">>", "<<"];
|
||||
|
||||
function isBitwiseOperator(operator) {
|
||||
return (
|
||||
!!bitshiftOperators[operator] ||
|
||||
operator === "|" ||
|
||||
operator === "^" ||
|
||||
operator === "&"
|
||||
);
|
||||
}
|
||||
|
||||
function shouldFlatten(parentOp, nodeOp) {
|
||||
if (getPrecedence(nodeOp) !== getPrecedence(parentOp)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// ** is right-associative
|
||||
// x ** y ** z --> x ** (y ** z)
|
||||
if (parentOp === "**") {
|
||||
return false;
|
||||
}
|
||||
|
||||
// x == y == z --> (x == y) == z
|
||||
if (
|
||||
equalityOperators.includes(parentOp) &&
|
||||
equalityOperators.includes(nodeOp)
|
||||
) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// x * y % z --> (x * y) % z
|
||||
if (
|
||||
(nodeOp === "%" && multiplicativeOperators.includes(parentOp)) ||
|
||||
(parentOp === "%" && multiplicativeOperators.includes(nodeOp))
|
||||
) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// x * y / z --> (x * y) / z
|
||||
// x / y * z --> (x / y) * z
|
||||
if (
|
||||
nodeOp !== parentOp &&
|
||||
multiplicativeOperators.includes(nodeOp) &&
|
||||
multiplicativeOperators.includes(parentOp)
|
||||
) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// x << y << z --> (x << y) << z
|
||||
if (
|
||||
bitshiftOperators.includes(parentOp) &&
|
||||
bitshiftOperators.includes(nodeOp)
|
||||
) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
function nodeHasStatement(node) {
|
||||
return [
|
||||
"block",
|
||||
"program",
|
||||
"namespace",
|
||||
"class",
|
||||
"enum",
|
||||
"interface",
|
||||
"trait",
|
||||
"traituse",
|
||||
"declare",
|
||||
].includes(node.kind);
|
||||
}
|
||||
|
||||
function getBodyFirstChild({ body }) {
|
||||
if (!body) {
|
||||
return null;
|
||||
}
|
||||
if (body.kind === "block") {
|
||||
body = body.children;
|
||||
}
|
||||
return body[0];
|
||||
}
|
||||
|
||||
function getNodeListProperty(node) {
|
||||
const body = node.children || node.body || node.adaptations;
|
||||
return Array.isArray(body) ? body : null;
|
||||
}
|
||||
|
||||
function getLast(arr) {
|
||||
if (arr.length > 0) {
|
||||
return arr[arr.length - 1];
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
function getPenultimate(arr) {
|
||||
if (arr.length > 1) {
|
||||
return arr[arr.length - 2];
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
function isFirstChildrenInlineNode(path) {
|
||||
const { node } = path;
|
||||
|
||||
if (node.kind === "program") {
|
||||
const children = getNodeListProperty(node);
|
||||
|
||||
if (!children || children.length === 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return children[0].kind === "inline";
|
||||
}
|
||||
|
||||
if (node.kind === "switch") {
|
||||
if (!node.body) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const children = getNodeListProperty(node.body);
|
||||
|
||||
if (children.length === 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const [firstCase] = children;
|
||||
|
||||
if (!firstCase.body) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const firstCaseChildren = getNodeListProperty(firstCase.body);
|
||||
|
||||
if (firstCaseChildren.length === 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return firstCaseChildren[0].kind === "inline";
|
||||
}
|
||||
|
||||
const firstChild = getBodyFirstChild(node);
|
||||
|
||||
if (!firstChild) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return firstChild.kind === "inline";
|
||||
}
|
||||
|
||||
function isDocNode(node) {
|
||||
return (
|
||||
node.kind === "nowdoc" ||
|
||||
(node.kind === "encapsed" && node.type === "heredoc")
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Heredoc/Nowdoc nodes need a trailing linebreak if they
|
||||
* appear as function arguments or array elements
|
||||
*/
|
||||
function docShouldHaveTrailingNewline(path, recurse = 0) {
|
||||
const node = path.getNode(recurse);
|
||||
const parent = path.getNode(recurse + 1);
|
||||
const parentParent = path.getNode(recurse + 2);
|
||||
|
||||
if (!parent) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (
|
||||
(parentParent &&
|
||||
["call", "new", "echo"].includes(parentParent.kind) &&
|
||||
!["call", "array"].includes(parent.kind)) ||
|
||||
parent.kind === "parameter"
|
||||
) {
|
||||
const lastIndex = parentParent.arguments.length - 1;
|
||||
const index = parentParent.arguments.indexOf(parent);
|
||||
|
||||
return index !== lastIndex;
|
||||
}
|
||||
|
||||
if (parentParent && parentParent.kind === "for") {
|
||||
const initIndex = parentParent.init.indexOf(parent);
|
||||
|
||||
if (initIndex !== -1) {
|
||||
return initIndex !== parentParent.init.length - 1;
|
||||
}
|
||||
|
||||
const testIndex = parentParent.test.indexOf(parent);
|
||||
|
||||
if (testIndex !== -1) {
|
||||
return testIndex !== parentParent.test.length - 1;
|
||||
}
|
||||
|
||||
const incrementIndex = parentParent.increment.indexOf(parent);
|
||||
|
||||
if (incrementIndex !== -1) {
|
||||
return incrementIndex !== parentParent.increment.length - 1;
|
||||
}
|
||||
}
|
||||
|
||||
if (parent.kind === "bin") {
|
||||
return (
|
||||
parent.left === node || docShouldHaveTrailingNewline(path, recurse + 1)
|
||||
);
|
||||
}
|
||||
|
||||
if (parent.kind === "case" && parent.test === node) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (parent.kind === "staticvariable") {
|
||||
const lastIndex = parentParent.variables.length - 1;
|
||||
const index = parentParent.variables.indexOf(parent);
|
||||
|
||||
return index !== lastIndex;
|
||||
}
|
||||
|
||||
if (parent.kind === "entry") {
|
||||
if (parent.key === node) {
|
||||
return true;
|
||||
}
|
||||
|
||||
const lastIndex = parentParent.items.length - 1;
|
||||
const index = parentParent.items.indexOf(parent);
|
||||
|
||||
return index !== lastIndex;
|
||||
}
|
||||
|
||||
if (["call", "new"].includes(parent.kind)) {
|
||||
const lastIndex = parent.arguments.length - 1;
|
||||
const index = parent.arguments.indexOf(node);
|
||||
|
||||
return index !== lastIndex;
|
||||
}
|
||||
|
||||
if (parent.kind === "echo") {
|
||||
const lastIndex = parent.expressions.length - 1;
|
||||
const index = parent.expressions.indexOf(node);
|
||||
|
||||
return index !== lastIndex;
|
||||
}
|
||||
|
||||
if (parent.kind === "array") {
|
||||
const lastIndex = parent.items.length - 1;
|
||||
const index = parent.items.indexOf(node);
|
||||
|
||||
return index !== lastIndex;
|
||||
}
|
||||
|
||||
if (parent.kind === "retif") {
|
||||
return docShouldHaveTrailingNewline(path, recurse + 1);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
function lineShouldEndWithSemicolon(path) {
|
||||
const { node, parent: parentNode } = path;
|
||||
if (!parentNode) {
|
||||
return false;
|
||||
}
|
||||
// for single line control structures written in a shortform (ie without a block),
|
||||
// we need to make sure the single body node gets a semicolon
|
||||
if (
|
||||
["for", "foreach", "while", "do", "if", "switch"].includes(
|
||||
parentNode.kind
|
||||
) &&
|
||||
node.kind !== "block" &&
|
||||
node.kind !== "if" &&
|
||||
(parentNode.body === node || parentNode.alternate === node)
|
||||
) {
|
||||
return true;
|
||||
}
|
||||
if (!nodeHasStatement(parentNode)) {
|
||||
return false;
|
||||
}
|
||||
if (node.kind === "echo" && node.shortForm) {
|
||||
return false;
|
||||
}
|
||||
if (node.kind === "traituse") {
|
||||
return !node.adaptations;
|
||||
}
|
||||
if (node.kind === "method" && node.isAbstract) {
|
||||
return true;
|
||||
}
|
||||
if (node.kind === "method") {
|
||||
const { parent } = path;
|
||||
if (parent && parent.kind === "interface") {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return [
|
||||
"expressionstatement",
|
||||
"do",
|
||||
"usegroup",
|
||||
"classconstant",
|
||||
"propertystatement",
|
||||
"traitprecedence",
|
||||
"traitalias",
|
||||
"goto",
|
||||
"constantstatement",
|
||||
"enumcase",
|
||||
"global",
|
||||
"static",
|
||||
"echo",
|
||||
"unset",
|
||||
"return",
|
||||
"break",
|
||||
"continue",
|
||||
"throw",
|
||||
].includes(node.kind);
|
||||
}
|
||||
|
||||
function fileShouldEndWithHardline(path) {
|
||||
const { node } = path;
|
||||
const isProgramNode = node.kind === "program";
|
||||
const lastNode = node.children && getLast(node.children);
|
||||
|
||||
if (!isProgramNode) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (lastNode && ["halt", "inline"].includes(lastNode.kind)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (
|
||||
lastNode &&
|
||||
(lastNode.kind === "declare" || lastNode.kind === "namespace")
|
||||
) {
|
||||
const lastNestedNode =
|
||||
lastNode.children.length > 0 && getLast(lastNode.children);
|
||||
|
||||
if (lastNestedNode && ["halt", "inline"].includes(lastNestedNode.kind)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
function maybeStripLeadingSlashFromUse(name) {
|
||||
const nameWithoutLeadingSlash = name.replace(/^\\/, "");
|
||||
if (nameWithoutLeadingSlash.indexOf("\\") !== -1) {
|
||||
return nameWithoutLeadingSlash;
|
||||
}
|
||||
return name;
|
||||
}
|
||||
|
||||
function hasDanglingComments(node) {
|
||||
return (
|
||||
node.comments &&
|
||||
node.comments.some((comment) => !comment.leading && !comment.trailing)
|
||||
);
|
||||
}
|
||||
|
||||
function isLookupNode(node) {
|
||||
return (
|
||||
node.kind === "propertylookup" ||
|
||||
node.kind === "nullsafepropertylookup" ||
|
||||
node.kind === "staticlookup" ||
|
||||
node.kind === "offsetlookup"
|
||||
);
|
||||
}
|
||||
|
||||
function shouldPrintHardLineAfterStartInControlStructure(path) {
|
||||
const { node } = path;
|
||||
|
||||
if (["try", "catch"].includes(node.kind)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return isFirstChildrenInlineNode(path);
|
||||
}
|
||||
|
||||
function shouldPrintHardLineBeforeEndInControlStructure(path) {
|
||||
const { node } = path;
|
||||
|
||||
if (["try", "catch"].includes(node.kind)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (node.kind === "switch") {
|
||||
const children = getNodeListProperty(node.body);
|
||||
|
||||
if (children.length === 0) {
|
||||
return true;
|
||||
}
|
||||
|
||||
const lastCase = getLast(children);
|
||||
|
||||
if (!lastCase.body) {
|
||||
return true;
|
||||
}
|
||||
|
||||
const childrenInCase = getNodeListProperty(lastCase.body);
|
||||
|
||||
if (childrenInCase.length === 0) {
|
||||
return true;
|
||||
}
|
||||
|
||||
return childrenInCase[0].kind !== "inline";
|
||||
}
|
||||
|
||||
return !isFirstChildrenInlineNode(path);
|
||||
}
|
||||
|
||||
function getAlignment(text) {
|
||||
const lines = text.split("\n");
|
||||
const lastLine = lines.pop();
|
||||
|
||||
return lastLine.length - lastLine.trimLeft().length + 1;
|
||||
}
|
||||
|
||||
function isProgramLikeNode(node) {
|
||||
return ["program", "declare", "namespace"].includes(node.kind);
|
||||
}
|
||||
|
||||
function isReferenceLikeNode(node) {
|
||||
return [
|
||||
"name",
|
||||
"parentreference",
|
||||
"selfreference",
|
||||
"staticreference",
|
||||
].includes(node.kind);
|
||||
}
|
||||
|
||||
// Return `logical` value for `bin` node containing `||` or `&&` type otherwise return kind of node.
|
||||
// Require for grouping logical and binary nodes in right way.
|
||||
function getNodeKindIncludingLogical(node) {
|
||||
if (node.kind === "bin" && ["||", "&&"].includes(node.type)) {
|
||||
return "logical";
|
||||
}
|
||||
|
||||
return node.kind;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if string can safely be converted from double to single quotes and vice-versa, i.e.
|
||||
*
|
||||
* - no embedded variables ("foo $bar")
|
||||
* - no linebreaks
|
||||
* - no special characters like \n, \t, ...
|
||||
* - no octal/hex/unicode characters
|
||||
*
|
||||
* See https://php.net/manual/en/language.types.string.php#language.types.string.syntax.double
|
||||
*/
|
||||
function useDoubleQuote(node, options) {
|
||||
if (node.isDoubleQuote === options.singleQuote) {
|
||||
// We have a double quote and the user passed singleQuote:true, or the other way around.
|
||||
const rawValue = node.raw.slice(node.raw[0] === "b" ? 2 : 1, -1);
|
||||
const isComplex = rawValue.match(
|
||||
/\\([$nrtfve]|[xX][0-9a-fA-F]{1,2}|[0-7]{1,3}|u{([0-9a-fA-F]+)})|\r?\n|'|"|\$/
|
||||
);
|
||||
return node.isDoubleQuote ? isComplex : !isComplex;
|
||||
}
|
||||
return node.isDoubleQuote;
|
||||
}
|
||||
|
||||
function hasEmptyBody(path, name = "body") {
|
||||
const { node } = path;
|
||||
|
||||
return (
|
||||
node[name] &&
|
||||
node[name].children &&
|
||||
node[name].children.length === 0 &&
|
||||
(!node[name].comments || node[name].comments.length === 0)
|
||||
);
|
||||
}
|
||||
|
||||
function isNextLineEmptyAfterNamespace(text, node) {
|
||||
let idx = locStart(node);
|
||||
idx = skipEverythingButNewLine(text, idx);
|
||||
idx = skipNewline(text, idx);
|
||||
return hasNewline(text, idx);
|
||||
}
|
||||
|
||||
function shouldPrintHardlineBeforeTrailingComma(lastElem) {
|
||||
if (
|
||||
lastElem.kind === "nowdoc" ||
|
||||
(lastElem.kind === "encapsed" && lastElem.type === "heredoc")
|
||||
) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (
|
||||
lastElem.kind === "entry" &&
|
||||
(lastElem.value.kind === "nowdoc" ||
|
||||
(lastElem.value.kind === "encapsed" && lastElem.value.type === "heredoc"))
|
||||
) {
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
function getAncestorCounter(path, typeOrTypes) {
|
||||
const types = [].concat(typeOrTypes);
|
||||
let counter = -1;
|
||||
let ancestorNode;
|
||||
while ((ancestorNode = path.getParentNode(++counter))) {
|
||||
if (types.indexOf(ancestorNode.kind) !== -1) {
|
||||
return counter;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
function getAncestorNode(path, typeOrTypes) {
|
||||
const counter = getAncestorCounter(path, typeOrTypes);
|
||||
return counter === -1 ? null : path.getParentNode(counter);
|
||||
}
|
||||
|
||||
const magicMethods = [
|
||||
"__construct",
|
||||
"__destruct",
|
||||
"__call",
|
||||
"__callStatic",
|
||||
"__get",
|
||||
"__set",
|
||||
"__isset",
|
||||
"__unset",
|
||||
"__sleep",
|
||||
"__wakeup",
|
||||
"__toString",
|
||||
"__invoke",
|
||||
"__set_state",
|
||||
"__clone",
|
||||
"__debugInfo",
|
||||
];
|
||||
const magicMethodsMap = new Map(
|
||||
magicMethods.map((name) => [name.toLowerCase(), name])
|
||||
);
|
||||
|
||||
function normalizeMagicMethodName(name) {
|
||||
const loweredName = name.toLowerCase();
|
||||
|
||||
if (magicMethodsMap.has(loweredName)) {
|
||||
return magicMethodsMap.get(loweredName);
|
||||
}
|
||||
|
||||
return name;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {string[]} kindsArray
|
||||
* @returns {(node: Node | Comment) => Boolean}
|
||||
*/
|
||||
function createTypeCheckFunction(kindsArray) {
|
||||
const kinds = new Set(kindsArray);
|
||||
return (node) => kinds.has(node?.kind);
|
||||
}
|
||||
|
||||
const isSingleWordType = createTypeCheckFunction([
|
||||
"variadicplaceholder",
|
||||
"namedargument",
|
||||
"nullkeyword",
|
||||
"identifier",
|
||||
"parameter",
|
||||
"variable",
|
||||
"variadic",
|
||||
"boolean",
|
||||
"literal",
|
||||
"number",
|
||||
"string",
|
||||
"clone",
|
||||
"cast",
|
||||
]);
|
||||
|
||||
const isArrayExpression = createTypeCheckFunction(["array"]);
|
||||
const isCallLikeExpression = createTypeCheckFunction([
|
||||
"nullsafepropertylookup",
|
||||
"propertylookup",
|
||||
"staticlookup",
|
||||
"offsetlookup",
|
||||
"call",
|
||||
"new",
|
||||
]);
|
||||
const isArrowFuncExpression = createTypeCheckFunction(["arrowfunc"]);
|
||||
|
||||
function getChainParts(node, prev = []) {
|
||||
const parts = prev;
|
||||
if (isCallLikeExpression(node)) {
|
||||
parts.push(node);
|
||||
}
|
||||
|
||||
if (!node.what) {
|
||||
return parts;
|
||||
}
|
||||
|
||||
return getChainParts(node.what, parts);
|
||||
}
|
||||
|
||||
function isSimpleCallArgument(node, depth = 2) {
|
||||
if (depth <= 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const isChildSimple = (child) => isSimpleCallArgument(child, depth - 1);
|
||||
|
||||
if (isSingleWordType(node)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (isArrayExpression(node)) {
|
||||
return node.items.every((x) => x === null || isChildSimple(x));
|
||||
}
|
||||
|
||||
if (isCallLikeExpression(node)) {
|
||||
const parts = getChainParts(node);
|
||||
parts.unshift();
|
||||
|
||||
return (
|
||||
parts.length <= depth &&
|
||||
parts.every((node) =>
|
||||
isLookupNode(node)
|
||||
? isChildSimple(node.offset)
|
||||
: node.arguments.every(isChildSimple)
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
if (isArrowFuncExpression(node)) {
|
||||
return (
|
||||
node.arguments.length <= depth && node.arguments.every(isChildSimple)
|
||||
);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
function memoize(fn) {
|
||||
const cache = new Map();
|
||||
return (key) => {
|
||||
if (!cache.has(key)) {
|
||||
cache.set(key, fn(key));
|
||||
}
|
||||
return cache.get(key);
|
||||
};
|
||||
}
|
||||
|
||||
export {
|
||||
printNumber,
|
||||
getPrecedence,
|
||||
isBitwiseOperator,
|
||||
shouldFlatten,
|
||||
nodeHasStatement,
|
||||
getLast,
|
||||
getPenultimate,
|
||||
getBodyFirstChild,
|
||||
lineShouldEndWithSemicolon,
|
||||
fileShouldEndWithHardline,
|
||||
maybeStripLeadingSlashFromUse,
|
||||
hasDanglingComments,
|
||||
docShouldHaveTrailingNewline,
|
||||
isLookupNode,
|
||||
isFirstChildrenInlineNode,
|
||||
shouldPrintHardLineAfterStartInControlStructure,
|
||||
shouldPrintHardLineBeforeEndInControlStructure,
|
||||
getAlignment,
|
||||
isProgramLikeNode,
|
||||
isReferenceLikeNode,
|
||||
getNodeKindIncludingLogical,
|
||||
useDoubleQuote,
|
||||
hasEmptyBody,
|
||||
isNextLineEmptyAfterNamespace,
|
||||
shouldPrintHardlineBeforeTrailingComma,
|
||||
isDocNode,
|
||||
getAncestorNode,
|
||||
normalizeMagicMethodName,
|
||||
isSimpleCallArgument,
|
||||
memoize,
|
||||
};
|
||||
824
frontend/src/common/prettier/plugins/rust/format/comments.ts
Normal file
824
frontend/src/common/prettier/plugins/rust/format/comments.ts
Normal file
@@ -0,0 +1,824 @@
|
||||
import { CommentOrDocComment, LocArray, Node, NodeType, NodeWithBodyOrCases } from "jinx-rust";
|
||||
import {
|
||||
end,
|
||||
getBodyOrCases,
|
||||
getLastParameter,
|
||||
hasOuterAttributes,
|
||||
isInner,
|
||||
is_Attribute,
|
||||
is_AttributeOrDocComment,
|
||||
is_BlockCommentKind,
|
||||
is_BlockCommentNode,
|
||||
is_Comment,
|
||||
is_CommentOrDocComment,
|
||||
is_ExpressionWithBodyOrCases,
|
||||
is_ExternSpecifier,
|
||||
is_FlowControlExpression,
|
||||
is_FunctionDeclaration,
|
||||
is_FunctionNode,
|
||||
is_IfBlockExpression,
|
||||
is_LineCommentKind,
|
||||
is_LineCommentNode,
|
||||
is_LocArray,
|
||||
is_MacroRule,
|
||||
is_NodeWithBodyOrCases,
|
||||
is_ReassignmentNode,
|
||||
is_StatementNode,
|
||||
is_StructLiteralProperty,
|
||||
is_StructLiteralPropertySpread,
|
||||
nisAnyOf,
|
||||
ownStart,
|
||||
start,
|
||||
} from "jinx-rust/utils";
|
||||
import { is_CallExpression_or_CallLikeMacroInvocation } from "../transform";
|
||||
import { Narrow, assert, exit, iLast, last_of, maybe_last_of } from "../utils/common";
|
||||
import { is_MemberAccessLike, is_xVariableEqualishLike } from "./core";
|
||||
import {
|
||||
AnyComment,
|
||||
CustomOptions,
|
||||
DCM,
|
||||
Doc,
|
||||
MutatedAttribute,
|
||||
NodeWithComments,
|
||||
PrettierCommentInfo,
|
||||
breakParent,
|
||||
cursor,
|
||||
hardline,
|
||||
indent,
|
||||
join,
|
||||
line,
|
||||
lineSuffix,
|
||||
literalline,
|
||||
} from "./external";
|
||||
import { assertPathAtNode, canAttachComment, getAllComments, getContext, getNode, getOptions, pathCallEach } from "./plugin";
|
||||
import { shouldPrintOuterAttributesAbove } from "./styling";
|
||||
|
||||
function addCommentHelper(node: Node, comment: AnyComment, leading = false, trailing = false) {
|
||||
__DEV__: assert(!handled(comment));
|
||||
((node as NodeWithComments<Node>).comments ??= []).push(comment);
|
||||
(comment.leading = leading), (comment.trailing = trailing), (comment.printed = false);
|
||||
}
|
||||
|
||||
function addLeadingComment(node: Node, comment: AnyComment) {
|
||||
addCommentHelper(node, comment, true);
|
||||
}
|
||||
function addDanglingComment(node: Node, comment: AnyComment, marker: DCM) {
|
||||
addCommentHelper(node, comment);
|
||||
comment.marker = marker;
|
||||
}
|
||||
function addTrailingComment(node: Node, comment: AnyComment) {
|
||||
addCommentHelper(node, comment, false, true);
|
||||
}
|
||||
export function setPrettierIgnoreTarget(node: Node, comment: AnyComment) {
|
||||
__DEV__: Narrow<Node & { prettierIgnore?: true }>(node), assert(isPrettierIgnoreComment(comment) || isPrettierIgnoreAttribute(comment));
|
||||
comment.unignore = true;
|
||||
node.prettierIgnore = true;
|
||||
}
|
||||
|
||||
function hasComments<T extends Node>(node: T): node is NodeWithComments<T> {
|
||||
return "comments" in node && node.comments.length > 0;
|
||||
}
|
||||
|
||||
export function printDanglingComments(enclosingNode: Node, sameIndent: boolean, marker?: DCM) {
|
||||
if (hasComments(enclosingNode)) {
|
||||
const printed: Doc[] = [];
|
||||
pathCallEach(enclosingNode, "comments", (comment) => {
|
||||
if (isDangling(comment) && (!marker || comment.marker === marker)) {
|
||||
printed.push(printComment(comment));
|
||||
}
|
||||
});
|
||||
if (printed.length > 0) {
|
||||
return sameIndent //
|
||||
? join(hardline, printed)
|
||||
: indent([hardline, join(hardline, printed)]);
|
||||
}
|
||||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
export function needsHardlineAfterDanglingComment(node: Node) {
|
||||
if (!hasComment(node)) return false;
|
||||
const lastDanglingComment = maybe_last_of(getComments(node, CF.Dangling));
|
||||
return lastDanglingComment && is_LineCommentNode(lastDanglingComment);
|
||||
}
|
||||
export function setDidPrintComment(comment: AnyComment) {
|
||||
comment.printed = true;
|
||||
}
|
||||
|
||||
function printComment(comment: AnyComment) {
|
||||
__DEV__: assertPathAtNode("printComment", comment);
|
||||
__DEV__: assert(handled(comment), `Assertion failed: Comment was not printed at ${comment.loc.url()}`, comment);
|
||||
setDidPrintComment(comment);
|
||||
return getContext().options.printer.printComment!(getContext().path as any, getOptions());
|
||||
}
|
||||
|
||||
export function isPreviousLineEmpty(node: Node) {
|
||||
let index = start(node) - 1;
|
||||
index = skipSpaces(index, true) as number;
|
||||
index = skipNewline(index, true) as number;
|
||||
index = skipSpaces(index, true) as number;
|
||||
return index !== skipNewline(index, true);
|
||||
}
|
||||
export function hasBreaklineBefore(node: Node) {
|
||||
return hasNewline(start(node) - 1, true);
|
||||
}
|
||||
|
||||
export function hasBreaklineAfter(node: Node) {
|
||||
return hasNewline(end(node));
|
||||
}
|
||||
|
||||
export function printCommentsSeparately(ignored?: Set<AnyComment>) {
|
||||
const node = getNode();
|
||||
__DEV__: Narrow<Node & { comments?: AnyComment[] }>(node);
|
||||
|
||||
const leading: Doc[] = [];
|
||||
const trailing: Doc[] = [];
|
||||
let hasTrailingLineComment = false;
|
||||
let hadLeadingBlockComment = false;
|
||||
|
||||
if ("comments" in node) {
|
||||
pathCallEach(node, "comments", (comment) => {
|
||||
if (ignored?.has(comment)) {
|
||||
return;
|
||||
} else if (isLeading(comment)) {
|
||||
leading.push(printLeadingComment(comment));
|
||||
} else if (isTrailing(comment)) {
|
||||
trailing.push(printTrailingComment(comment));
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
if (node === getOptions().cursorNode) {
|
||||
leading.unshift(cursor);
|
||||
trailing.push(cursor);
|
||||
}
|
||||
|
||||
return (leading.length | trailing.length) > 0 ? { leading, trailing } : ({ leading: "", trailing: "" } as const);
|
||||
|
||||
function printLeadingComment(comment: AnyComment) {
|
||||
if (is_Attribute(comment) && !comment.inner) {
|
||||
const printed = printComment(comment);
|
||||
return [printed, " "];
|
||||
}
|
||||
hadLeadingBlockComment ||= is_BlockCommentKind(comment) && hasBreaklineBefore(comment);
|
||||
return [
|
||||
printComment(comment),
|
||||
is_BlockCommentKind(comment)
|
||||
? hasBreaklineAfter(comment) //
|
||||
? hadLeadingBlockComment
|
||||
? hardline
|
||||
: line
|
||||
: " "
|
||||
: hardline,
|
||||
hasNewline(skipNewline(skipSpaces(end(comment)))) ? hardline : "",
|
||||
];
|
||||
}
|
||||
|
||||
function printTrailingComment(comment: AnyComment) {
|
||||
const printed = printComment(comment);
|
||||
return hasBreaklineBefore(comment)
|
||||
? lineSuffix([hardline, isPreviousLineEmpty(comment) ? hardline : "", printed])
|
||||
: is_BlockCommentNode(comment)
|
||||
? [" ", printed]
|
||||
: lineSuffix([" ", printed, hasTrailingLineComment === (hasTrailingLineComment = true) ? hardline : breakParent]);
|
||||
}
|
||||
}
|
||||
|
||||
export function getPostLeadingComment(comment: AnyComment) {
|
||||
// console.log(comment.loc.url());
|
||||
// is_BlockCommentKind(comment)
|
||||
// ? hasBreaklineAfter(comment) //
|
||||
// ? hasBreaklineBefore(comment)
|
||||
// ? hardline
|
||||
// : line
|
||||
// : " "
|
||||
// : hardline,
|
||||
return hasNewline(skipNewline(skipSpaces(end(comment)))) ? hardline : "";
|
||||
}
|
||||
|
||||
export function withComments<D extends Doc>(node: Node, printed: D, ignored?: Set<AnyComment>): D | Doc[] {
|
||||
__DEV__: assertPathAtNode("withComments", node);
|
||||
const { leading, trailing } = printCommentsSeparately(ignored);
|
||||
return leading || trailing ? [...leading!, printed, ...trailing!] : printed;
|
||||
// return needsOuterParens(node) ? group(["(", indent([softline, parts]), softline, ")"]) : parts;
|
||||
// return parts;
|
||||
}
|
||||
export function getComments(node: Node, ...args: Parameters<typeof getCommentTestFunction>): AnyComment[] {
|
||||
__DEV__: Narrow<Node & { comments?: AnyComment[] }>(node);
|
||||
// if (!node || !node.comments) return [];
|
||||
// if (args.length === 0) return node.comments;
|
||||
// return args.length > 0 ? node.comments.filter(getCommentTestFunction(...args)) : node.comments;
|
||||
return node && node.comments //
|
||||
? args.length > 0
|
||||
? node.comments.filter(getCommentTestFunction(...args))
|
||||
: node.comments
|
||||
: [];
|
||||
}
|
||||
|
||||
export function getFirstComment(node: Node, flags: CF, fn?: (comment: AnyComment) => boolean): AnyComment | undefined {
|
||||
const r = getComments(node, flags | CF.First, fn);
|
||||
return r.length === 0 ? undefined : r[0];
|
||||
}
|
||||
|
||||
export function escapeComments(flags: number, fn?: (comment: AnyComment) => boolean) {
|
||||
const comments = getAllComments().filter(getCommentTestFunction(flags, fn)) as AnyComment[];
|
||||
comments.forEach(setDidPrintComment);
|
||||
return new Set(comments);
|
||||
}
|
||||
|
||||
export const enum CF {
|
||||
Leading = 1 << 1,
|
||||
Trailing = 1 << 2,
|
||||
Dangling = 1 << 3,
|
||||
Block = 1 << 4,
|
||||
Line = 1 << 5,
|
||||
PrettierIgnore = 1 << 6,
|
||||
First = 1 << 7,
|
||||
Last = 1 << 8,
|
||||
}
|
||||
export function isPrettierIgnoreComment(comment: AnyComment) {
|
||||
return is_Comment(comment) && /^\s*prettier-ignore\s*/.test(comment.value) && !comment.unignore;
|
||||
}
|
||||
export function isPrettierIgnoreAttribute(node: Node): node is MutatedAttribute {
|
||||
return is_Attribute(node) && /^\s*rustfmt::skip\s*$/.test(node.value);
|
||||
}
|
||||
function getCommentTestFunction(flags: CF, fn?: (comment: AnyComment) => boolean) {
|
||||
return function (comment: AnyComment, index: number, comments: AnyComment[]) {
|
||||
__DEV__: Narrow<number>(flags), assert(handled(comment));
|
||||
return !(
|
||||
(flags & CF.Leading && !isLeading(comment)) ||
|
||||
(flags & CF.Trailing && !isTrailing(comment)) ||
|
||||
(flags & CF.Dangling && !isDangling(comment)) ||
|
||||
(flags & CF.Block && !is_BlockCommentKind(comment)) ||
|
||||
(flags & CF.Line && !is_LineCommentKind(comment)) ||
|
||||
(flags & CF.First && index !== 0) ||
|
||||
(flags & CF.Last && !iLast(index, comments)) ||
|
||||
(flags & CF.PrettierIgnore && !(isPrettierIgnoreComment(comment) || isPrettierIgnoreAttribute(comment))) ||
|
||||
(fn && !fn(comment))
|
||||
);
|
||||
};
|
||||
}
|
||||
|
||||
export function hasComment(node: Node, flags: number = 0, fn?: (comment: AnyComment) => boolean) {
|
||||
if ("comments" in node && node.comments!.length > 0) {
|
||||
return flags || fn ? (node.comments as AnyComment[]).some(getCommentTestFunction(flags, fn)) : true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
export function hasNewlineInRange(leftIndex: number, rightIndex: number) {
|
||||
__DEV__: assert(leftIndex <= rightIndex);
|
||||
const text = getContext().options.originalText;
|
||||
for (var i = leftIndex; i < rightIndex; ++i) if (text.charCodeAt(i) === 10) return true;
|
||||
return false;
|
||||
}
|
||||
export function isNextLineEmpty(node: Node) {
|
||||
return isNextLineEmptyAfterIndex(end(node));
|
||||
}
|
||||
export function isNextLineEmptyAfterIndex(index: number | false) {
|
||||
let oldIdx: number | false = -1;
|
||||
let idx: number | false = index;
|
||||
while (idx !== oldIdx) {
|
||||
oldIdx = idx;
|
||||
idx = skipToLineEnd(idx);
|
||||
idx = skipBlockComment(idx);
|
||||
idx = skipSpaces(idx);
|
||||
idx = skipParens(idx);
|
||||
}
|
||||
idx = skipLineComment(idx);
|
||||
idx = skipParens(idx);
|
||||
idx = skipNewline(idx);
|
||||
idx = skipParens(idx);
|
||||
return idx !== false && hasNewline(idx);
|
||||
}
|
||||
export function hasNewline(index: number | false, backwards = false) {
|
||||
if (index === false) return false;
|
||||
const i = skipSpaces(index, backwards);
|
||||
return i !== false && i !== skipNewline(i, backwards);
|
||||
}
|
||||
function skipLineComment(index: number | false) {
|
||||
if (index === false) return false;
|
||||
const { commentSpans, originalText } = getContext().options;
|
||||
if (commentSpans.has(index) && originalText.charCodeAt(index + 1) === 47 /** "/" */)
|
||||
return skipEverythingButNewLine(commentSpans.get(index)!);
|
||||
return index;
|
||||
}
|
||||
function skipBlockComment(index: number | false) {
|
||||
if (index === false) return false;
|
||||
const { commentSpans, originalText } = getContext().options;
|
||||
if (commentSpans.has(index) && originalText.charCodeAt(index + 1) === 42 /** "*" */) return commentSpans.get(index)!;
|
||||
return index;
|
||||
}
|
||||
const [skipSpaces, skipToLineEnd, skipEverythingButNewLine] = [/[ \t]/, /[,; \t]/, /[^\r\n]/].map(function (re) {
|
||||
return function (index: number | false, backwards = false) {
|
||||
if (index === false) return false;
|
||||
const { originalText: text } = getContext().options;
|
||||
let cursor = index;
|
||||
while (cursor >= 0 && cursor < text.length) {
|
||||
if (re.test(text.charAt(cursor))) backwards ? cursor-- : cursor++;
|
||||
else return cursor;
|
||||
}
|
||||
return cursor === -1 || cursor === text.length ? cursor : false;
|
||||
};
|
||||
});
|
||||
|
||||
function skipNewline(index: number | false, backwards = false) {
|
||||
if (index === false) return false;
|
||||
const { originalText } = getContext().options;
|
||||
const atIndex = originalText.charCodeAt(index);
|
||||
if (backwards) {
|
||||
if (originalText.charCodeAt(index - 1) === 13 && atIndex === 10) return index - 2;
|
||||
if (atIndex === 10) return index - 1;
|
||||
} else {
|
||||
if (atIndex === 13 && originalText.charCodeAt(index + 1) === 10) return index + 2;
|
||||
if (atIndex === 10) return index + 1;
|
||||
}
|
||||
return index;
|
||||
}
|
||||
|
||||
function skipParens(index: number | false, backwards = false) {
|
||||
return index;
|
||||
// if (index === false) return false;
|
||||
// const { parensPositions } = getContext().options;
|
||||
// while (parensPositions.has(index)) backwards ? index-- : index++;
|
||||
// return index;
|
||||
}
|
||||
|
||||
export function getNextNonSpaceNonCommentCharacterIndex(node: Node) {
|
||||
return getNextNonSpaceNonCommentCharacterIndexWithStartIndex(end(node));
|
||||
}
|
||||
function getNextNonSpaceNonCommentCharacterIndexWithStartIndex(i: number) {
|
||||
let oldIdx = -1;
|
||||
let nextIdx = i;
|
||||
while (nextIdx !== oldIdx) {
|
||||
oldIdx = nextIdx;
|
||||
nextIdx = skipSpaces(nextIdx) as number;
|
||||
nextIdx = skipBlockComment(nextIdx) as number;
|
||||
nextIdx = skipLineComment(nextIdx) as number;
|
||||
nextIdx = skipNewline(nextIdx) as number;
|
||||
nextIdx = skipParens(nextIdx) as number;
|
||||
}
|
||||
return nextIdx;
|
||||
}
|
||||
export function getNextNonSpaceNonCommentCharacter(node: Node) {
|
||||
return getContext().options.originalText.charAt(getNextNonSpaceNonCommentCharacterIndex(node));
|
||||
}
|
||||
|
||||
interface CommentContext {
|
||||
comment: AnyComment;
|
||||
precedingNode: Node | undefined;
|
||||
enclosingNode: Node | undefined;
|
||||
followingNode: Node | undefined;
|
||||
text: string;
|
||||
options: CustomOptions;
|
||||
ast: Node;
|
||||
isLastComment: boolean;
|
||||
}
|
||||
|
||||
function handled(comment: AnyComment) {
|
||||
return "printed" in comment;
|
||||
}
|
||||
function handleCommon(ctx: CommentContext): boolean {
|
||||
{
|
||||
const { comment, precedingNode, enclosingNode, followingNode } = ctx;
|
||||
if (!enclosingNode) {
|
||||
ctx.enclosingNode = ctx.comment.loc.src.program;
|
||||
} else if (enclosingNode && is_NodeWithBodyOrCases(enclosingNode)) {
|
||||
const body = getBodyOrCases(enclosingNode);
|
||||
if (body) {
|
||||
if (is_ExpressionWithBodyOrCases(enclosingNode) && enclosingNode.label) {
|
||||
if (ctx.precedingNode === enclosingNode.label) {
|
||||
ctx.precedingNode = undefined;
|
||||
}
|
||||
if (followingNode === enclosingNode.label) {
|
||||
ctx.followingNode = undefined;
|
||||
}
|
||||
}
|
||||
if (comment.loc.isBefore(body)) {
|
||||
if (followingNode && body.loc.contains(followingNode)) {
|
||||
ctx.followingNode = undefined;
|
||||
}
|
||||
if (!ctx.precedingNode && !ctx.followingNode) {
|
||||
addLeadingComment(enclosingNode, comment);
|
||||
return true;
|
||||
}
|
||||
} else if (comment.loc.isAfter(body)) {
|
||||
if (precedingNode && body.loc.contains(precedingNode)) {
|
||||
ctx.precedingNode = undefined;
|
||||
}
|
||||
if (!ctx.precedingNode && !ctx.followingNode) {
|
||||
addTrailingComment(enclosingNode, comment);
|
||||
return true;
|
||||
}
|
||||
} else if (body.loc.contains(comment)) {
|
||||
if (precedingNode && !body.loc.contains(precedingNode)) {
|
||||
ctx.precedingNode = undefined;
|
||||
}
|
||||
if (followingNode && !body.loc.contains(followingNode)) {
|
||||
ctx.followingNode = undefined;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for (const fn of [
|
||||
handleMixedInOuterAttributeComments,
|
||||
handleAttributeComments,
|
||||
handleDanglingComments,
|
||||
handleFunctionComments,
|
||||
handleMacroRuleComments,
|
||||
handleStructLiteralComments,
|
||||
handleVariableDeclaratorComments,
|
||||
handleIfBlockExpressionComments,
|
||||
handleMemberExpressionComments,
|
||||
handleStatementComments,
|
||||
handleFlowControlComments,
|
||||
handleBadComments,
|
||||
]) {
|
||||
fn(ctx);
|
||||
if (handled(ctx.comment)) {
|
||||
// console.log(ctx.comment.loc.url(), fn.name);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
const { precedingNode, followingNode, comment } = ctx;
|
||||
|
||||
if (isStartOfLine(comment)) {
|
||||
if (followingNode) {
|
||||
addLeadingComment(followingNode, comment);
|
||||
} else if (precedingNode) {
|
||||
addTrailingComment(precedingNode, comment);
|
||||
} else {
|
||||
exit.never(ctx);
|
||||
}
|
||||
} else if (isEndOfLine(comment)) {
|
||||
if (precedingNode) {
|
||||
addTrailingComment(precedingNode, comment);
|
||||
} else if (followingNode) {
|
||||
addLeadingComment(followingNode, comment);
|
||||
} else {
|
||||
exit.never(ctx);
|
||||
}
|
||||
} else {
|
||||
if (precedingNode && followingNode) {
|
||||
return false;
|
||||
} else if (precedingNode) {
|
||||
addTrailingComment(precedingNode, comment);
|
||||
} else if (followingNode) {
|
||||
addLeadingComment(followingNode, comment);
|
||||
} else {
|
||||
exit.never(ctx);
|
||||
}
|
||||
}
|
||||
return handled(ctx.comment);
|
||||
}
|
||||
export function handleOwnLineComment(ctx: CommentContext) {
|
||||
return handleCommon(ctx);
|
||||
}
|
||||
export function handleEndOfLineComment(ctx: CommentContext) {
|
||||
const { precedingNode, enclosingNode, comment } = ctx;
|
||||
if (
|
||||
// handleCallExpressionComments
|
||||
precedingNode &&
|
||||
enclosingNode &&
|
||||
is_CallExpression_or_CallLikeMacroInvocation(enclosingNode) &&
|
||||
enclosingNode.arguments.length > 0 &&
|
||||
precedingNode === (enclosingNode.typeArguments ? last_of(enclosingNode.typeArguments) : enclosingNode.callee)
|
||||
) {
|
||||
addLeadingComment(enclosingNode.arguments[0], comment);
|
||||
return true;
|
||||
} else if (
|
||||
// handlePropertyComments
|
||||
enclosingNode &&
|
||||
is_StructLiteralProperty(enclosingNode)
|
||||
) {
|
||||
addLeadingComment(enclosingNode, comment);
|
||||
return true;
|
||||
} else {
|
||||
return handleCommon(ctx);
|
||||
}
|
||||
}
|
||||
|
||||
export function handleRemainingComment(ctx: CommentContext) {
|
||||
return handleCommon(ctx);
|
||||
}
|
||||
|
||||
function handleStructLiteralComments({ enclosingNode, followingNode, comment }: CommentContext) {
|
||||
if (enclosingNode && is_StructLiteralPropertySpread(enclosingNode) && followingNode === enclosingNode.expression) {
|
||||
addLeadingComment(enclosingNode, comment);
|
||||
}
|
||||
}
|
||||
|
||||
function handleVariableDeclaratorComments({ enclosingNode, followingNode, comment }: CommentContext) {
|
||||
if (
|
||||
enclosingNode &&
|
||||
(is_xVariableEqualishLike(enclosingNode) || is_ReassignmentNode(enclosingNode)) &&
|
||||
followingNode &&
|
||||
(is_BlockCommentKind(comment) ||
|
||||
nisAnyOf(followingNode, [
|
||||
NodeType.StructLiteral,
|
||||
NodeType.StructPattern,
|
||||
NodeType.TupleLiteral,
|
||||
NodeType.TypeTuple,
|
||||
NodeType.TuplePattern,
|
||||
NodeType.ArrayLiteral,
|
||||
NodeType.ArrayPattern,
|
||||
NodeType.SizedArrayLiteral,
|
||||
NodeType.TypeSizedArray,
|
||||
]))
|
||||
) {
|
||||
addLeadingComment(followingNode, comment);
|
||||
}
|
||||
}
|
||||
|
||||
function handleMixedInOuterAttributeComments({ precedingNode, enclosingNode, followingNode, comment }: CommentContext) {
|
||||
if (enclosingNode && hasOuterAttributes(enclosingNode) && end(comment) <= ownStart(enclosingNode)) {
|
||||
if (isPrettierIgnoreComment(comment) || isPrettierIgnoreAttribute(comment)) {
|
||||
setPrettierIgnoreTarget(enclosingNode, comment);
|
||||
}
|
||||
if (isEndOfLine(comment)) {
|
||||
__DEV__: assert(!!precedingNode && is_Attribute(precedingNode), "", precedingNode);
|
||||
if (shouldPrintOuterAttributesAbove(enclosingNode)) {
|
||||
// #[attr] // comment
|
||||
// node
|
||||
addTrailingComment(precedingNode, comment);
|
||||
} else {
|
||||
// #[attr] /* comment */ node
|
||||
addLeadingComment(followingNode || enclosingNode, comment);
|
||||
}
|
||||
} else {
|
||||
// __DEV__: assert(isStartOfLine(comment));
|
||||
if (followingNode && end(followingNode) <= ownStart(enclosingNode)) {
|
||||
addLeadingComment(followingNode, comment);
|
||||
} else if (precedingNode && enclosingNode.loc.contains(precedingNode)) {
|
||||
addTrailingComment(precedingNode, comment);
|
||||
} else {
|
||||
addLeadingComment(enclosingNode, comment);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
function handleAttributeComments({ precedingNode, enclosingNode, followingNode, comment, ast }: CommentContext) {
|
||||
if (is_AttributeOrDocComment(comment)) {
|
||||
if (
|
||||
comment.inner &&
|
||||
enclosingNode &&
|
||||
is_FunctionDeclaration(enclosingNode) &&
|
||||
(!followingNode || !is_StatementNode(followingNode)) &&
|
||||
(!precedingNode || !is_StatementNode(precedingNode))
|
||||
) {
|
||||
if (enclosingNode.body) {
|
||||
if (canAttachCommentInLocArray(enclosingNode.body)) {
|
||||
addDanglingComment(enclosingNode, comment, DCM["body"]);
|
||||
} else {
|
||||
addLeadingComment(enclosingNode.body[0], comment);
|
||||
}
|
||||
} else {
|
||||
addLeadingComment(enclosingNode, comment);
|
||||
}
|
||||
} else {
|
||||
// if (comment.loc.url().startsWith("tests/samples/macro/attr.rs") && getContext().options.danglingAttributes.includes(comment)) {
|
||||
// // debugger;
|
||||
// console.log({
|
||||
// comment: comment.loc.url(),
|
||||
// precedingNode: precedingNode?.loc.url(),
|
||||
// enclosingNode: enclosingNode?.loc.url(),
|
||||
// followingNode: followingNode?.loc.url(),
|
||||
// });
|
||||
// }
|
||||
if (followingNode) {
|
||||
addLeadingComment(followingNode, comment);
|
||||
} else if (enclosingNode) {
|
||||
for (var key in DCM)
|
||||
if (key in enclosingNode) {
|
||||
addDanglingComment(enclosingNode, comment, key as DCM);
|
||||
return;
|
||||
}
|
||||
} else {
|
||||
addDanglingComment(ast, comment, DCM["body"]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function handleBadComments({ precedingNode, enclosingNode, followingNode, ast, comment }: CommentContext) {
|
||||
if (!enclosingNode) {
|
||||
// console.log(comment.loc.url());
|
||||
if (followingNode) {
|
||||
addLeadingComment(followingNode, comment);
|
||||
} else if (precedingNode) {
|
||||
addTrailingComment(precedingNode, comment);
|
||||
} else {
|
||||
addDanglingComment(enclosingNode || ast, comment, DCM["body"]);
|
||||
}
|
||||
} else if (!precedingNode && !followingNode) {
|
||||
if (enclosingNode && enclosingNode !== ast) {
|
||||
addLeadingComment(enclosingNode, comment);
|
||||
} else {
|
||||
addDanglingComment(ast, comment, DCM["body"]);
|
||||
}
|
||||
}
|
||||
}
|
||||
function is_ABI_Comment({ precedingNode, enclosingNode, comment }: CommentContext) {
|
||||
return (
|
||||
is_CommentOrDocComment(comment) &&
|
||||
((precedingNode && is_ExternSpecifier(precedingNode)) || (enclosingNode && is_ExternSpecifier(enclosingNode)))
|
||||
);
|
||||
}
|
||||
function handleFlowControlComments({ precedingNode, enclosingNode, followingNode, comment }: CommentContext) {
|
||||
if (enclosingNode && is_FlowControlExpression(enclosingNode)) {
|
||||
if (!precedingNode && (isOwnLine(comment) || isEndOfLine(comment)) && !followingNode) {
|
||||
addLeadingComment(enclosingNode, comment);
|
||||
}
|
||||
}
|
||||
}
|
||||
function handleFunctionComments(ctx: CommentContext) {
|
||||
const { precedingNode, enclosingNode, followingNode, comment } = ctx;
|
||||
if (enclosingNode && is_FunctionNode(enclosingNode)) {
|
||||
if (
|
||||
is_FunctionDeclaration(enclosingNode) &&
|
||||
((!is_ABI_Comment(ctx) && comment.loc.isBefore(enclosingNode.generics || enclosingNode.id)) ||
|
||||
(enclosingNode.generics && comment.loc.isBetween(enclosingNode.generics, enclosingNode.parameters)))
|
||||
) {
|
||||
addLeadingComment(enclosingNode, comment);
|
||||
} else if (
|
||||
!enclosingNode.returnType &&
|
||||
comment.loc.isBetween(
|
||||
enclosingNode.parameters,
|
||||
is_FunctionDeclaration(enclosingNode) ? enclosingNode.body! : enclosingNode.expression
|
||||
)
|
||||
) {
|
||||
if (is_FunctionDeclaration(enclosingNode)) {
|
||||
addCommentToBlock(enclosingNode, comment);
|
||||
} else {
|
||||
addLeadingComment(enclosingNode.expression, comment);
|
||||
}
|
||||
} else if (
|
||||
precedingNode && //
|
||||
enclosingNode.parameters.loc.contains(comment)
|
||||
) {
|
||||
if (precedingNode === getLastParameter(enclosingNode)) {
|
||||
addTrailingComment(precedingNode, comment);
|
||||
}
|
||||
} else if (
|
||||
followingNode &&
|
||||
isStartOfLine(comment) &&
|
||||
comment.loc.isAfter(enclosingNode.parameters) &&
|
||||
(!is_FunctionDeclaration(enclosingNode) || !enclosingNode.whereBounds || comment.loc.isAfter(enclosingNode.whereBounds!)) &&
|
||||
(!enclosingNode.returnType || comment.loc.isAfter(enclosingNode.returnType)) &&
|
||||
followingNode === (is_FunctionDeclaration(enclosingNode) ? enclosingNode.body?.[0] : enclosingNode.expression)
|
||||
) {
|
||||
addLeadingComment(followingNode, comment);
|
||||
}
|
||||
}
|
||||
}
|
||||
function handleMacroRuleComments(ctx: CommentContext) {
|
||||
const { precedingNode, enclosingNode, followingNode, comment } = ctx;
|
||||
if (enclosingNode && is_MacroRule(enclosingNode)) {
|
||||
if (enclosingNode.transform.loc.contains(comment)) {
|
||||
__DEV__: assert(enclosingNode.transform.length > 0);
|
||||
if (!precedingNode || !enclosingNode.transform.loc.contains(precedingNode)) {
|
||||
__DEV__: assert(!!followingNode && enclosingNode.transform.loc.contains(followingNode));
|
||||
addLeadingComment(followingNode, comment);
|
||||
}
|
||||
} else if (enclosingNode.match.loc.contains(comment)) {
|
||||
__DEV__: assert(enclosingNode.match.length > 0);
|
||||
if (!followingNode || !enclosingNode.match.loc.contains(followingNode)) {
|
||||
__DEV__: assert(!!precedingNode && enclosingNode.match.loc.contains(precedingNode));
|
||||
addTrailingComment(precedingNode!, comment);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function handleStatementComments(ctx: CommentContext) {
|
||||
const { precedingNode, comment } = ctx;
|
||||
if (isEndOfLine(comment) && precedingNode && (is_StatementNode(precedingNode) || precedingNode.loc.sliceText().endsWith(";"))) {
|
||||
addTrailingComment(precedingNode, comment);
|
||||
}
|
||||
}
|
||||
|
||||
function addCommentToBlock(block: NodeWithBodyOrCases, comment: AnyComment) {
|
||||
const body = getBodyOrCases(block);
|
||||
__DEV__: assert(!!body);
|
||||
if (body.length > 0) {
|
||||
addLeadingComment(body![0], comment);
|
||||
} else {
|
||||
addDanglingComment(block, comment, DCM["body"]);
|
||||
}
|
||||
}
|
||||
|
||||
function handleIfBlockExpressionComments(ctx: CommentContext) {
|
||||
const { comment, enclosingNode } = ctx;
|
||||
if (enclosingNode && is_IfBlockExpression(enclosingNode)) {
|
||||
const { condition, body, else: else_ } = enclosingNode;
|
||||
if (comment.loc.isBefore(condition)) {
|
||||
addLeadingComment(condition, comment);
|
||||
} else if (comment.loc.isBetween(condition, body)) {
|
||||
addTrailingComment(condition, comment);
|
||||
} else if (else_ && comment.loc.isBetween(body, else_)) {
|
||||
if (is_IfBlockExpression(else_)) {
|
||||
addLeadingComment(else_.condition, comment);
|
||||
} else {
|
||||
addCommentToBlock(else_, comment);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function handleMemberExpressionComments({ comment, precedingNode, enclosingNode }: CommentContext) {
|
||||
if (enclosingNode && is_MemberAccessLike(enclosingNode)) {
|
||||
if (isStartOfLine(comment) || !precedingNode) addLeadingComment(enclosingNode, comment);
|
||||
else addTrailingComment(precedingNode, comment);
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
function handleDanglingComments({ comment, enclosingNode }: CommentContext) {
|
||||
if (enclosingNode) {
|
||||
for (var key in DCM) {
|
||||
if (key in enclosingNode) {
|
||||
var arr: LocArray = enclosingNode[key];
|
||||
if (is_LocArray(arr) && canAttachCommentInLocArray(arr) && arr.loc.contains(comment)) {
|
||||
addDanglingComment(enclosingNode, comment, key as DCM);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function canAttachCommentInLocArray(arr: LocArray) {
|
||||
return arr.length === 0 || arr.every((node) => !canAttachComment(node));
|
||||
}
|
||||
|
||||
function isOwnLine(comment: AnyComment) {
|
||||
return isStartOfLine(comment) && hasBreaklineAfter(comment);
|
||||
}
|
||||
function isStartOfLine(comment: AnyComment) {
|
||||
return comment.placement === "ownLine";
|
||||
}
|
||||
function isEndOfLine(comment: AnyComment) {
|
||||
return comment.placement === "endOfLine";
|
||||
}
|
||||
export function isDangling(comment: AnyComment) {
|
||||
__DEV__: assert(handled(comment));
|
||||
return !comment.leading && !comment.trailing;
|
||||
}
|
||||
export function isLeading(comment: AnyComment) {
|
||||
__DEV__: assert(handled(comment));
|
||||
return comment.leading && !comment.trailing;
|
||||
}
|
||||
export function isTrailing(comment: AnyComment) {
|
||||
__DEV__: assert(handled(comment));
|
||||
return !comment.leading && comment.trailing;
|
||||
}
|
||||
|
||||
export function print_comment(comment: CommentOrDocComment) {
|
||||
__DEV__: Narrow<PrettierCommentInfo>(comment);
|
||||
|
||||
const doc = is_BlockCommentNode(comment)
|
||||
? isIndentableBlockComment(comment.value)
|
||||
? [
|
||||
(!handled(comment) || isTrailing(comment)) && !hasBreaklineBefore(comment) ? hardline : "",
|
||||
getCommentStart(comment),
|
||||
...comment.value.split(/\n/g).map((line, i, a) =>
|
||||
i === 0 //
|
||||
? [line.trimEnd(), hardline]
|
||||
: !iLast(i, a)
|
||||
? [" " + line.trim(), hardline]
|
||||
: " " + line.trimStart()
|
||||
),
|
||||
"*/",
|
||||
]
|
||||
: [
|
||||
getCommentStart(comment), //
|
||||
join(literalline, comment.value.split(/\n/g)),
|
||||
"*/",
|
||||
]
|
||||
: [getCommentStart(comment), comment.value.trimEnd()];
|
||||
|
||||
return handled(comment) && isDangling(comment) //
|
||||
? [doc, getPostLeadingComment(comment)]
|
||||
: doc;
|
||||
|
||||
function getCommentStart(comment: CommentOrDocComment) {
|
||||
return is_Comment(comment)
|
||||
? is_BlockCommentKind(comment)
|
||||
? "/*"
|
||||
: "//"
|
||||
: is_BlockCommentKind(comment)
|
||||
? isInner(comment)
|
||||
? "/*!"
|
||||
: "/**"
|
||||
: isInner(comment)
|
||||
? "//!"
|
||||
: "///";
|
||||
}
|
||||
function isIndentableBlockComment(value: string) {
|
||||
const lines = `*${value}*`.split(/\n/g);
|
||||
return lines.length > 1 && lines.every((line) => /^\s*\*/.test(line));
|
||||
}
|
||||
}
|
||||
282
frontend/src/common/prettier/plugins/rust/format/complexity.ts
Normal file
282
frontend/src/common/prettier/plugins/rust/format/complexity.ts
Normal file
@@ -0,0 +1,282 @@
|
||||
import {
|
||||
ForLtParametersBody,
|
||||
FunctionSpread,
|
||||
GenericParameterDeclaration,
|
||||
MaybeGenericArgsTarget,
|
||||
MissingNode,
|
||||
Node,
|
||||
NodeType,
|
||||
TypeBound,
|
||||
TypeBoundsConstaint,
|
||||
TypeCallArgument,
|
||||
TypeNamespaceTargetNoSelector,
|
||||
TypeNode,
|
||||
} from "jinx-rust";
|
||||
import {
|
||||
getAstPath,
|
||||
getOwnChildAstPath,
|
||||
is_BareTypeTraitBound,
|
||||
is_FunctionSpread,
|
||||
is_LetScrutinee,
|
||||
is_Literal,
|
||||
is_MissingNode,
|
||||
is_TypeBoundsStandaloneNode,
|
||||
is_TypeFunctionNode,
|
||||
is_TypeNode,
|
||||
is_VariableDeclarationNode,
|
||||
} from "jinx-rust/utils";
|
||||
import { exit, has_key_defined, last_of, spliceAll } from "../utils/common";
|
||||
import { canBreak } from "./external";
|
||||
import { getContext, getNode, getOptions, getPrintFn } from "./plugin";
|
||||
|
||||
let DEPTH = 0;
|
||||
const ANCESTRY: Node[] = [];
|
||||
const LONE_SHORT_ARGUMENT_THRESHOLD_RATE = 0.25;
|
||||
|
||||
export function withCheckContext<R>(fn: () => R): R {
|
||||
if (0 === DEPTH) {
|
||||
return fn();
|
||||
} else {
|
||||
DEPTH = 0;
|
||||
const prev = spliceAll(ANCESTRY);
|
||||
try {
|
||||
return fn();
|
||||
} finally {
|
||||
DEPTH = ANCESTRY.push(...prev);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export function is_short(str: string) {
|
||||
return str.length <= LONE_SHORT_ARGUMENT_THRESHOLD_RATE * getOptions().printWidth;
|
||||
}
|
||||
function print(target: Node) {
|
||||
const current = getNode();
|
||||
const keys: (string | number)[] = [...getAstPath(ANCESTRY[0], getNode())];
|
||||
for (let i = 1; i < ANCESTRY.length; i++) keys.push(...getOwnChildAstPath(ANCESTRY[i - 1], ANCESTRY[i]));
|
||||
keys.push(...getOwnChildAstPath(last_of(ANCESTRY), target));
|
||||
try {
|
||||
return getContext().path.call(() => getPrintFn(target)(), ...keys);
|
||||
} catch (e) {
|
||||
console.log({ current, target, keys, ANCESTRY });
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
|
||||
function IsSimpleFunction<T extends Node>(fn: (node: T) => boolean): (node: T) => boolean {
|
||||
return function (node: T) {
|
||||
if (0 !== DEPTH && node === ANCESTRY[DEPTH - 1]) {
|
||||
return fn(node);
|
||||
}
|
||||
|
||||
if (DEPTH >= 2) {
|
||||
return isShortBasic(node);
|
||||
}
|
||||
|
||||
try {
|
||||
return fn((ANCESTRY[DEPTH++] = node) as any);
|
||||
} finally {
|
||||
ANCESTRY.length = --DEPTH;
|
||||
}
|
||||
} as any;
|
||||
}
|
||||
|
||||
function HasComplexFunction<T extends Node>(fn: (node: T) => boolean): (node: T) => boolean {
|
||||
return function (node: T) {
|
||||
if (0 !== DEPTH && node === ANCESTRY[DEPTH - 1]) {
|
||||
return fn(node);
|
||||
}
|
||||
|
||||
if (DEPTH >= 2) {
|
||||
return !isShortBasic(node);
|
||||
}
|
||||
|
||||
try {
|
||||
return fn((ANCESTRY[DEPTH++] = node) as any);
|
||||
} finally {
|
||||
ANCESTRY.length = --DEPTH;
|
||||
}
|
||||
} as any;
|
||||
}
|
||||
|
||||
const isShortBasic = (node: Node) => {
|
||||
switch (node.nodeType) {
|
||||
case NodeType.MissingNode:
|
||||
return true;
|
||||
case NodeType.Identifier:
|
||||
case NodeType.Index:
|
||||
case NodeType.LtIdentifier:
|
||||
case NodeType.LbIdentifier:
|
||||
case NodeType.McIdentifier:
|
||||
return is_short(node.name);
|
||||
case NodeType.Literal:
|
||||
return is_short(node.value) && !/\n/.test(node.value);
|
||||
}
|
||||
return false;
|
||||
};
|
||||
|
||||
export const isSimpleType = IsSimpleFunction<FunctionSpread | TypeNode | MissingNode>((node): boolean => {
|
||||
switch (node.nodeType) {
|
||||
case NodeType.MissingNode:
|
||||
case NodeType.FunctionSpread:
|
||||
return true;
|
||||
case NodeType.MacroInvocation:
|
||||
return false;
|
||||
case NodeType.Identifier:
|
||||
case NodeType.TypeNever:
|
||||
case NodeType.TypeInferred:
|
||||
return true;
|
||||
case NodeType.TypePath:
|
||||
return isShortBasic(node.segment) && (!node.namespace || isSimpleType(node.namespace));
|
||||
case NodeType.TypeCall:
|
||||
return isSimpleType(node.typeCallee) && !hasComplexTypeArguments(node);
|
||||
case NodeType.ExpressionTypeSelector:
|
||||
return isSimpleType(node.typeTarget) && (!node.typeExpression || isSimpleType(node.typeExpression));
|
||||
case NodeType.TypeDynBounds:
|
||||
return !hasComplexTypeBounds(node);
|
||||
case NodeType.TypeImplBounds:
|
||||
return !hasComplexTypeBounds(node);
|
||||
case NodeType.TypeFnPointer: {
|
||||
const param = node.parameters[0];
|
||||
return (
|
||||
(!node.extern || !node.extern.abi || isShortBasic(node.extern.abi)) &&
|
||||
!hasComplexLtParameters(node) &&
|
||||
(node.parameters.length === 0 ||
|
||||
(node.parameters.length === 1 &&
|
||||
(is_FunctionSpread(param) ||
|
||||
(!is_TypeFunctionNode(param.typeAnnotation) && isSimpleType(param.typeAnnotation))))) &&
|
||||
(!node.returnType || isSimpleType(node.returnType))
|
||||
);
|
||||
}
|
||||
case NodeType.TypeFunction:
|
||||
return isSimpleType(node.callee) && node.parameters.every(isSimpleType) && (!node.returnType || isSimpleType(node.returnType));
|
||||
case NodeType.TypeSizedArray:
|
||||
return isSimpleType(node.typeExpression) && isShortBasic(node.sizeExpression);
|
||||
case NodeType.TypeSlice:
|
||||
return isSimpleType(node.typeExpression);
|
||||
case NodeType.TypeTuple:
|
||||
return node.items.length === 0 || (node.items.length === 1 && isSimpleType(node.items[0]));
|
||||
case NodeType.TypeReference:
|
||||
case NodeType.TypeDereferenceMut:
|
||||
case NodeType.TypeDereferenceConst:
|
||||
case NodeType.TypeParenthesized:
|
||||
return isSimpleType(node.typeExpression);
|
||||
default:
|
||||
__DEV__: exit.never(node);
|
||||
return false;
|
||||
}
|
||||
});
|
||||
|
||||
export const hasComplexTypeBounds = HasComplexFunction<Extract<Node, TypeBoundsConstaint>>((node) => {
|
||||
return !!node.typeBounds && node.typeBounds.length > 1 && !node.typeBounds.every(isSimpleTypeBound);
|
||||
});
|
||||
|
||||
export const isSimpleTypeBound = (node: TypeBound): boolean => {
|
||||
switch (node.nodeType) {
|
||||
case NodeType.TypeParenthesized:
|
||||
return isSimpleTypeBound(node.typeExpression);
|
||||
// #Lifetime
|
||||
case NodeType.LtIdentifier:
|
||||
case NodeType.LtElided:
|
||||
case NodeType.LtStatic:
|
||||
return true;
|
||||
case NodeType.TypeTraitBound:
|
||||
return is_BareTypeTraitBound(node) && isSimpleTypeNamespaceTargetNoSelector(node.typeExpression);
|
||||
default:
|
||||
__DEV__: exit.never(node);
|
||||
return false;
|
||||
}
|
||||
function isSimpleTypeNamespaceTargetNoSelector(node: TypeNamespaceTargetNoSelector): boolean {
|
||||
switch (node.nodeType) {
|
||||
case NodeType.Identifier:
|
||||
return true;
|
||||
case NodeType.TypePath:
|
||||
return undefined === node.namespace || isSimpleTypeNamespaceTargetNoSelector(node.namespace);
|
||||
case NodeType.TypeCall:
|
||||
return false;
|
||||
case NodeType.TypeFunction:
|
||||
return isSimpleTypeNamespaceTargetNoSelector(node.callee) && node.parameters.length === 0 && !node.returnType;
|
||||
default:
|
||||
__DEV__: exit.never(node);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
const isSimpleTypeArgument = IsSimpleFunction<TypeCallArgument>((node) => {
|
||||
if (is_TypeNode(node)) {
|
||||
return isSimpleType(node);
|
||||
}
|
||||
switch (node.nodeType) {
|
||||
// #Lifetime
|
||||
case NodeType.LtIdentifier:
|
||||
case NodeType.LtElided:
|
||||
case NodeType.LtStatic:
|
||||
case NodeType.Literal:
|
||||
return true;
|
||||
case NodeType.MinusExpression:
|
||||
return is_Literal(node.expression);
|
||||
case NodeType.BlockExpression:
|
||||
return false; //willBreak(getPrintFn(node)("body"));
|
||||
case NodeType.TypeCallNamedArgument:
|
||||
return isSimpleType(node.typeExpression);
|
||||
case NodeType.TypeCallNamedBound:
|
||||
return isSimpleType(node.typeTarget) && !hasComplexTypeBounds(node);
|
||||
default:
|
||||
__DEV__: exit.never(node);
|
||||
return false;
|
||||
}
|
||||
});
|
||||
|
||||
export const hasComplexTypeArguments = HasComplexFunction<Extract<Node, MaybeGenericArgsTarget>>((node) =>
|
||||
!node.typeArguments || node.typeArguments.length === 0
|
||||
? false
|
||||
: node.typeArguments.length === 1
|
||||
? (() => {
|
||||
const arg = node.typeArguments[0];
|
||||
return is_TypeBoundsStandaloneNode(arg) || canBreak(print(arg));
|
||||
})()
|
||||
: true
|
||||
);
|
||||
|
||||
export const hasComplexLtParameters = HasComplexFunction<Extract<Node, ForLtParametersBody>>((node) => {
|
||||
const ltParameters = node.ltParameters;
|
||||
if (!ltParameters || ltParameters.length === 0) {
|
||||
return false;
|
||||
}
|
||||
if (ltParameters.length === 1) {
|
||||
const arg = ltParameters[0];
|
||||
if (arg.ltBounds && arg.ltBounds.length > 1) {
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
});
|
||||
|
||||
export const isShortGenericParameterDeclaration = IsSimpleFunction<GenericParameterDeclaration>((node) => {
|
||||
switch (node.nodeType) {
|
||||
case NodeType.GenericTypeParameterDeclaration:
|
||||
return !node.typeBounds && !node.typeDefault;
|
||||
case NodeType.ConstTypeParameterDeclaration:
|
||||
return (!node.typeAnnotation || is_MissingNode(node)) && !node.typeDefault;
|
||||
case NodeType.GenericLtParameterDeclaration:
|
||||
return !node.ltBounds;
|
||||
default:
|
||||
exit.never();
|
||||
}
|
||||
});
|
||||
|
||||
export const hasComplexGenerics = HasComplexFunction<Node>((node) => {
|
||||
return has_key_defined(node, "generics") && node.generics.length > 0 && !node.generics.every(isShortGenericParameterDeclaration);
|
||||
});
|
||||
|
||||
export const hasComplexTypeAnnotation = HasComplexFunction<Node>((node) => {
|
||||
if (is_VariableDeclarationNode(node) && !is_LetScrutinee(node)) {
|
||||
const { typeAnnotation } = node;
|
||||
return !!typeAnnotation && !is_MissingNode(typeAnnotation) && !isSimpleType(typeAnnotation);
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
});
|
||||
2349
frontend/src/common/prettier/plugins/rust/format/core.ts
Normal file
2349
frontend/src/common/prettier/plugins/rust/format/core.ts
Normal file
File diff suppressed because it is too large
Load Diff
126
frontend/src/common/prettier/plugins/rust/format/external.ts
Normal file
126
frontend/src/common/prettier/plugins/rust/format/external.ts
Normal file
@@ -0,0 +1,126 @@
|
||||
import { Attribute, AttributeOrDocComment, Comment, DocCommentAttribute, LocArray, MemberExpression, Node, SourceFile } from "jinx-rust";
|
||||
import { PickProps } from "jinx-rust/utils";
|
||||
import type { Doc, ParserOptions, Printer } from "prettier";
|
||||
import { doc } from "prettier";
|
||||
import { AssertTypesEq } from "../utils/common";
|
||||
|
||||
export type { Doc, ParserOptions, Plugin, Printer } from "prettier";
|
||||
|
||||
|
||||
export const {
|
||||
join,
|
||||
line,
|
||||
softline,
|
||||
hardline,
|
||||
literalline,
|
||||
group,
|
||||
conditionalGroup,
|
||||
fill,
|
||||
lineSuffix,
|
||||
lineSuffixBoundary,
|
||||
cursor,
|
||||
breakParent,
|
||||
ifBreak,
|
||||
trim,
|
||||
indent,
|
||||
indentIfBreak,
|
||||
align,
|
||||
addAlignmentToDoc,
|
||||
markAsRoot,
|
||||
dedentToRoot,
|
||||
dedent,
|
||||
hardlineWithoutBreakParent,
|
||||
literallineWithoutBreakParent,
|
||||
label,
|
||||
} = doc.builders;
|
||||
|
||||
export const {
|
||||
willBreak,
|
||||
traverseDoc,
|
||||
findInDoc,
|
||||
mapDoc,
|
||||
removeLines,
|
||||
stripTrailingHardline,
|
||||
} = doc.utils;
|
||||
|
||||
// Fallback implementations for removed common in prettier 3
|
||||
export const isConcat = (doc: any): boolean => Array.isArray(doc);
|
||||
export const getDocParts = (doc: any): any[] => Array.isArray(doc) ? doc : [doc];
|
||||
export const propagateBreaks = (doc: any): any => doc;
|
||||
export const normalizeParts = (parts: any[]): any[] => parts.flat();
|
||||
export const normalizeDoc = (doc: any): any => doc;
|
||||
export const cleanDoc = (doc: any): any => doc;
|
||||
export const canBreak = (doc: any): boolean => {
|
||||
if (!doc) return false;
|
||||
if (typeof doc === 'string') return false;
|
||||
if (Array.isArray(doc)) return doc.some(canBreak);
|
||||
if (doc.type === 'group' || doc.type === 'fill') return true;
|
||||
return willBreak(doc);
|
||||
};
|
||||
|
||||
export const Symbol_comments = Symbol.for("comments");
|
||||
|
||||
export interface CustomOptions extends ParserOptions<Node> {
|
||||
[Symbol_comments]: AnyComment[];
|
||||
rsParsedFile: SourceFile;
|
||||
commentSpans: Map<number, number>;
|
||||
printer: Printer<Node>;
|
||||
cursorNode: any;
|
||||
|
||||
comments: Comment[];
|
||||
danglingAttributes: AttributeOrDocComment[];
|
||||
actuallyMethodNodes: WeakSet<MemberExpression>;
|
||||
}
|
||||
|
||||
export type NodeWithComments<T extends Node> = T & { comments: AnyComment[] };
|
||||
export interface MutatedComment extends Comment, PrettierCommentInfo {}
|
||||
export interface MutatedAttribute extends Attribute, PrettierCommentInfo {}
|
||||
export interface MutatedDocComment extends DocCommentAttribute, PrettierCommentInfo {}
|
||||
export type AnyComment = MutatedComment | MutatedAttribute | MutatedDocComment;
|
||||
|
||||
type keyofDelimitedArrayProps<T> = T extends never ? never : keyof PickProps<T, LocArray<any, "()" | "[]" | "{}" | "<>">>;
|
||||
|
||||
__DEV__: AssertTypesEq<keyof typeof DCM, keyofDelimitedArrayProps<Node>>();
|
||||
|
||||
export enum DCM {
|
||||
"arguments" = "arguments",
|
||||
"parameters" = "parameters",
|
||||
"items" = "items",
|
||||
"properties" = "properties",
|
||||
"members" = "members",
|
||||
"body" = "body",
|
||||
"cases" = "cases",
|
||||
"typeArguments" = "typeArguments",
|
||||
"ltParameters" = "ltParameters",
|
||||
"generics" = "generics",
|
||||
"specifiers" = "specifiers",
|
||||
"rules" = "rules",
|
||||
"match" = "match",
|
||||
"transform" = "transform",
|
||||
"segments" = "segments",
|
||||
}
|
||||
|
||||
export interface PrettierCommentInfo {
|
||||
trailing: boolean;
|
||||
leading: boolean;
|
||||
unignore: boolean;
|
||||
printed: boolean;
|
||||
placement: "ownLine" | "endOfLine" | "remaining";
|
||||
// nodeDescription?: any;
|
||||
marker?: DCM;
|
||||
}
|
||||
|
||||
export interface AstPath<T = Node> {
|
||||
stack: (Node | string | number)[];
|
||||
callParent<R>(callback: (path: this) => R, count?: number): R;
|
||||
getName(): PropertyKey | null;
|
||||
getValue(): T;
|
||||
getNode(count?: number): T | null;
|
||||
getParentNode(count?: number): T | null;
|
||||
|
||||
match(...predicates: ((node: Node, name: string | null, number: number | null) => boolean)[]): boolean;
|
||||
|
||||
call<R>(callback: (path: AstPath, index: number, value: any) => R, ...props: (string | number)[]): R;
|
||||
each(callback: (path: AstPath, index: number, value: any) => void, ...props: (string | number)[]): void;
|
||||
map<R>(callback: (path: AstPath, index: number, value: any) => R, ...props: (string | number)[]): R[];
|
||||
}
|
||||
367
frontend/src/common/prettier/plugins/rust/format/plugin.ts
Normal file
367
frontend/src/common/prettier/plugins/rust/format/plugin.ts
Normal file
@@ -0,0 +1,367 @@
|
||||
import { AttributeOrComment, IfBlockExpression, Node, Program, rs } from "jinx-rust";
|
||||
import {
|
||||
ArrayProps,
|
||||
BoolProps,
|
||||
NodeProps,
|
||||
end,
|
||||
hasAttributes,
|
||||
insertNodes,
|
||||
is_Attribute,
|
||||
is_AttributeOrComment,
|
||||
is_BlockCommentKind,
|
||||
is_BlockCommentNode,
|
||||
is_Comment,
|
||||
is_DocCommentAttribute,
|
||||
is_ElseBlock,
|
||||
is_LineCommentNode,
|
||||
is_MacroInvocation,
|
||||
is_MacroRule,
|
||||
is_MissingNode,
|
||||
is_Node,
|
||||
is_PunctuationToken,
|
||||
is_UnionPattern,
|
||||
start,
|
||||
} from "jinx-rust/utils";
|
||||
import { getCommentChildNodes, isTransformed, transform_ast } from "../transform";
|
||||
import { Narrow, assert, color, each, exit, iLast, is_array, map_tagged_template, print_string } from "../utils/common";
|
||||
import {
|
||||
CF,
|
||||
escapeComments,
|
||||
getComments,
|
||||
handleEndOfLineComment,
|
||||
handleOwnLineComment,
|
||||
handleRemainingComment,
|
||||
hasBreaklineAfter,
|
||||
hasComment,
|
||||
isDangling,
|
||||
isPrettierIgnoreAttribute,
|
||||
setDidPrintComment,
|
||||
withComments,
|
||||
} from "./comments";
|
||||
import { withCheckContext } from "./complexity";
|
||||
import { isNoopExpressionStatement, maybeEmptyLine } from "./core";
|
||||
import { AstPath, CustomOptions, Doc, Plugin, Symbol_comments, group, hardline, indent, line, softline, ParserOptions } from "./external";
|
||||
import { printer } from "./printer";
|
||||
import { needsInnerParens, needsOuterSoftbreakParens, shouldPrintOuterAttributesAbove } from "./styling";
|
||||
|
||||
export function is_printing_macro() {
|
||||
return getContext().path.stack.some((node) => is_Node(node) && (is_MacroInvocation(node) || is_Attribute(node)));
|
||||
}
|
||||
|
||||
export function assertPathAtNode(name: string, node: Node, ...ctx: any[]) {
|
||||
__DEV__: if (getNode() !== node)
|
||||
exit(`Attempted to call ${name}() in wrong prettier path context`, { asserted: node, actual: getNode() }, ...ctx);
|
||||
}
|
||||
|
||||
export function f(...args: [strings: TemplateStringsArray, ...values: Doc[]]) {
|
||||
let cancel = false;
|
||||
const res = map_tagged_template(args, (doc) => {
|
||||
cancel ||= !doc || (is_array(doc) && doc.length === 0);
|
||||
return doc;
|
||||
});
|
||||
return cancel ? "" : res;
|
||||
}
|
||||
|
||||
export function sg_single(s: TemplateStringsArray, v_0: Doc) {
|
||||
return group([s[0], indent([softline, v_0]), softline, s[1]]);
|
||||
}
|
||||
export function sg_duo(s: TemplateStringsArray, v_0: Doc, v_1: Doc) {
|
||||
return group([s[0], indent([softline, v_0, s[1], line, v_1]), softline, s[2]]);
|
||||
}
|
||||
|
||||
let ctx: {
|
||||
path: AstPath;
|
||||
options: CustomOptions;
|
||||
print: (path?: AstPath | string | [] | undefined, args?: any) => Doc;
|
||||
args: any;
|
||||
};
|
||||
|
||||
export const getNode = () => ctx.path.stack[ctx.path.stack.length - 1] as Node;
|
||||
export const stackIncludes = (x: Node | string | number) => ctx.path.stack.includes(x);
|
||||
export const getContext = () => ctx;
|
||||
export const getOptions = () => ctx.options;
|
||||
export const getProgram = () => ctx.options.rsParsedFile.program;
|
||||
export const getAllComments = () => ctx.options[Symbol_comments];
|
||||
export const getParentNode = (child?: Node) => {
|
||||
__DEV__: if (child) assertPathAtNode("getParentNode", child);
|
||||
return ctx.path.getParentNode();
|
||||
};
|
||||
export const getGrandParentNode = () => ctx.path.getParentNode(1) as Node;
|
||||
export const getPrintFn = <T extends Node>(forNode?: T | undefined): print<T> => {
|
||||
__DEV__: if (forNode) assertPathAtNode("getPrintFn", forNode);
|
||||
return print as print<T>;
|
||||
};
|
||||
|
||||
const get = (property: keyof any) => getNode()[property];
|
||||
const has = (property: keyof any) => !!get(property);
|
||||
|
||||
export function pathCall<T extends Node, K extends keyof NodeProps<T> & keyof T, R>(node: T, key: K, fn: (child: T[K]) => R): R {
|
||||
return ctx.path.call(() => fn(getNode() as any), key as any);
|
||||
}
|
||||
|
||||
export function pathCallEach<T extends Node, K extends AK<T>>(
|
||||
node: T,
|
||||
key: K, // @ts-expect-error
|
||||
fn: (child: NonNullable<T[K]>[number], index: number) => void
|
||||
) {
|
||||
__DEV__: assertPathAtNode("", node); // @ts-expect-error
|
||||
ctx.path.each((_, i) => fn(getNode() as any, i), key);
|
||||
}
|
||||
|
||||
export function pathCallAtParent<T extends Node, R>(parent: T, fn: (parent: T) => R): R {
|
||||
return ctx.path.callParent(() => {
|
||||
__DEV__: assertPathAtNode("pathCallParent", parent);
|
||||
return fn(parent);
|
||||
});
|
||||
}
|
||||
export function pathCallParentOf<T extends Node, R>(child: Node, fn: (parent: T) => R): R {
|
||||
__DEV__: assertPathAtNode("pathCallParentOf", child);
|
||||
return ctx.path.callParent((p) => fn(getNode() as any));
|
||||
}
|
||||
|
||||
export function pathCallTopMostIfBlockExpression<R>(node: IfBlockExpression, fn: (node: IfBlockExpression) => R): R {
|
||||
const parent = getParentNode(node)!;
|
||||
return is_ElseBlock(node, parent) ? pathCallAtParent(parent, (parent) => pathCallTopMostIfBlockExpression(parent, fn)) : fn(node);
|
||||
}
|
||||
|
||||
function print(property?: any, args?: any): Doc | Doc[] {
|
||||
if (!property) return ctx.print(undefined!, args);
|
||||
if (Array.isArray(property)) return ctx.print(property as any, args);
|
||||
const value = get(property);
|
||||
return !!value ? (Array.isArray(value) ? ctx.path.map(ctx.print, property) : ctx.print(property, args)) : "";
|
||||
}
|
||||
|
||||
namespace print {
|
||||
export function b(property: string, res = `${property} `): Doc {
|
||||
return has(property) ? res : "";
|
||||
}
|
||||
export function map(property: string, mapItem?: MapFn<any, any>): Doc[] {
|
||||
return !has(property) ? [] : ctx.path.map(mapItem ? (p, i, a) => mapItem(a[i], i, a) : () => ctx.print(), property);
|
||||
}
|
||||
export function join(property: string, sep: SepFn<any, any> | Doc, trailingSep: TrailingSepFn<any, any> | Doc = ""): Doc[] {
|
||||
return map_join(property, () => ctx.print(), sep, trailingSep);
|
||||
}
|
||||
export function map_join(
|
||||
property: string,
|
||||
mapFn: MapFn<any, any>,
|
||||
sep: SepFn<any, any> | Doc,
|
||||
sepTrailing: TrailingSepFn<any, any> | Doc = ""
|
||||
) {
|
||||
const sepFn = typeof sep === "function" ? sep : () => sep;
|
||||
return map(property, (v, i, a) => [
|
||||
mapFn(v, i, a),
|
||||
iLast(i, a as any)
|
||||
? typeof sepTrailing === "function"
|
||||
? sepTrailing(v)
|
||||
: sepTrailing
|
||||
: sepFn(v, a[i + 1], i === 0 ? undefined : a[i - 1]),
|
||||
]);
|
||||
}
|
||||
}
|
||||
|
||||
// prettier-ignore
|
||||
type SepFn<T extends Node = Node, K extends AK<T> = AK<T>> = <A extends AV<T, K>>(item: A[number], next_item: A[number], prev_item: A[number] | undefined) => Doc;
|
||||
type MapFn<T extends Node = Node, K extends AK<T> = AK<T>> = <A extends AV<T, K>>(item: A[number], index: number, arr: A) => Doc;
|
||||
type TrailingSepFn<T extends Node = Node, K extends AK<T> = AK<T>> = <A extends AV<T, K>>(item: A[number]) => Doc;
|
||||
type AV<T extends Node, K extends keyof T> = Extract<NonNullable<T[K]>, ReadonlyArray<unknown>>;
|
||||
type AK<T extends Node> = keyof ArrayProps<T> & keyof T;
|
||||
// type AK<T extends Node> = keyof PickProps<T, {nodeType:number}|{nodeType:number}[]> & keyof T;
|
||||
|
||||
export interface print<T extends Node> {
|
||||
(property?: [], args?: any): Doc;
|
||||
(property?: [AK<T>, number], args?: any): Doc;
|
||||
(property?: AK<T>, args?: any): Doc[];
|
||||
// (property?: T extends {rules:{nodeType:number}|{nodeType:number}[]} ? "rules" : never, args?: any): Doc[];
|
||||
(property?: keyof NodeProps<T> & keyof T, args?: any): Doc;
|
||||
b(property: keyof BoolProps<T>, res?: string): Doc;
|
||||
map<K extends AK<T>>(property: K & keyof ArrayProps<T>, mapFn?: MapFn<T, K>): Doc[];
|
||||
join<K extends AK<T>>(property: K, sep: SepFn<T, K> | Doc, trailingSep?: TrailingSepFn<T, K> | Doc): Doc[];
|
||||
map_join<K extends AK<T>>(property: K, mapFn: MapFn<T, K>, sep: SepFn<T, K> | Doc, trailingSep?: TrailingSepFn<T, K> | Doc): Doc[];
|
||||
}
|
||||
|
||||
function genericPrint() {
|
||||
return withCheckContext(() => {
|
||||
const node = getNode();
|
||||
__DEV__: assert(node.nodeType in printer);
|
||||
|
||||
let printed: Doc = hasPrettierIgnore(node) //
|
||||
? node.loc.getOwnText()
|
||||
: printer[node.nodeType]!(print as any, node as never);
|
||||
|
||||
const inner_parens = needsInnerParens(node);
|
||||
|
||||
if (inner_parens) {
|
||||
printed = group(["(", printed, ")"]);
|
||||
}
|
||||
|
||||
if (hasAttributes(node)) {
|
||||
const print_above = shouldPrintOuterAttributesAbove(node); /* || node.attributes.length > 1 */
|
||||
printed = [
|
||||
...print.join(
|
||||
"attributes",
|
||||
(attr) =>
|
||||
print_above
|
||||
? maybeEmptyLine(attr)
|
||||
: is_LineCommentNode(attr) || (is_BlockCommentNode(attr) && hasBreaklineAfter(attr))
|
||||
? hardline
|
||||
: " ",
|
||||
(attr) =>
|
||||
print_above && is_DocCommentAttribute(attr)
|
||||
? maybeEmptyLine(attr)
|
||||
: print_above || is_LineCommentNode(attr) || (is_BlockCommentNode(attr) && hasBreaklineAfter(attr))
|
||||
? hardline
|
||||
: " "
|
||||
),
|
||||
printed,
|
||||
];
|
||||
}
|
||||
|
||||
printed = withComments(
|
||||
node,
|
||||
printed,
|
||||
hasPrettierIgnore(node) || ((is_Attribute(node) || is_MacroInvocation(node)) && !isTransformed(node))
|
||||
? escapeComments(0, (comment) => node.loc.ownContains(comment))
|
||||
: is_MacroRule(node)
|
||||
? escapeComments(0, (comment) => node.transform.loc.contains(comment))
|
||||
: is_UnionPattern(getParentNode() ?? ({ nodeType: 0 } as any))
|
||||
? new Set(getComments(node, CF.Leading | CF.Trailing, (comment) => !isDangling(comment)))
|
||||
: undefined
|
||||
);
|
||||
|
||||
if (!inner_parens && needsOuterSoftbreakParens(node)) {
|
||||
printed = [group(["(", indent([softline, printed]), softline, ")"])];
|
||||
}
|
||||
|
||||
return printed;
|
||||
});
|
||||
|
||||
function hasPrettierIgnore(node: Node) {
|
||||
return (
|
||||
(node as any).prettierIgnore ||
|
||||
hasComment(node, CF.PrettierIgnore) ||
|
||||
(hasAttributes(node) && node.attributes.some(isPrettierIgnoreAttribute))
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
export function canAttachComment(n: Node) {
|
||||
return !is_Comment(n) && !isNoopExpressionStatement(n) && !is_MissingNode(n) && !is_PunctuationToken(n);
|
||||
}
|
||||
|
||||
export const plugin: Plugin<Node> = {
|
||||
languages: [
|
||||
{
|
||||
name: "Rust",
|
||||
aliases: ["rs"],
|
||||
parsers: ["jinx-rust"],
|
||||
extensions: [".rs", ".rs.in"],
|
||||
linguistLanguageId: 327,
|
||||
vscodeLanguageIds: ["rust"],
|
||||
tmScope: "source.rust",
|
||||
aceMode: "rust",
|
||||
codemirrorMode: "rust",
|
||||
codemirrorMimeType: "text/x-rustsrc",
|
||||
},
|
||||
],
|
||||
parsers: {
|
||||
"jinx-rust": {
|
||||
astFormat: "jinx-rust",
|
||||
locStart: start,
|
||||
locEnd: end,
|
||||
parse(code: string, options: ParserOptions<Node> & Partial<CustomOptions>) {
|
||||
const customOptions = options as CustomOptions;
|
||||
ctx = { options: customOptions } as any;
|
||||
|
||||
customOptions.rsParsedFile = rs.parseFile((customOptions.originalText = code), { filepath: customOptions.filepath });
|
||||
|
||||
customOptions.actuallyMethodNodes = new WeakSet();
|
||||
customOptions.danglingAttributes = [];
|
||||
customOptions.comments = [];
|
||||
|
||||
transform_ast(customOptions);
|
||||
|
||||
const comments: AttributeOrComment[] = [];
|
||||
insertNodes(comments, customOptions.comments);
|
||||
insertNodes(comments, customOptions.danglingAttributes);
|
||||
|
||||
// @ts-expect-error
|
||||
customOptions.rsParsedFile.program.comments = comments;
|
||||
|
||||
customOptions.commentSpans = new Map(comments.map((n) => [start(n), end(n)]));
|
||||
|
||||
return customOptions.rsParsedFile.program;
|
||||
},
|
||||
},
|
||||
},
|
||||
printers: {
|
||||
"jinx-rust": {
|
||||
preprocess: (node: Node) => (node as Program).loc?.src || node,
|
||||
print(path, options, print, args) {
|
||||
if (path.stack.length === 1) {
|
||||
__DEV__: Narrow<CustomOptions>(options);
|
||||
ctx = { path, options, print: print as any, args };
|
||||
try {
|
||||
const printed = genericPrint();
|
||||
__DEV__: devEndCheck(printed);
|
||||
return printed;
|
||||
} finally {
|
||||
ctx = undefined!;
|
||||
}
|
||||
} else if (args || ctx.args) {
|
||||
const prev_args = ctx.args;
|
||||
try {
|
||||
ctx.args = args;
|
||||
return genericPrint();
|
||||
} finally {
|
||||
ctx.args = prev_args;
|
||||
}
|
||||
} else {
|
||||
return genericPrint();
|
||||
}
|
||||
},
|
||||
hasPrettierIgnore: () => false,
|
||||
willPrintOwnComments: () => true,
|
||||
isBlockComment: (node: Node): boolean => {
|
||||
return is_AttributeOrComment(node) && is_BlockCommentKind(node as any);
|
||||
},
|
||||
canAttachComment: canAttachComment,
|
||||
getCommentChildNodes: getCommentChildNodes,
|
||||
printComment: genericPrint,
|
||||
handleComments: {
|
||||
// @ts-expect-error
|
||||
avoidAstMutation: true,
|
||||
ownLine: handleOwnLineComment,
|
||||
endOfLine: handleEndOfLineComment,
|
||||
remaining: handleRemainingComment,
|
||||
},
|
||||
},
|
||||
},
|
||||
options: {},
|
||||
defaultOptions: {
|
||||
// default prettier (2) -> rustfmt (4)
|
||||
tabWidth: 4,
|
||||
// default prettier (80) -> rustfmt (100)
|
||||
printWidth: 100,
|
||||
},
|
||||
};
|
||||
|
||||
function devEndCheck(printed: Doc) {
|
||||
let first = false;
|
||||
const comments = getAllComments();
|
||||
each(comments, (comment, index) => {
|
||||
if (!comment.printed) {
|
||||
if (!first) (first = true), console.log(color.red(`Unprinted comments:`));
|
||||
const len = 40;
|
||||
const msg =
|
||||
color.magenta(
|
||||
(comment.marker ? `Dangling "${comment.marker}" ` : "") +
|
||||
(is_Attribute(comment) ? "Attribute " : is_DocCommentAttribute(comment) ? "DocCommentAttribute" : "Comment") +
|
||||
` ${index}/${comments.length}` +
|
||||
color.yellow(` ${print_string(comment.loc.sliceText(0, len))}${comment.loc.len() > len ? " ..." : ""}`)
|
||||
) + color.grey(`\n at ${comment.loc.url()}`);
|
||||
if (globalThis.TESTS_FORMAT_DEV) exit(msg);
|
||||
else console.log(msg);
|
||||
setDidPrintComment(comment);
|
||||
}
|
||||
});
|
||||
}
|
||||
719
frontend/src/common/prettier/plugins/rust/format/printer.ts
Normal file
719
frontend/src/common/prettier/plugins/rust/format/printer.ts
Normal file
@@ -0,0 +1,719 @@
|
||||
import { DelimKind, Node, NodeType, NTMap } from "jinx-rust";
|
||||
import {
|
||||
getDelimChars,
|
||||
hasSuffix,
|
||||
is_ArrayOrTupleLiteral,
|
||||
is_BlockExpression,
|
||||
is_ClosureFunctionExpression,
|
||||
is_Identifier,
|
||||
is_IfBlockExpression,
|
||||
is_LiteralNumberLike,
|
||||
is_StructLiteral,
|
||||
start,
|
||||
} from "jinx-rust/utils";
|
||||
import {
|
||||
BlockLikeMacroInvocation,
|
||||
CallLikeMacroInvocation,
|
||||
is_BlockLikeMacroInvocation,
|
||||
is_CallLikeMacroInvocation,
|
||||
isTransformed,
|
||||
} from "../transform";
|
||||
import { exit } from "../utils/common";
|
||||
import { hasComment, print_comment } from "./comments";
|
||||
import { isSimpleType } from "./complexity";
|
||||
import {
|
||||
adjustClause,
|
||||
parenthesize_if_break,
|
||||
printAnnotatedPattern,
|
||||
printArrayLike,
|
||||
printArrowFunction,
|
||||
printAssignment,
|
||||
printBinaryishExpression,
|
||||
printBlockBody,
|
||||
printBodyOrCases,
|
||||
printCallArguments,
|
||||
printCallExpression,
|
||||
printCondition,
|
||||
printDanglingCommentsForInline,
|
||||
printDeclarationTypeBounds,
|
||||
printEnumBody,
|
||||
printFlowControlExpression,
|
||||
printGenerics_x_whereBounds,
|
||||
printIfBlock,
|
||||
printIfBlockCondition,
|
||||
printImplTraitForType,
|
||||
printLtBounds,
|
||||
printLtParameters,
|
||||
printMacroRules,
|
||||
printMaybeBlockBody,
|
||||
printMemberExpression,
|
||||
printNumber,
|
||||
printObject,
|
||||
printParametersAndReturnType,
|
||||
printRuleMatch,
|
||||
printRuleTransform,
|
||||
printTypeAnnotation,
|
||||
printTypeArguments,
|
||||
printTypeBounds,
|
||||
printUnaryExpression,
|
||||
printUnionPattern,
|
||||
} from "./core";
|
||||
import { DCM, Doc, group, hardline, ifBreak, indent, join, line, softline, willBreak } from "./external";
|
||||
import { f, getOptions, getParentNode, pathCall, sg_duo, sg_single, type print } from "./plugin";
|
||||
import { needsParens, stmtNeedsSemi } from "./styling";
|
||||
|
||||
type nPrint<T extends Node> = (print: print<T>, node: T) => Doc | never;
|
||||
|
||||
export const printer: { [K in NodeType]: nPrint<Extract<NTMap[K], Node>> } = {
|
||||
[NodeType.MissingNode](print, node) {
|
||||
return "";
|
||||
},
|
||||
[NodeType.SourceFile](print, node) {
|
||||
return [
|
||||
print.b("UTF8BOM", "\uFEFF"), //
|
||||
print("shebang"),
|
||||
print("program"),
|
||||
];
|
||||
},
|
||||
[NodeType.Shebang](print, node) {
|
||||
return [`#!${node.value}`, hardline];
|
||||
},
|
||||
[NodeType.Program](print, node) {
|
||||
return printBodyOrCases(print, node);
|
||||
},
|
||||
[NodeType.Snippet](print, node) {
|
||||
exit.never();
|
||||
},
|
||||
[NodeType.Identifier](print, node) {
|
||||
return node.name;
|
||||
},
|
||||
[NodeType.Index](print, node) {
|
||||
return node.name;
|
||||
},
|
||||
[NodeType.LbIdentifier](print, node) {
|
||||
return node.name;
|
||||
},
|
||||
[NodeType.McIdentifier](print, node) {
|
||||
return node.name;
|
||||
},
|
||||
[NodeType.LtIdentifier](print, node) {
|
||||
return node.name;
|
||||
},
|
||||
[NodeType.PunctuationToken](print, node) {
|
||||
return node.token;
|
||||
},
|
||||
[NodeType.DelimGroup](print, node) {
|
||||
return node.loc.getOwnText();
|
||||
},
|
||||
[NodeType.Literal](print, node) {
|
||||
let { value } = node;
|
||||
if (is_LiteralNumberLike(node)) value = printNumber(value);
|
||||
return hasSuffix(node) ? [value, print("suffix")] : value;
|
||||
},
|
||||
[NodeType.ItemPath](print, node) {
|
||||
return [print("namespace"), "::", print("segment")];
|
||||
},
|
||||
[NodeType.ExpressionPath](print, node) {
|
||||
return [print("namespace"), "::", print("segment")];
|
||||
},
|
||||
[NodeType.TypePath](print, node) {
|
||||
return [print("namespace"), "::", print("segment")];
|
||||
},
|
||||
[NodeType.Comment](print, node) {
|
||||
return print_comment(node);
|
||||
},
|
||||
[NodeType.DocCommentAttribute](print, node) {
|
||||
return print_comment(node);
|
||||
},
|
||||
[NodeType.Attribute](print, node) {
|
||||
return [
|
||||
node.inner ? "#![" : "#[",
|
||||
isTransformed(node)
|
||||
? [print("segments"), printDanglingCommentsForInline(node)] //
|
||||
: node.segments.loc.sliceText(1, -1).trim(),
|
||||
"]",
|
||||
];
|
||||
},
|
||||
[NodeType.MacroInvocation](print, node) {
|
||||
const hasCurlyBrackets = node.segments.dk === DelimKind["{}"];
|
||||
const delim = getDelimChars(node.segments);
|
||||
if (node.segments.length === 0) {
|
||||
return [print("callee"), "!", hasCurlyBrackets ? " " : "", delim.left, printDanglingCommentsForInline(node), delim.right];
|
||||
}
|
||||
if (isTransformed(node)) {
|
||||
if (is_CallLikeMacroInvocation(node)) {
|
||||
return [print("callee"), "!", printCallArguments(print as print<CallLikeMacroInvocation>, node)];
|
||||
}
|
||||
if (is_BlockLikeMacroInvocation(node)) {
|
||||
return [print("callee"), "!", " ", printBlockBody(print as print<BlockLikeMacroInvocation>, node)];
|
||||
}
|
||||
}
|
||||
let content = node.segments.loc.sliceText(1, -1);
|
||||
if (content.trim().length === 0) {
|
||||
content = "";
|
||||
} else if (!content.includes("\n")) {
|
||||
content = content.trim();
|
||||
if (hasCurlyBrackets) content = " " + content + " ";
|
||||
}
|
||||
return [print("callee"), "!", hasCurlyBrackets ? " " : "", delim.left, content, delim.right];
|
||||
},
|
||||
[NodeType.MacroRulesDeclaration](print, node) {
|
||||
return ["macro_rules! ", print("id"), printMacroRules(print, node)];
|
||||
},
|
||||
[NodeType.MacroRuleDeclaration](print, node) {
|
||||
return [printRuleMatch(print, node), " => ", printRuleTransform(print, node), ";"];
|
||||
},
|
||||
[NodeType.MacroDeclaration](print, node) {
|
||||
return [print("pub"), "macro ", print("id"), printMacroRules(print, node)];
|
||||
},
|
||||
[NodeType.MacroInlineRuleDeclaration](print, node) {
|
||||
return [printRuleMatch(print, node), " ", printRuleTransform(print, node)];
|
||||
},
|
||||
[NodeType.MacroGroup](print, node) {
|
||||
return node.loc.getOwnText();
|
||||
},
|
||||
[NodeType.MacroParameterDeclaration](print, node) {
|
||||
return [print("id"), ":", print("ty")];
|
||||
},
|
||||
[NodeType.PubSpecifier](print, node) {
|
||||
if (!node.location) return "pub ";
|
||||
if (is_Identifier(node.location)) {
|
||||
switch (node.location.name) {
|
||||
case "crate":
|
||||
if (start(node) === start(node.location)) {
|
||||
return "crate ";
|
||||
} else {
|
||||
return ["pub(", print("location"), ") "];
|
||||
}
|
||||
case "self":
|
||||
case "super":
|
||||
return ["pub(", print("location"), ") "];
|
||||
}
|
||||
}
|
||||
return ["pub(in ", print("location"), ") "];
|
||||
},
|
||||
[NodeType.ExternSpecifier](print, node) {
|
||||
return ["extern ", f`${print("abi")} `];
|
||||
},
|
||||
[NodeType.ExpressionStatement](print, node) {
|
||||
return [print("expression"), stmtNeedsSemi(node) ? ";" : ""];
|
||||
},
|
||||
[NodeType.UseStatement](print, node) {
|
||||
return [print("pub"), "use ", print("import"), ";"];
|
||||
},
|
||||
[NodeType.DestructuredImport](print, node) {
|
||||
if (node.specifiers.length === 0) return [print("source"), "::{", printDanglingCommentsForInline(node, DCM["specifiers"]), "}"];
|
||||
let space = true;
|
||||
__DEV__: if (globalThis.TESTS_FORMAT_DEV) space = false;
|
||||
return [
|
||||
print("source"),
|
||||
group([
|
||||
"::{",
|
||||
indent([space ? line : softline, join([",", line], print("specifiers")), ifBreak(",")]),
|
||||
space ? line : softline,
|
||||
"}",
|
||||
]),
|
||||
];
|
||||
},
|
||||
[NodeType.AmbientImport](print, node) {
|
||||
return f`${print("source")}::*` || "*";
|
||||
},
|
||||
[NodeType.AnonymousImport](print, node) {
|
||||
return [print("source"), " as ", "_"];
|
||||
},
|
||||
[NodeType.NamedImport](print, node) {
|
||||
return [print("source"), f` as ${print("local")}`];
|
||||
},
|
||||
[NodeType.ExternCrateStatement](print, node) {
|
||||
return [print("pub"), "extern crate ", print("import"), ";"];
|
||||
},
|
||||
[NodeType.TypeAliasDeclaration](print, node) {
|
||||
return [
|
||||
print("pub"),
|
||||
"type",
|
||||
printAssignment(
|
||||
printGenerics_x_whereBounds(print, node, printDeclarationTypeBounds(print, node, ":")), //
|
||||
" =",
|
||||
"typeExpression"
|
||||
),
|
||||
";",
|
||||
];
|
||||
},
|
||||
[NodeType.LetVariableDeclaration](print, node) {
|
||||
return [
|
||||
"let ",
|
||||
printAssignment(
|
||||
printAnnotatedPattern(print, node), //
|
||||
" =",
|
||||
"expression"
|
||||
),
|
||||
f` else ${print("else")}`,
|
||||
";",
|
||||
];
|
||||
},
|
||||
[NodeType.ConstVariableDeclaration](print, node) {
|
||||
return [
|
||||
print("pub"),
|
||||
"const ",
|
||||
printAssignment(
|
||||
printAnnotatedPattern(print, node), //
|
||||
" =",
|
||||
"expression"
|
||||
),
|
||||
";",
|
||||
];
|
||||
},
|
||||
[NodeType.StaticVariableDeclaration](print, node) {
|
||||
return [
|
||||
print("pub"),
|
||||
"static ",
|
||||
printAssignment(
|
||||
printAnnotatedPattern(print, node), //
|
||||
" =",
|
||||
"expression"
|
||||
),
|
||||
";",
|
||||
];
|
||||
},
|
||||
[NodeType.ModuleDeclaration](print, node) {
|
||||
return [
|
||||
print("pub"), //
|
||||
print.b("unsafe"),
|
||||
"mod ",
|
||||
print("id"),
|
||||
printMaybeBlockBody(print, node),
|
||||
];
|
||||
},
|
||||
[NodeType.ExternBlockDeclaration](print, node) {
|
||||
return [
|
||||
print("pub"), //
|
||||
print.b("unsafe"),
|
||||
"extern ",
|
||||
f`${print("abi")} `,
|
||||
printBlockBody(print, node),
|
||||
];
|
||||
},
|
||||
[NodeType.FunctionDeclaration](print, node) {
|
||||
return [
|
||||
print("pub"),
|
||||
print.b("const"),
|
||||
print.b("async"),
|
||||
print.b("unsafe"),
|
||||
print("extern"),
|
||||
"fn",
|
||||
printGenerics_x_whereBounds(print, node, printParametersAndReturnType(node)),
|
||||
printMaybeBlockBody(print, node),
|
||||
];
|
||||
},
|
||||
[NodeType.FunctionSelfParameterDeclaration](print, node) {
|
||||
return group([print.b("ref", "&"), f`${print("lt")} `, print.b("mut"), "self", printTypeAnnotation(print, node)]);
|
||||
},
|
||||
[NodeType.FunctionParameterDeclaration](print, node) {
|
||||
return group(printAnnotatedPattern(print, node));
|
||||
},
|
||||
[NodeType.FunctionSpread](print, node) {
|
||||
return "...";
|
||||
},
|
||||
[NodeType.StructDeclaration](print, node) {
|
||||
return [print("pub"), "struct", printGenerics_x_whereBounds(print, node, ""), printObject(print, node)];
|
||||
},
|
||||
[NodeType.StructPropertyDeclaration](print, node) {
|
||||
return [print("pub"), print("id"), printTypeAnnotation(print, node)];
|
||||
},
|
||||
[NodeType.TupleStructDeclaration](print, node) {
|
||||
return [print("pub"), "struct", printGenerics_x_whereBounds(print, node, printArrayLike(print, node)), ";"];
|
||||
},
|
||||
[NodeType.TupleStructItemDeclaration](print, node) {
|
||||
return [print("pub"), print("typeAnnotation")];
|
||||
},
|
||||
[NodeType.UnionDeclaration](print, node) {
|
||||
return [print("pub"), "union", printGenerics_x_whereBounds(print, node, ""), printObject(print, node)];
|
||||
},
|
||||
[NodeType.EnumDeclaration](print, node) {
|
||||
return [print("pub"), "enum", printGenerics_x_whereBounds(print, node, ""), printEnumBody(print, node)];
|
||||
},
|
||||
[NodeType.EnumMemberDeclaration](print, node) {
|
||||
return [
|
||||
print("pub"),
|
||||
printAssignment(
|
||||
print("id"), //
|
||||
" =",
|
||||
"value"
|
||||
),
|
||||
];
|
||||
},
|
||||
[NodeType.EnumMemberTupleDeclaration](print, node) {
|
||||
return [
|
||||
print("pub"),
|
||||
printAssignment(
|
||||
[print("id"), printArrayLike(print, node)], //
|
||||
" =",
|
||||
"value"
|
||||
),
|
||||
];
|
||||
},
|
||||
[NodeType.EnumMemberStructDeclaration](print, node) {
|
||||
return [
|
||||
print("pub"),
|
||||
printAssignment(
|
||||
[print("id"), printObject(print, node)], //
|
||||
" =",
|
||||
"value"
|
||||
),
|
||||
];
|
||||
},
|
||||
[NodeType.TraitDeclaration](print, node) {
|
||||
return [
|
||||
print("pub"),
|
||||
print.b("unsafe"),
|
||||
"trait",
|
||||
printGenerics_x_whereBounds(print, node, printDeclarationTypeBounds(print, node, ":")),
|
||||
adjustClause(node, printBlockBody(print, node)),
|
||||
];
|
||||
},
|
||||
[NodeType.AutoTraitDeclaration](print, node) {
|
||||
return [
|
||||
print("pub"),
|
||||
print.b("unsafe"),
|
||||
"auto trait ",
|
||||
print("id"),
|
||||
" ",
|
||||
printBlockBody(print, node as any), // see "transform.ts"
|
||||
];
|
||||
},
|
||||
[NodeType.TraitAliasDeclaration](print, node) {
|
||||
return [
|
||||
print("pub"),
|
||||
print.b("unsafe"),
|
||||
"trait",
|
||||
printGenerics_x_whereBounds(print, node, printDeclarationTypeBounds(print, node, " =")),
|
||||
";",
|
||||
];
|
||||
},
|
||||
[NodeType.ImplDeclaration](print, node) {
|
||||
return [
|
||||
print("pub"),
|
||||
print.b("unsafe"),
|
||||
"impl",
|
||||
printGenerics_x_whereBounds(print, node, [print.b("const"), printImplTraitForType(print, node)]),
|
||||
adjustClause(node, printBlockBody(print, node)),
|
||||
];
|
||||
},
|
||||
[NodeType.NegativeImplDeclaration](print, node) {
|
||||
return [
|
||||
print("pub"),
|
||||
"impl",
|
||||
printGenerics_x_whereBounds(print, node, ["!", printImplTraitForType(print, node)]),
|
||||
" ",
|
||||
printBlockBody(print, node as any), // see "transform.ts"
|
||||
];
|
||||
},
|
||||
[NodeType.ExpressionTypeSelector](print, node) {
|
||||
return group(["<", print("typeTarget"), f` as ${print("typeExpression")}`, ">"]);
|
||||
},
|
||||
[NodeType.ExpressionTypeCast](print, node) {
|
||||
return [print("typeCallee"), f`::${printTypeArguments(print, node)}`];
|
||||
},
|
||||
[NodeType.ExpressionAsTypeCast](print, node) {
|
||||
return [print("expression"), " as ", print("typeExpression")];
|
||||
},
|
||||
[NodeType.ReturnExpression](print, node) {
|
||||
return ["return", printFlowControlExpression(print, node)];
|
||||
},
|
||||
[NodeType.BreakExpression](print, node) {
|
||||
return ["break", f` ${print("label")}`, printFlowControlExpression(print, node)];
|
||||
},
|
||||
[NodeType.ContinueExpression](print, node) {
|
||||
return ["continue", f` ${print("label")}`];
|
||||
},
|
||||
[NodeType.YieldExpression](print, node) {
|
||||
return ["yield", printFlowControlExpression(print, node)];
|
||||
},
|
||||
[NodeType.RangeLiteral](print, node) {
|
||||
return [print("lower"), "..", print.b("last", "="), print("upper")];
|
||||
},
|
||||
[NodeType.CallExpression](print, node) {
|
||||
return printCallExpression(print, node);
|
||||
},
|
||||
[NodeType.MemberExpression](print, node) {
|
||||
return printMemberExpression(print, node);
|
||||
},
|
||||
[NodeType.AwaitExpression](print, node) {
|
||||
return [print("expression"), ".await"];
|
||||
},
|
||||
[NodeType.UnwrapExpression](print, node) {
|
||||
return [print("expression"), "?"];
|
||||
},
|
||||
[NodeType.ParenthesizedExpression](print, node) {
|
||||
exit.never();
|
||||
const shouldHug = !hasComment(node.expression) && (is_ArrayOrTupleLiteral(node.expression) || is_StructLiteral(node.expression));
|
||||
if (shouldHug) return ["(", print("expression"), ")"];
|
||||
return group(["(", indent([softline, print("expression")]), softline, ")"]);
|
||||
},
|
||||
[NodeType.MinusExpression](print, node) {
|
||||
return printUnaryExpression("-", node);
|
||||
},
|
||||
[NodeType.NotExpression](print, node) {
|
||||
return printUnaryExpression("!", node);
|
||||
},
|
||||
[NodeType.OrExpression](print, node) {
|
||||
return printBinaryishExpression(print, node);
|
||||
},
|
||||
[NodeType.AndExpression](print, node) {
|
||||
return printBinaryishExpression(print, node);
|
||||
},
|
||||
[NodeType.ReassignmentExpression](print, node) {
|
||||
return printAssignment(print("left"), " =", "right");
|
||||
},
|
||||
[NodeType.UnassignedExpression](print, node) {
|
||||
return "_";
|
||||
},
|
||||
[NodeType.OperationExpression](print, node) {
|
||||
return printBinaryishExpression(print, node);
|
||||
},
|
||||
[NodeType.ReassignmentOperationExpression](print, node) {
|
||||
return printAssignment(print("left"), " " + node.kind, "right");
|
||||
},
|
||||
[NodeType.ComparisonExpression](print, node) {
|
||||
return printBinaryishExpression(print, node);
|
||||
},
|
||||
[NodeType.LetScrutinee](print, node) {
|
||||
return ["let ", printAssignment(print("pattern"), " =", "expression")];
|
||||
},
|
||||
[NodeType.ClosureFunctionExpression](print, node) {
|
||||
return printArrowFunction(print, node);
|
||||
},
|
||||
[NodeType.ClosureFunctionParameterDeclaration](print, node) {
|
||||
return group(printAnnotatedPattern(print, node));
|
||||
},
|
||||
[NodeType.BlockExpression](print, node) {
|
||||
return [
|
||||
f`${print("label")}: `,
|
||||
print.b("const"),
|
||||
print.b("async"),
|
||||
print.b("move"),
|
||||
print.b("unsafe"),
|
||||
printBlockBody(print, node),
|
||||
];
|
||||
},
|
||||
[NodeType.LoopBlockExpression](print, node) {
|
||||
return [f`${print("label")}: `, "loop ", printBlockBody(print, node)];
|
||||
},
|
||||
[NodeType.WhileBlockExpression](print, node) {
|
||||
return [f`${print("label")}: `, "while ", printCondition(print, node), printBlockBody(print, node)];
|
||||
},
|
||||
[NodeType.ForInBlockExpression](print, node) {
|
||||
return [f`${print("label")}: `, "for ", print("pattern"), " in ", print("expression"), " ", printBlockBody(print, node)];
|
||||
},
|
||||
[NodeType.IfBlockExpression](print, node) {
|
||||
return [f`${print("label")}: `, printIfBlock(print, node)];
|
||||
},
|
||||
[NodeType.TryBlockExpression](print, node) {
|
||||
return [f`${print("label")}: `, "try ", printBlockBody(print, node)];
|
||||
},
|
||||
[NodeType.MatchExpression](print, node) {
|
||||
const id = Symbol("match");
|
||||
const expr = print("expression");
|
||||
const needs_parens = pathCall(node, "expression", needsParens);
|
||||
|
||||
let printed: Doc = [
|
||||
f`${print("label")}: `,
|
||||
"match ",
|
||||
needs_parens ? expr : group([indent([softline, expr]), softline], { id }),
|
||||
needs_parens ? " " : !willBreak(expr) ? ifBreak("", " ", { groupId: id }) : "" /* ifBreak("", " ", { groupId: id }) */,
|
||||
printBlockBody(print, node),
|
||||
];
|
||||
|
||||
const parent = getParentNode()!;
|
||||
if (is_ClosureFunctionExpression(parent) && parent.expression === node) {
|
||||
printed = parenthesize_if_break([indent([softline, printed]), softline]);
|
||||
}
|
||||
return printed;
|
||||
},
|
||||
[NodeType.MatchExpressionCase](print, node) {
|
||||
return group([
|
||||
group(print("pattern")),
|
||||
" ",
|
||||
printIfBlockCondition(print, node),
|
||||
"=>", //
|
||||
(is_BlockExpression(node.expression) || is_IfBlockExpression(node.expression)) &&
|
||||
!hasComment(node.expression, 0, (comment) => getOptions().danglingAttributes.includes(comment as any))
|
||||
? [" ", print("expression")]
|
||||
: group(indent([line, print("expression")])),
|
||||
]);
|
||||
return printAssignment(
|
||||
[print("pattern"), " ", printIfBlockCondition(print, node)], //
|
||||
"=>",
|
||||
"expression"
|
||||
);
|
||||
return [print("pattern"), " ", printIfBlockCondition(print, node)];
|
||||
},
|
||||
[NodeType.StructLiteral](print, node) {
|
||||
return [print("struct"), printObject(print, node)];
|
||||
},
|
||||
[NodeType.StructLiteralPropertyShorthand](print, node) {
|
||||
return print("value");
|
||||
},
|
||||
[NodeType.StructLiteralProperty](print, node) {
|
||||
return [print("key"), ": ", print("value")];
|
||||
},
|
||||
[NodeType.StructLiteralPropertySpread](print, node) {
|
||||
return ["..", print("expression")];
|
||||
},
|
||||
[NodeType.StructLiteralRestUnassigned](print, node) {
|
||||
return "..";
|
||||
},
|
||||
[NodeType.ArrayLiteral](print, node) {
|
||||
return printArrayLike(print, node);
|
||||
},
|
||||
[NodeType.SizedArrayLiteral](print, node) {
|
||||
return sg_duo`[${print("initExpression")};${print("sizeExpression")}]`;
|
||||
},
|
||||
[NodeType.TupleLiteral](print, node) {
|
||||
return printArrayLike(print, node);
|
||||
},
|
||||
[NodeType.ReferenceExpression](print, node) {
|
||||
return printUnaryExpression(["&", print.b("mut")], node);
|
||||
},
|
||||
[NodeType.RawReferenceExpression](print, node) {
|
||||
return printUnaryExpression(`&raw ${node.kind} `, node);
|
||||
},
|
||||
[NodeType.DereferenceExpression](print, node) {
|
||||
return printUnaryExpression("*", node);
|
||||
},
|
||||
[NodeType.BoxExpression](print, node) {
|
||||
return printUnaryExpression("box ", node);
|
||||
},
|
||||
[NodeType.UnionPattern](print, node) {
|
||||
return printUnionPattern(print, node);
|
||||
},
|
||||
[NodeType.ParenthesizedPattern](print, node) {
|
||||
exit.never();
|
||||
return sg_single`(${print("pattern")})`;
|
||||
},
|
||||
[NodeType.RestPattern](print, node) {
|
||||
return "..";
|
||||
},
|
||||
[NodeType.WildcardPattern](print, node) {
|
||||
return "_";
|
||||
},
|
||||
[NodeType.PatternVariableDeclaration](print, node) {
|
||||
return [print.b("ref"), print.b("mut"), printAssignment(print("id"), " @", "pattern")];
|
||||
},
|
||||
[NodeType.StructPattern](print, node) {
|
||||
return [print("struct"), printObject(print, node)];
|
||||
},
|
||||
[NodeType.StructPatternPropertyDestructured](print, node) {
|
||||
return [print("key"), ": ", print("pattern")];
|
||||
},
|
||||
[NodeType.StructPatternPropertyShorthand](print, node) {
|
||||
return [print.b("box"), print.b("ref"), print.b("mut"), print("id")];
|
||||
},
|
||||
[NodeType.TuplePattern](print, node) {
|
||||
return [print("struct"), printArrayLike(print, node)];
|
||||
},
|
||||
[NodeType.ArrayPattern](print, node) {
|
||||
return printArrayLike(print, node);
|
||||
},
|
||||
[NodeType.ReferencePattern](print, node) {
|
||||
return ["&", print.b("mut"), print("pattern")];
|
||||
},
|
||||
[NodeType.BoxPattern](print, node) {
|
||||
return ["box ", print("pattern")];
|
||||
},
|
||||
[NodeType.MinusPattern](print, node) {
|
||||
return ["-", print("pattern")];
|
||||
},
|
||||
[NodeType.RangePattern](print, node) {
|
||||
return [print("lower"), "..", print.b("last", "="), print("upper")];
|
||||
},
|
||||
[NodeType.TypeCall](print, node) {
|
||||
return [print("typeCallee"), printTypeArguments(print, node)];
|
||||
},
|
||||
[NodeType.TypeCallNamedArgument](print, node) {
|
||||
return printAssignment(print("target"), " =", "typeExpression");
|
||||
},
|
||||
[NodeType.TypeCallNamedBound](print, node) {
|
||||
return [print("typeTarget"), printTypeBounds(":", print, node)];
|
||||
},
|
||||
[NodeType.LtElided](print, node) {
|
||||
return "'_";
|
||||
},
|
||||
[NodeType.LtStatic](print, node) {
|
||||
return "'static";
|
||||
},
|
||||
[NodeType.TypeNever](print, node) {
|
||||
return "!";
|
||||
},
|
||||
[NodeType.TypeInferred](print, node) {
|
||||
return "_";
|
||||
},
|
||||
[NodeType.GenericTypeParameterDeclaration](print, node) {
|
||||
return printAssignment(
|
||||
[print("id"), printTypeBounds(":", print, node)], //
|
||||
" =",
|
||||
"typeDefault"
|
||||
);
|
||||
},
|
||||
[NodeType.ConstTypeParameterDeclaration](print, node) {
|
||||
return [
|
||||
"const ",
|
||||
printAssignment(
|
||||
[print("id"), printTypeAnnotation(print, node)], //
|
||||
" =",
|
||||
"typeDefault"
|
||||
),
|
||||
];
|
||||
},
|
||||
[NodeType.GenericLtParameterDeclaration](print, node) {
|
||||
return [print("id"), printLtBounds(":", print, node)];
|
||||
},
|
||||
[NodeType.WhereTypeBoundDeclaration](print, node) {
|
||||
return [printLtParameters(print, node), print("typeTarget"), printTypeBounds(":", print, node)];
|
||||
},
|
||||
[NodeType.WhereLtBoundDeclaration](print, node) {
|
||||
return [print("ltTarget"), printLtBounds(":", print, node)];
|
||||
},
|
||||
[NodeType.TypeTraitBound](print, node) {
|
||||
return [print.b("maybeConst", "~const "), print.b("optional", "?"), printLtParameters(print, node), print("typeExpression")];
|
||||
},
|
||||
[NodeType.TypeDynBounds](print, node) {
|
||||
return printTypeBounds("dyn", print, node);
|
||||
},
|
||||
[NodeType.TypeImplBounds](print, node) {
|
||||
return printTypeBounds("impl", print, node);
|
||||
},
|
||||
[NodeType.TypeFnPointer](print, node) {
|
||||
return [printLtParameters(print, node), print.b("unsafe"), print("extern"), "fn", printParametersAndReturnType(node)];
|
||||
},
|
||||
[NodeType.TypeFnPointerParameter](print, node) {
|
||||
return [f`${print("id")}: `, print("typeAnnotation")];
|
||||
},
|
||||
[NodeType.TypeFunction](print, node) {
|
||||
return [print("callee"), printParametersAndReturnType(node)];
|
||||
},
|
||||
[NodeType.TypeTuple](print, node) {
|
||||
return printArrayLike(print, node);
|
||||
},
|
||||
[NodeType.TypeSizedArray](print, node) {
|
||||
return sg_duo`[${print("typeExpression")};${print("sizeExpression")}]`;
|
||||
if (isSimpleType(node)) return ["[", print("typeExpression"), "; ", print("sizeExpression"), "]"];
|
||||
},
|
||||
[NodeType.TypeSlice](print, node) {
|
||||
if (isSimpleType(node)) return ["[", print("typeExpression"), "]"];
|
||||
return sg_single`[${print("typeExpression")}]`;
|
||||
},
|
||||
[NodeType.TypeReference](print, node) {
|
||||
return ["&", f`${print("lt")} `, print.b("mut"), print("typeExpression")];
|
||||
},
|
||||
[NodeType.TypeDereferenceConst](print, node) {
|
||||
return ["*const ", print("typeExpression")];
|
||||
},
|
||||
[NodeType.TypeDereferenceMut](print, node) {
|
||||
return ["*mut ", print("typeExpression")];
|
||||
},
|
||||
[NodeType.TypeParenthesized](print, node) {
|
||||
exit.never();
|
||||
return sg_single`(${print("typeExpression")})`;
|
||||
},
|
||||
};
|
||||
645
frontend/src/common/prettier/plugins/rust/format/styling.ts
Normal file
645
frontend/src/common/prettier/plugins/rust/format/styling.ts
Normal file
@@ -0,0 +1,645 @@
|
||||
import {
|
||||
ClosureFunctionExpression,
|
||||
ComparisonExpression,
|
||||
ConditionExpression,
|
||||
EnumDeclaration,
|
||||
EnumMemberStructDeclaration,
|
||||
ExpressionAsTypeCast,
|
||||
ExpressionNode,
|
||||
ExpressionStatement,
|
||||
ExpressionWithBody,
|
||||
LeftRightExpression,
|
||||
LogicalExpression,
|
||||
MacroDeclaration,
|
||||
MacroRulesDeclaration,
|
||||
MissingNode,
|
||||
Node,
|
||||
NodeType,
|
||||
NodeWithBody,
|
||||
NodeWithBodyOrCases,
|
||||
OperationExpression,
|
||||
PRCD,
|
||||
StructDeclaration,
|
||||
StructLiteral,
|
||||
StructPattern,
|
||||
TK,
|
||||
UnionDeclaration,
|
||||
} from "jinx-rust";
|
||||
import {
|
||||
can_have_OuterAttributes,
|
||||
getAstPath,
|
||||
getPrecedence,
|
||||
hasAttributes,
|
||||
hasBody,
|
||||
hasCondition,
|
||||
hasItems,
|
||||
hasLetScrutineeCondition,
|
||||
hasOuterAttributes,
|
||||
hasProperties,
|
||||
is_Attribute,
|
||||
is_AttributeOrDocComment,
|
||||
is_AwaitExpression,
|
||||
is_BitwiseOperator,
|
||||
is_CallExpression,
|
||||
is_ClosureFunctionExpression,
|
||||
is_ComparisonExpression,
|
||||
is_DocCommentAttribute,
|
||||
is_ElseBlock,
|
||||
is_EnumMemberDeclaration,
|
||||
is_EqualityOperator,
|
||||
is_ExpressionAsTypeCast,
|
||||
is_ExpressionStatement,
|
||||
is_ExpressionWithBody,
|
||||
is_ExpressionWithBodyOrCases,
|
||||
is_ExpressionWithBodyOrCases_or_BlockLikeMacroInvocation,
|
||||
is_FlowControlExpression,
|
||||
is_FlowControlMaybeValueExpression,
|
||||
is_ForInBlockExpression,
|
||||
is_Identifier,
|
||||
is_IfBlockExpression,
|
||||
is_ImplicitReturnAbleNode,
|
||||
is_LeftRightExpression,
|
||||
is_LetScrutinee,
|
||||
is_Literal,
|
||||
is_LiteralNumberLike,
|
||||
is_LogicalExpression,
|
||||
is_LoopBlockExpression,
|
||||
is_MatchExpression,
|
||||
is_MatchExpressionCase,
|
||||
is_MemberExpression,
|
||||
is_NodeWithBodyNoBody,
|
||||
is_NodeWithMaybePatternNoUnionBody,
|
||||
is_OperationExpression,
|
||||
is_ParenthesizedNode,
|
||||
is_PatternVariableDeclaration,
|
||||
is_PostfixExpression,
|
||||
is_RangeLiteral,
|
||||
is_ReassignmentNode,
|
||||
is_ReturnExpression,
|
||||
is_StatementNode,
|
||||
is_StructLiteral,
|
||||
is_StructLiteralProperty,
|
||||
is_StructPatternProperty,
|
||||
is_StructPropertyDeclaration,
|
||||
is_TypeBoundsStandaloneNode,
|
||||
is_TypeFunctionNode,
|
||||
is_TypeTraitBound,
|
||||
is_UnaryExpression,
|
||||
is_UnaryType,
|
||||
is_UnionPattern,
|
||||
is_WhileBlockExpression,
|
||||
is_YieldExpression,
|
||||
is_bitshiftOperator,
|
||||
is_multiplicativeOperator,
|
||||
} from "jinx-rust/utils";
|
||||
import { BlockLikeMacroInvocation, is_BlockLikeMacroInvocation, is_CallExpression_or_CallLikeMacroInvocation } from "../transform";
|
||||
import { exit, last_of } from "../utils/common";
|
||||
import { CF, hasBreaklineAfter, hasComment } from "./comments";
|
||||
import { flowControlExpressionNeedsOuterParens } from "./core";
|
||||
import { Doc, hardline, softline, willBreak } from "./external";
|
||||
import {
|
||||
assertPathAtNode,
|
||||
getContext,
|
||||
getGrandParentNode,
|
||||
getNode,
|
||||
getOptions,
|
||||
getParentNode,
|
||||
getPrintFn,
|
||||
is_printing_macro,
|
||||
pathCallAtParent,
|
||||
pathCallParentOf,
|
||||
stackIncludes,
|
||||
} from "./plugin";
|
||||
|
||||
export function needsOuterSoftbreakParens(node: Node) {
|
||||
const parent = getParentNode(node);
|
||||
|
||||
if (!parent) return false;
|
||||
|
||||
if (is_ExpressionAsTypeCast(node)) {
|
||||
return precedenceNeedsParens(node, parent);
|
||||
}
|
||||
|
||||
if (
|
||||
is_FlowControlMaybeValueExpression(parent) && //
|
||||
parent.expression === node &&
|
||||
flowControlExpressionNeedsOuterParens(parent)
|
||||
) {
|
||||
return true;
|
||||
}
|
||||
if (
|
||||
is_ExpressionWithBodyOrCases_or_BlockLikeMacroInvocation(node) &&
|
||||
(false ||
|
||||
(is_MemberExpression(parent) && parent.expression === node) ||
|
||||
(is_ExpressionWithBodyOrCases_or_BlockLikeMacroInvocation(parent) && !is_ElseBlock(node, parent)))
|
||||
) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (is_UnionPattern(node) && is_NodeWithMaybePatternNoUnionBody(parent)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (hasComment(node)) {
|
||||
if (is_UnaryExpression(parent)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (hasComment(node, CF.Line)) {
|
||||
if (is_ReturnExpression(parent) || (is_YieldExpression(parent) && parent.expression === node)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
if (
|
||||
hasComment(node, CF.Leading, (comment) => is_Attribute(comment) && !comment.inner) &&
|
||||
!can_have_OuterAttributes(node, parent, true)
|
||||
) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
export function needsInnerParens(node: Node) {
|
||||
if (needsOuterSoftbreakParens(node)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const parent = getParentNode(node);
|
||||
|
||||
if (!parent) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (is_Identifier(node)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (is_Literal(node)) {
|
||||
return is_LiteralNumberLike(node) && is_MemberExpression(parent) && node === parent.expression;
|
||||
}
|
||||
|
||||
if (is_CallExpression(parent) && parent.callee === node && is_MemberExpression(node)) {
|
||||
return !getOptions().actuallyMethodNodes.has(node);
|
||||
}
|
||||
|
||||
if (is_ReassignmentNode(node)) {
|
||||
if (is_printing_macro()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (is_ClosureFunctionExpression(parent) && node === parent.expression) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (is_ExpressionStatement(parent)) {
|
||||
return is_StructLiteral(node.left);
|
||||
}
|
||||
|
||||
if (is_ReassignmentNode(parent)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
if (is_ParenthesizedNode(parent)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (is_ExpressionStatement(parent)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (is_RangeLiteral(node)) {
|
||||
return (
|
||||
is_ExpressionAsTypeCast(parent) ||
|
||||
is_LogicalExpression(parent) ||
|
||||
is_UnaryExpression(parent) ||
|
||||
is_PostfixExpression(parent) ||
|
||||
(is_MemberExpression(parent) && node === parent.expression) ||
|
||||
(is_CallExpression(parent) && node === parent.callee) ||
|
||||
is_OperationExpression(parent) ||
|
||||
is_ComparisonExpression(parent)
|
||||
);
|
||||
}
|
||||
|
||||
if (is_LetScrutinee(parent) && is_LogicalExpression(node) && parent.expression === (node as any)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (is_UnaryExpression(node)) {
|
||||
switch (parent.nodeType) {
|
||||
case NodeType.MemberExpression:
|
||||
case NodeType.AwaitExpression:
|
||||
return node === parent.expression;
|
||||
case NodeType.CallExpression:
|
||||
return node === parent.callee;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
if (is_ExpressionWithBodyOrCases_or_BlockLikeMacroInvocation(node)) {
|
||||
if (is_ExpressionWithBodyOrCases(parent)) {
|
||||
return !is_ElseBlock(node, parent);
|
||||
}
|
||||
if (is_LetScrutinee(parent) && parent.expression === node && is_ExpressionWithBodyOrCases(getGrandParentNode())) {
|
||||
return true;
|
||||
}
|
||||
return (
|
||||
is_ExpressionAsTypeCast(parent) ||
|
||||
is_LogicalExpression(parent) ||
|
||||
is_UnaryExpression(parent) ||
|
||||
is_PostfixExpression(parent) ||
|
||||
(is_MemberExpression(parent) && node === parent.expression) ||
|
||||
(is_CallExpression(parent) && node === parent.callee) ||
|
||||
is_OperationExpression(parent) ||
|
||||
is_ComparisonExpression(parent) ||
|
||||
is_RangeLiteral(parent)
|
||||
);
|
||||
}
|
||||
|
||||
if (is_StructLiteral(node)) {
|
||||
if (is_ExpressionWithBodyOrCases(parent)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (is_LetScrutinee(parent) && parent.expression === node && is_ExpressionWithBodyOrCases(getGrandParentNode())) {
|
||||
return true;
|
||||
}
|
||||
if (is_UnaryExpression(parent) || is_PostfixExpression(parent) || is_MemberExpression(parent)) {
|
||||
return parent.expression === node;
|
||||
}
|
||||
if (is_CallExpression(parent)) {
|
||||
return parent.callee === node;
|
||||
}
|
||||
}
|
||||
|
||||
if (is_LogicalExpression(node) || is_OperationExpression(node) || is_ComparisonExpression(node) || is_ClosureFunctionExpression(node)) {
|
||||
return precedenceNeedsParens(node, parent);
|
||||
}
|
||||
|
||||
if (is_TypeFunctionNode(node)) {
|
||||
const gp = getGrandParentNode();
|
||||
if (node.returnType && is_TypeTraitBound(parent) && is_TypeBoundsStandaloneNode(gp) && last_of(gp.typeBounds) !== parent) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
if (is_TypeBoundsStandaloneNode(node)) {
|
||||
return (
|
||||
(is_UnaryType(parent) && node.typeBounds.length > 1) ||
|
||||
is_TypeBoundsStandaloneNode(parent) ||
|
||||
is_TypeTraitBound(parent) ||
|
||||
(is_TypeFunctionNode(parent) && parent.returnType === node)
|
||||
);
|
||||
}
|
||||
|
||||
if (is_PatternVariableDeclaration(parent)) {
|
||||
return is_UnionPattern(node);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
function precedenceNeedsParens(node: LeftRightExpression | ClosureFunctionExpression | ExpressionAsTypeCast, parent: Node) {
|
||||
if (is_UnaryExpression(parent) || is_PostfixExpression(parent)) return true;
|
||||
if (is_ReassignmentNode(parent)) return parent.left === node;
|
||||
if (is_MemberExpression(parent)) return parent.expression === node;
|
||||
if (is_CallExpression(parent)) return parent.callee === node;
|
||||
if (is_ExpressionAsTypeCast(parent)) return !is_ExpressionAsTypeCast(node);
|
||||
if (is_LogicalExpression(parent)) return is_LogicalExpression(node) ? parent.nodeType !== node.nodeType : evalPrecedence(node, parent);
|
||||
if (is_OperationExpression(parent) || is_ComparisonExpression(parent)) return evalPrecedence(node, parent);
|
||||
return false;
|
||||
function evalPrecedence(
|
||||
child: LeftRightExpression | ClosureFunctionExpression | ExpressionAsTypeCast,
|
||||
parent: ComparisonExpression | OperationExpression | LogicalExpression
|
||||
) {
|
||||
if (is_ExpressionAsTypeCast(child) || is_ClosureFunctionExpression(child)) {
|
||||
return true;
|
||||
}
|
||||
function getPrec(node, bool) {
|
||||
// if (is_EqualityOperator(node.tk)) {
|
||||
// return 11.3;
|
||||
// }
|
||||
// if (is_LargerLesserOperator(node.tk)) {
|
||||
// return 11.6;
|
||||
// }
|
||||
return getPrecedence(node, bool);
|
||||
}
|
||||
|
||||
const childPRCD = getPrec(child, is_insideScrutinee(child));
|
||||
const parentPRCD = getPrec(parent, is_insideScrutinee(parent));
|
||||
|
||||
if (parentPRCD > childPRCD) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (parentPRCD === childPRCD && parent.right === child) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (parentPRCD === childPRCD && !shouldFlatten(parent, child)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (parentPRCD < childPRCD && child.tk === TK["%"]) {
|
||||
return parentPRCD === PRCD["+-"];
|
||||
}
|
||||
|
||||
if (is_BitwiseOperator(parent.tk) || (is_BitwiseOperator(child.tk) && is_EqualityOperator(parent.tk))) {
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
export function shouldFlatten(parent: ExpressionNode | ConditionExpression, node: ExpressionNode | ConditionExpression) {
|
||||
if (getPrecedence(node, is_insideScrutinee(node)) !== getPrecedence(parent, is_insideScrutinee(parent))) return false;
|
||||
if (is_ComparisonExpression(parent) && is_ComparisonExpression(node)) return false;
|
||||
if (is_OperationExpression(parent) && is_OperationExpression(node)) {
|
||||
if (
|
||||
(node.tk === TK["%"] && is_multiplicativeOperator(parent.tk)) ||
|
||||
(parent.tk === TK["%"] && is_multiplicativeOperator(node.tk)) ||
|
||||
(node.tk !== parent.tk && is_multiplicativeOperator(node.tk) && is_multiplicativeOperator(parent.tk)) ||
|
||||
(is_bitshiftOperator(node.tk) && is_bitshiftOperator(parent.tk))
|
||||
)
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
export function needsParens(node: Node) {
|
||||
return needsOuterSoftbreakParens(node) || needsInnerParens(node);
|
||||
}
|
||||
|
||||
export function stmtNeedsSemi(stmt: ExpressionStatement, disregardExprType = false) {
|
||||
return pathCallParentOf(stmt, (parent) => needsSemi(parent as any, stmt, disregardExprType));
|
||||
}
|
||||
|
||||
const NoNode = { nodeType: 0 } as MissingNode;
|
||||
|
||||
export function needsSemi(parent: NodeWithBody, stmt: ExpressionStatement, disregardExprType = false) {
|
||||
const expr = disregardExprType ? NoNode : stmt.expression!;
|
||||
const hadSemi = !disregardExprType && stmt.semi;
|
||||
|
||||
return (
|
||||
!!expr &&
|
||||
(forcePreserveSemi()
|
||||
? true
|
||||
: shouldNeverSemi()
|
||||
? false
|
||||
: shouldPreserveSemi()
|
||||
? hadSemi || shouldAlwaysSemi() || canAutoCompleteSemi()
|
||||
: true)
|
||||
);
|
||||
|
||||
function forcePreserveSemi() {
|
||||
/** Rust Compiler bug (preserve optional semicolon) */
|
||||
// rust-lang/rust#70844 https://github.com/rust-lang/rust/issues/70844
|
||||
// issue#22 https://github.com/jinxdash/prettier-plugin-rust/issues/22
|
||||
return (
|
||||
hadSemi &&
|
||||
stmt === last_of(parent.body!) &&
|
||||
((is_IfBlockExpression(expr) &&
|
||||
hasLetScrutineeCondition(expr) &&
|
||||
!(is_LetScrutinee(expr.condition) && is_Identifier(expr.condition.expression))) ||
|
||||
(is_MatchExpression(expr) && !is_Identifier(expr.expression)))
|
||||
);
|
||||
}
|
||||
function shouldNeverSemi() {
|
||||
return is_ExpressionWithBodyOrCases_or_BlockLikeMacroInvocation(expr);
|
||||
}
|
||||
function shouldPreserveSemi() {
|
||||
return stmt === last_of(parent.body!) && (is_ImplicitReturnAbleNode(parent) || is_BlockLikeMacroInvocation(parent));
|
||||
}
|
||||
function shouldAlwaysSemi() {
|
||||
return is_FlowControlExpression(expr) || is_ReassignmentNode(expr);
|
||||
}
|
||||
function canAutoCompleteSemi() {
|
||||
return withPathAt(parent, function checkParent(child: NodeWithBodyOrCases): boolean {
|
||||
return pathCallParentOf(child, (parent) => {
|
||||
if (is_IfBlockExpression(parent) && parent.else === child) {
|
||||
// if ... { ... } else if { ... } ...
|
||||
// ^ ------------------------------- parent
|
||||
// ^ ----------- child
|
||||
return checkParent(parent);
|
||||
}
|
||||
if (is_ExpressionStatement(parent)) {
|
||||
// { .... { ... } ... }
|
||||
// ^ -----------------^ grandparent
|
||||
// ^ --- ^ ExpressionStatement<child>
|
||||
if (hasOuterAttributes(parent)) return false;
|
||||
return stmtNeedsSemi(parent, true);
|
||||
}
|
||||
if (is_MatchExpressionCase(parent) && parent.expression === child) {
|
||||
return pathCallParentOf(parent, checkParent);
|
||||
}
|
||||
return false;
|
||||
});
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
export function canInlineBlockBody(node: NodeWithBodyOrCases | BlockLikeMacroInvocation): boolean {
|
||||
if (!is_ExpressionWithBody(node)) {
|
||||
return false;
|
||||
}
|
||||
const body = node.body;
|
||||
|
||||
if (body.length === 0) {
|
||||
return canInlineInlineable(node);
|
||||
}
|
||||
|
||||
if (body.length === 1) {
|
||||
const stmt = body[0];
|
||||
if (is_AttributeOrDocComment(stmt)) {
|
||||
return true;
|
||||
}
|
||||
if (is_ExpressionStatement(stmt) && !needsSemi(node, stmt)) {
|
||||
/**
|
||||
* parent ( ExpressionStatement | StructLiteralProperty | LetVariableDeclaration | ... )
|
||||
* ...
|
||||
* node {
|
||||
* expr
|
||||
* }
|
||||
* ...
|
||||
*
|
||||
*
|
||||
* Q: Can you inline "node { expr }" ?
|
||||
*/
|
||||
const expr = stmt.expression!;
|
||||
|
||||
if (
|
||||
is_FlowControlExpression(expr) || //
|
||||
is_ClosureFunctionExpression(expr) ||
|
||||
is_ExpressionWithBodyOrCases_or_BlockLikeMacroInvocation(expr)
|
||||
) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return canInlineInlineable(node);
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// function q(node: ExpressionWithBody) {
|
||||
// pathCallTopMostIfBlockExpression(node, (node) => {});
|
||||
// }
|
||||
|
||||
function canInlineInlineable(node: ExpressionWithBody) {
|
||||
if (is_ForInBlockExpression(node) || is_LoopBlockExpression(node)) {
|
||||
return false;
|
||||
}
|
||||
if (is_WhileBlockExpression(node)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
const parent = getParentNode(node)!;
|
||||
|
||||
if (
|
||||
is_ExpressionStatement(parent) &&
|
||||
(!is_ImplicitReturnAbleNode(node) || pathCallAtParent(parent, (parent) => stmtNeedsSemi(parent, true)))
|
||||
) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (is_ElseBlock(node, parent)) {
|
||||
return pathCallAtParent(parent, canInlineBlockBody);
|
||||
}
|
||||
// if (is_CaseBlock(node, parent)) {
|
||||
// return false;
|
||||
// }
|
||||
if (is_IfBlockExpression(node)) {
|
||||
if (
|
||||
!node.else ||
|
||||
// hasLetScrutineeCondition(node) ||
|
||||
is_ExpressionWithBodyOrCases_or_BlockLikeMacroInvocation(node.condition) ||
|
||||
willBreak(getPrintFn(node)("condition"))
|
||||
) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const grandparent = getGrandParentNode();
|
||||
if (is_ExpressionStatement(parent) && hasBody(grandparent) && grandparent.body.length > 1) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
return (
|
||||
is_CallExpression_or_CallLikeMacroInvocation(parent) ||
|
||||
hasItems(parent) ||
|
||||
hasProperties(parent) ||
|
||||
is_ClosureFunctionExpression(parent) ||
|
||||
is_MemberExpression(parent) ||
|
||||
is_AwaitExpression(parent) ||
|
||||
is_LeftRightExpression(parent)
|
||||
);
|
||||
}
|
||||
|
||||
type NodeWithBracketContent =
|
||||
| NodeWithBodyOrCases
|
||||
| BlockLikeMacroInvocation
|
||||
| EnumDeclaration
|
||||
| StructDeclaration
|
||||
| StructLiteral
|
||||
| StructPattern
|
||||
| EnumMemberStructDeclaration
|
||||
| UnionDeclaration
|
||||
| MacroRulesDeclaration
|
||||
| MacroDeclaration;
|
||||
|
||||
export function emptyContent(node: NodeWithBracketContent): Doc {
|
||||
switch (node.nodeType) {
|
||||
case NodeType.Program:
|
||||
case NodeType.MacroRulesDeclaration:
|
||||
case NodeType.MacroDeclaration:
|
||||
case NodeType.ExternBlockDeclaration:
|
||||
case NodeType.ModuleDeclaration:
|
||||
case NodeType.TraitDeclaration:
|
||||
case NodeType.StructDeclaration:
|
||||
case NodeType.MacroInvocation:
|
||||
case NodeType.FunctionDeclaration:
|
||||
case NodeType.ImplDeclaration:
|
||||
case NodeType.UnionDeclaration:
|
||||
case NodeType.EnumDeclaration:
|
||||
case NodeType.EnumMemberStructDeclaration:
|
||||
case NodeType.StructLiteral:
|
||||
case NodeType.StructPattern:
|
||||
// case NodeType.MatchExpression:
|
||||
return "";
|
||||
case NodeType.BlockExpression:
|
||||
case NodeType.WhileBlockExpression:
|
||||
case NodeType.ForInBlockExpression:
|
||||
case NodeType.TryBlockExpression:
|
||||
case NodeType.IfBlockExpression:
|
||||
return canInlineInlineable(node)
|
||||
? is_IfBlockExpression(node) || is_ElseBlock(node, getParentNode()!)
|
||||
? softline
|
||||
: ""
|
||||
: hardline;
|
||||
case NodeType.LoopBlockExpression:
|
||||
case NodeType.MatchExpression:
|
||||
return hardline;
|
||||
default:
|
||||
if (is_NodeWithBodyNoBody(node)) {
|
||||
return "";
|
||||
}
|
||||
__DEV__: exit.never(node);
|
||||
return "";
|
||||
}
|
||||
}
|
||||
|
||||
export function is_insideScrutinee(target: Node) {
|
||||
return withPathAt(target, (n) => stackIncludes("condition") && r(n));
|
||||
function r(CHILD: Node) {
|
||||
switch (CHILD.nodeType) {
|
||||
case NodeType.OrExpression:
|
||||
case NodeType.AndExpression:
|
||||
return pathCallParentOf(CHILD, (PARENT) =>
|
||||
hasCondition(PARENT) && PARENT.condition === CHILD //
|
||||
? hasLetScrutineeCondition(PARENT)
|
||||
: r(PARENT)
|
||||
);
|
||||
case NodeType.LetScrutinee:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function withPathAt<T extends Node, R>(target: T, callback: (target: T) => R): R {
|
||||
if (target === getNode()) return callback(target);
|
||||
if (target === getParentNode()) return pathCallAtParent(target, () => callback(target));
|
||||
if (stackIncludes(target)) return pathCallAtParent(getParentNode()!, () => withPathAt(target, callback));
|
||||
return getContext().path.call(() => {
|
||||
__DEV__: assertPathAtNode("withPathAt", target);
|
||||
return callback(target); // @ts-ignore
|
||||
}, ...getAstPath(getNode(), target));
|
||||
}
|
||||
export function shouldPrintOuterAttributesAbove(node: Node) {
|
||||
return (
|
||||
is_StatementNode(node) ||
|
||||
is_MatchExpressionCase(node) ||
|
||||
(hasAttributes(node) &&
|
||||
node.attributes.some(
|
||||
canInlineOuterAttribute(node)
|
||||
? (attr) => is_DocCommentAttribute(attr) || hasBreaklineAfter(attr) //
|
||||
: is_DocCommentAttribute
|
||||
))
|
||||
);
|
||||
function canInlineOuterAttribute(node: Node) {
|
||||
return (
|
||||
is_EnumMemberDeclaration(node) ||
|
||||
is_StructPropertyDeclaration(node) ||
|
||||
is_StructLiteralProperty(node) ||
|
||||
is_StructPatternProperty(node)
|
||||
);
|
||||
}
|
||||
}
|
||||
8
frontend/src/common/prettier/plugins/rust/index.ts
Normal file
8
frontend/src/common/prettier/plugins/rust/index.ts
Normal file
@@ -0,0 +1,8 @@
|
||||
import { plugin } from "./format/plugin";
|
||||
|
||||
export default plugin;
|
||||
export const languages = plugin.languages;
|
||||
export const parsers = plugin.parsers;
|
||||
export const printers = plugin.printers;
|
||||
export const options = plugin.options;
|
||||
export const defaultOptions = plugin.defaultOptions;
|
||||
@@ -0,0 +1,116 @@
|
||||
import {
|
||||
AttrSegment,
|
||||
CallExpression,
|
||||
DelimKind,
|
||||
ExpressionPath,
|
||||
Identifier,
|
||||
Literal,
|
||||
LocArray,
|
||||
MacroInvocation,
|
||||
NodeType,
|
||||
PunctuationToken,
|
||||
ReassignmentExpression,
|
||||
TK,
|
||||
rs,
|
||||
} from "jinx-rust";
|
||||
import { isTK, start } from "jinx-rust/utils";
|
||||
import { assert, exit } from "../../utils/common";
|
||||
import { isIdent } from "./utils";
|
||||
|
||||
type SimpleAttrItem =
|
||||
| Identifier //
|
||||
| Literal
|
||||
| ExpressionPath
|
||||
| CallExpression
|
||||
| ReassignmentExpression
|
||||
| MacroInvocation;
|
||||
|
||||
export function transform_simpleAttrSyntax(segments: MacroInvocation["segments"]) {
|
||||
assert(segments.length !== 0, segments.loc.url());
|
||||
return transform_segments(segments, false);
|
||||
|
||||
function transform_segments<N extends boolean>(
|
||||
seq: LocArray<AttrSegment>,
|
||||
nestedCall: N
|
||||
): N extends true ? LocArray<SimpleAttrItem, "()"> : SimpleAttrItem {
|
||||
let i = 0;
|
||||
|
||||
if (nestedCall) {
|
||||
const args = rs.createLocArray<SimpleAttrItem, any>(DelimKind["()"], seq.loc.clone());
|
||||
while (i !== seq.length) {
|
||||
args.push(read(true));
|
||||
if (i === seq.length) break;
|
||||
assert(isTK(seq[i++], TK[","]));
|
||||
}
|
||||
return args as any;
|
||||
} else {
|
||||
const res = read(true);
|
||||
assert(i === seq.length, res.loc.url());
|
||||
return res as any;
|
||||
}
|
||||
|
||||
function read(allowEq: boolean): SimpleAttrItem {
|
||||
let lhs: Identifier | ExpressionPath;
|
||||
|
||||
switch (seq[i].nodeType) {
|
||||
case NodeType.Literal:
|
||||
return seq[i++] as Literal;
|
||||
case NodeType.Identifier:
|
||||
lhs = seq[i++] as Identifier;
|
||||
break;
|
||||
case NodeType.PunctuationToken:
|
||||
assert((seq[i] as PunctuationToken).tk === TK["::"], seq[i].loc.url());
|
||||
lhs = eatPathSegment(undefined);
|
||||
break;
|
||||
default:
|
||||
exit.never();
|
||||
}
|
||||
|
||||
while (true) {
|
||||
if (i === seq.length) return lhs;
|
||||
const seg = seq[i];
|
||||
switch (seg.nodeType) {
|
||||
case NodeType.PunctuationToken:
|
||||
switch (seg.tk) {
|
||||
case TK[","]:
|
||||
assert(nestedCall);
|
||||
return lhs;
|
||||
case TK["="]: {
|
||||
assert(allowEq);
|
||||
const right = (i++, read(false));
|
||||
return rs.mockNode(NodeType.ReassignmentExpression, right.loc.cloneFrom(start(lhs)), {
|
||||
tk: TK["="],
|
||||
kind: DelimKind["="],
|
||||
left: lhs,
|
||||
right,
|
||||
});
|
||||
}
|
||||
case TK["::"]:
|
||||
lhs = eatPathSegment(lhs);
|
||||
continue;
|
||||
default:
|
||||
exit.never();
|
||||
}
|
||||
case NodeType.DelimGroup:
|
||||
assert(seg.segments.dk === DelimKind["()"]);
|
||||
return rs.mockNode(NodeType.CallExpression, seq[i++].loc.cloneFrom(start(lhs)), {
|
||||
callee: lhs,
|
||||
typeArguments: undefined,
|
||||
method: undefined,
|
||||
arguments: transform_segments(seg.segments, true),
|
||||
});
|
||||
default:
|
||||
exit.never();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function eatPathSegment(left: undefined | Identifier | ExpressionPath) {
|
||||
const segment = seq[i + 1];
|
||||
assert(isIdent(segment));
|
||||
const res = rs.mockNode(NodeType.ExpressionPath, segment.loc.cloneFrom(start(left ?? seq[i])), { namespace: left, segment });
|
||||
i += 2;
|
||||
return res;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,92 @@
|
||||
import {
|
||||
DelimGroup,
|
||||
DelimKind,
|
||||
IfBlockExpression,
|
||||
LocArray,
|
||||
MacroInvocation,
|
||||
NodeType,
|
||||
NodeWithBody,
|
||||
rs,
|
||||
Segment,
|
||||
Snippet,
|
||||
StatementNode,
|
||||
TK,
|
||||
} from "jinx-rust";
|
||||
import { insertNodes, start, transferAttributes } from "jinx-rust/utils";
|
||||
import { assert, iLast } from "../../utils/common";
|
||||
import { isGroup, isIdent, isToken } from "./utils";
|
||||
|
||||
export function transform_macro_cfg_if(segments: MacroInvocation["segments"]) {
|
||||
const danglingAttributes: Snippet["danglingAttributes"] = [];
|
||||
const comments: Snippet["comments"] = [];
|
||||
|
||||
const block = (function create_if_block(i: number): IfBlockExpression | undefined {
|
||||
if (i >= segments.length) return undefined;
|
||||
|
||||
const _if = segments[i];
|
||||
const pound = segments[i + 1];
|
||||
const grp = segments[i + 2];
|
||||
const block = segments[i + 3];
|
||||
const _else = segments[i + 4];
|
||||
|
||||
assert(
|
||||
isIdent(_if, "if") &&
|
||||
isToken(pound, TK["#"]) &&
|
||||
isGroup(grp, DelimKind["[]"]) &&
|
||||
isGroup(block, DelimKind["{}"]) &&
|
||||
(!_else || isIdent(_else, "else"))
|
||||
);
|
||||
|
||||
return create_block(block, (body) =>
|
||||
rs.mockNode(NodeType.IfBlockExpression, block.loc.cloneFrom(start(_if)), {
|
||||
label: undefined,
|
||||
condition: rs.mockNode(NodeType.Attribute, grp.loc.cloneFrom(start(pound)), {
|
||||
segments: grp.segments,
|
||||
value: grp.segments.loc.sliceText(),
|
||||
line: false,
|
||||
inner: false,
|
||||
}) as any,
|
||||
body: body,
|
||||
else: (_else && iLast(i + 5, segments)
|
||||
? function create_else_block(i: number) {
|
||||
const block = segments[i];
|
||||
assert(isGroup(block, DelimKind["{}"]));
|
||||
return create_block(block, (body) =>
|
||||
rs.mockNode(NodeType.BlockExpression, body.loc.clone(), {
|
||||
label: undefined,
|
||||
body,
|
||||
})
|
||||
);
|
||||
}
|
||||
: create_if_block)(i + 5),
|
||||
})
|
||||
);
|
||||
})(0);
|
||||
|
||||
const ast = rs.createLocArray(
|
||||
segments.dk,
|
||||
segments.loc,
|
||||
block && [
|
||||
rs.mockNode(NodeType.ExpressionStatement, block.loc.clone(), {
|
||||
expression: block,
|
||||
semi: false,
|
||||
}),
|
||||
]
|
||||
);
|
||||
|
||||
return rs.mockNode(NodeType.Snippet, segments.loc.clone(), { ast, danglingAttributes, comments });
|
||||
|
||||
function create_block<R extends NodeWithBody>(
|
||||
group: DelimGroup<Segment> & { segments: { dk: 3 } },
|
||||
fn: (statements: LocArray<StatementNode, "{}">) => R
|
||||
): R {
|
||||
const snippet = rs.toBlockBody(group.segments);
|
||||
|
||||
insertNodes(danglingAttributes, snippet.danglingAttributes);
|
||||
insertNodes(comments, snippet.comments);
|
||||
|
||||
const block = fn(snippet.ast);
|
||||
transferAttributes(snippet, block);
|
||||
return block;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
import { DelimGroup, DelimKind, Identifier, LocArray, PunctuationToken, Segment, TK } from "jinx-rust";
|
||||
import { isTK, is_DelimGroup, is_Identifier, is_PunctuationToken } from "jinx-rust/utils";
|
||||
|
||||
export function isIdent(node: Segment | undefined, name?: string): node is Identifier {
|
||||
return !!node && is_Identifier(node) && (null == name || node.name === name);
|
||||
}
|
||||
export function isToken(node: Segment | undefined, tk?: TK): node is PunctuationToken {
|
||||
return !!node && (null == tk ? is_PunctuationToken(node) : isTK(node, tk));
|
||||
}
|
||||
export function isGroup<D extends DelimKind>(node: Segment | undefined, dk?: D): node is DelimGroup & { segments: LocArray<any, D> } {
|
||||
return !!node && is_DelimGroup(node) && (null == dk || node.segments.dk === dk);
|
||||
}
|
||||
|
||||
export function isCallLike(tk_1: Segment | undefined, tk_2: Segment | undefined): boolean {
|
||||
return !!tk_1 && !!tk_2 && is_Identifier(tk_1) && is_DelimGroup(tk_2) && tk_2.segments.dk === DelimKind["()"];
|
||||
}
|
||||
568
frontend/src/common/prettier/plugins/rust/transform/index.ts
Normal file
568
frontend/src/common/prettier/plugins/rust/transform/index.ts
Normal file
@@ -0,0 +1,568 @@
|
||||
import {
|
||||
Attribute,
|
||||
AttributeOrDocComment,
|
||||
CallExpression,
|
||||
DelimKind,
|
||||
ExpressionNode,
|
||||
LocArray,
|
||||
MacroInvocation,
|
||||
MemberExpression,
|
||||
Node,
|
||||
NodeType,
|
||||
NodeWithBodyNoBody,
|
||||
NodeWithTypeBounds,
|
||||
NTMap,
|
||||
ProgramLike,
|
||||
rs,
|
||||
Snippet,
|
||||
StatementNode,
|
||||
StructLiteral,
|
||||
StructPattern,
|
||||
TK,
|
||||
TypeBound,
|
||||
TypeBoundsStandaloneNode,
|
||||
TypeDynBounds,
|
||||
TypeTraitBound,
|
||||
} from "jinx-rust";
|
||||
import {
|
||||
countActualNodeChildren,
|
||||
deleteAttributes,
|
||||
each_childNode,
|
||||
end,
|
||||
getActualNodeChildren,
|
||||
getBodyOrCases,
|
||||
getMacroName,
|
||||
getNodeChildren,
|
||||
hasAttributes,
|
||||
hasMethod,
|
||||
hasTypeBounds,
|
||||
includesTK,
|
||||
insertNode,
|
||||
insertNodes,
|
||||
is_AttributeOrDocComment,
|
||||
is_BareTypeTraitBound,
|
||||
is_BlockExpression,
|
||||
is_CallExpression,
|
||||
is_ClosureFunctionExpression,
|
||||
is_DocCommentAttribute,
|
||||
is_ExpressionStatement,
|
||||
is_ExpressionWithBodyOrCases,
|
||||
is_FlowControlExpression,
|
||||
is_IfBlockExpression,
|
||||
is_MacroInvocation,
|
||||
is_Node,
|
||||
is_NodeWithBodyNoBody,
|
||||
is_NodeWithBodyOrCases,
|
||||
is_Program,
|
||||
is_PunctuationToken,
|
||||
is_ReassignmentNode,
|
||||
is_Snippet,
|
||||
is_TypeBoundsStandaloneNode,
|
||||
is_TypeDynBounds,
|
||||
is_TypeImplBounds,
|
||||
is_TypeTraitBound,
|
||||
ownStart,
|
||||
reassignNodeProperty,
|
||||
start,
|
||||
transferAttributes,
|
||||
unsafe_set_nodeType,
|
||||
} from "jinx-rust/utils";
|
||||
import { isPrettierIgnoreAttribute, setPrettierIgnoreTarget } from "../format/comments";
|
||||
import { is_StructSpread } from "../format/core";
|
||||
import { CustomOptions } from "../format/external";
|
||||
import { getOptions } from "../format/plugin";
|
||||
import {
|
||||
Array_replace,
|
||||
Array_splice,
|
||||
assert,
|
||||
binarySearchIn,
|
||||
each,
|
||||
exit,
|
||||
iLast,
|
||||
last_of,
|
||||
Map_get,
|
||||
spliceAll,
|
||||
try_eval,
|
||||
} from "../utils/common";
|
||||
import { transform_simpleAttrSyntax } from "./custom/attribute";
|
||||
import { transform_macro_cfg_if } from "./custom/cfg_if";
|
||||
|
||||
export interface ExpressionLikeAttribute extends Attribute {
|
||||
segments: LocArray<any, "[]">;
|
||||
}
|
||||
|
||||
export interface CallLikeMacroInvocation extends MacroInvocation {
|
||||
segments: LocArray<any, any>;
|
||||
callee: MacroInvocation["callee"];
|
||||
method: undefined;
|
||||
typeArguments: undefined;
|
||||
arguments: LocArray<ExpressionNode, "()" | "[]" | "{}">;
|
||||
}
|
||||
|
||||
export interface BlockLikeMacroInvocation extends MacroInvocation {
|
||||
segments: LocArray<any, any>;
|
||||
body: LocArray<StatementNode, "()" | "[]" | "{}">;
|
||||
attributes?: AttributeOrDocComment[];
|
||||
}
|
||||
|
||||
export function is_CallLikeMacroInvocation(node: Node): node is CallLikeMacroInvocation {
|
||||
return is_MacroInvocation(node) && "arguments" in node;
|
||||
}
|
||||
|
||||
export function is_BlockLikeMacroInvocation(node: Node): node is BlockLikeMacroInvocation {
|
||||
return is_MacroInvocation(node) && "body" in node;
|
||||
}
|
||||
|
||||
export function is_CallExpression_or_CallLikeMacroInvocation(node: any): node is CallExpression | CallLikeMacroInvocation {
|
||||
return is_CallExpression(node) || is_CallLikeMacroInvocation(node);
|
||||
}
|
||||
|
||||
const IGNORED_MACROS = new Set([
|
||||
// std
|
||||
// crates
|
||||
"quote",
|
||||
]);
|
||||
|
||||
const HARDCODED_MACRO_DELIMS = new Map<string, MacroInvocation["segments"]["dk"]>();
|
||||
each(
|
||||
{
|
||||
[DelimKind["{}"]]: [
|
||||
// std
|
||||
"thread_local",
|
||||
// crates
|
||||
"cfg_if",
|
||||
],
|
||||
[DelimKind["()"]]: [
|
||||
// std
|
||||
"assert_eq",
|
||||
"assert_ne",
|
||||
"assert",
|
||||
"cfg",
|
||||
"concat_bytes",
|
||||
"concat_idents",
|
||||
"concat",
|
||||
"debug_assert_eq",
|
||||
"debug_assert_ne",
|
||||
"debug_assert",
|
||||
"eprint",
|
||||
"eprintln",
|
||||
"format_args_nl",
|
||||
"format_args",
|
||||
"format",
|
||||
"matches",
|
||||
"panic",
|
||||
"print",
|
||||
"println",
|
||||
"try",
|
||||
"unimplemented",
|
||||
"unreachable",
|
||||
"write",
|
||||
"writeln",
|
||||
// crates
|
||||
],
|
||||
[DelimKind["[]"]]: [
|
||||
// std
|
||||
"vec",
|
||||
// crates
|
||||
],
|
||||
},
|
||||
(names, tk) =>
|
||||
each(names, (name) => {
|
||||
HARDCODED_MACRO_DELIMS.set(name, +tk as MacroInvocation["segments"]["dk"]);
|
||||
})
|
||||
);
|
||||
|
||||
let _COMMENTS: CustomOptions["comments"] = undefined!;
|
||||
let _DANGLING_ATTRIBUTES: CustomOptions["danglingAttributes"] = undefined!;
|
||||
|
||||
export function transform_ast(options: CustomOptions) {
|
||||
try {
|
||||
_COMMENTS = options.comments;
|
||||
_DANGLING_ATTRIBUTES = options.danglingAttributes;
|
||||
transformNode(options.rsParsedFile);
|
||||
} finally {
|
||||
_depth = 0;
|
||||
_COMMENTS = undefined!;
|
||||
_DANGLING_ATTRIBUTES = undefined!;
|
||||
}
|
||||
}
|
||||
|
||||
let _depth = 0;
|
||||
const isReadingSnippet = () => 0 !== _depth;
|
||||
|
||||
function maybe_transform_node<T extends Node, S extends Snippet>(
|
||||
node: T,
|
||||
read_snippet: () => S,
|
||||
fn: (node: T, snippet: S) => void
|
||||
): T | undefined {
|
||||
const snippet = try_eval(read_snippet);
|
||||
if (snippet) {
|
||||
++_depth;
|
||||
transformNode(snippet);
|
||||
--_depth;
|
||||
fn(node, snippet);
|
||||
transformed.add(node);
|
||||
return node;
|
||||
}
|
||||
}
|
||||
const transformed = new WeakSet<Node>();
|
||||
export function isTransformed(node: Node) {
|
||||
return transformed.has(node);
|
||||
}
|
||||
|
||||
const transform: { [K in NodeType]?: (node: NTMap[K]) => void } = {
|
||||
[NodeType.Attribute](node) {
|
||||
try_eval(() => {
|
||||
node.segments = rs.createLocArray(node.segments.dk, node.segments.loc.clone(), [
|
||||
transform_simpleAttrSyntax(node.segments),
|
||||
]) as any;
|
||||
transformed.add(node);
|
||||
});
|
||||
},
|
||||
[NodeType.MacroInlineRuleDeclaration](node) {
|
||||
node.match.dk = DelimKind["()"];
|
||||
node.transform.dk = DelimKind["{}"];
|
||||
},
|
||||
[NodeType.MacroInvocation](node) {
|
||||
const name = getMacroName(node);
|
||||
|
||||
if (
|
||||
IGNORED_MACROS.has(name) ||
|
||||
node.segments.length === 0 ||
|
||||
(node.segments.length === 1 && is_PunctuationToken(node.segments[0]))
|
||||
) {
|
||||
return;
|
||||
}
|
||||
|
||||
const tk = transformMacroDelim(name, node);
|
||||
|
||||
if (name === "matches") {
|
||||
//
|
||||
}
|
||||
|
||||
if (name === "if_chain") {
|
||||
//
|
||||
}
|
||||
|
||||
if (name === "cfg_if") {
|
||||
transformBlockLike(() => transform_macro_cfg_if(node.segments) as any);
|
||||
} else if (tk === DelimKind["{}"]) {
|
||||
transformBlockLike(); /* || (includesTK(node, TK[","]) && transformCallLike()); */
|
||||
} else {
|
||||
transformCallLike(); /* || (includesTK(node, TK[";"]) && transformBlockLike()); */
|
||||
}
|
||||
|
||||
function transformBlockLike(transform = () => rs.toBlockBody(node.segments)) {
|
||||
return maybe_transform_node(node as BlockLikeMacroInvocation, transform, (node, snippet) => {
|
||||
const _body = snippet.ast;
|
||||
_body.dk = tk;
|
||||
|
||||
node.body = _body;
|
||||
node.segments = _body;
|
||||
transferAttributes(snippet, node);
|
||||
});
|
||||
}
|
||||
|
||||
function transformCallLike() {
|
||||
return maybe_transform_node(
|
||||
node as CallLikeMacroInvocation,
|
||||
() => rs.toCallExpressionArguments(node.segments),
|
||||
(node, snippet) => {
|
||||
const _arguments = snippet.ast;
|
||||
_arguments.dk = tk;
|
||||
|
||||
node.method = undefined;
|
||||
node.typeArguments = undefined;
|
||||
node.arguments = _arguments;
|
||||
node.segments = _arguments;
|
||||
}
|
||||
);
|
||||
}
|
||||
},
|
||||
[NodeType.CallExpression](node) {
|
||||
if (hasMethod(node)) {
|
||||
node.callee = rs.mockNode(NodeType.MemberExpression, node.method.loc.cloneFrom(start(node.callee)), {
|
||||
expression: node.callee,
|
||||
property: node.method,
|
||||
computed: false,
|
||||
});
|
||||
node.method = undefined!;
|
||||
getOptions().actuallyMethodNodes.add(node.callee as MemberExpression);
|
||||
}
|
||||
},
|
||||
|
||||
[NodeType.AutoTraitDeclaration](node) {
|
||||
mockBodyNoBody(node);
|
||||
},
|
||||
[NodeType.NegativeImplDeclaration](node) {
|
||||
mockBodyNoBody(node);
|
||||
},
|
||||
|
||||
[NodeType.StructLiteral](node) {
|
||||
moveSpreadsToEnd(node);
|
||||
},
|
||||
[NodeType.StructPattern](node) {
|
||||
moveSpreadsToEnd(node);
|
||||
},
|
||||
};
|
||||
|
||||
function moveSpreadsToEnd(node: StructLiteral | StructPattern) {
|
||||
const props = node.properties;
|
||||
if (props.some((p, i, a) => is_StructSpread(p) && !iLast(i, a))) {
|
||||
const spreads: any[] = [];
|
||||
for (let i = 0; i < props.length; i++) {
|
||||
const prop = props[i];
|
||||
if (is_StructSpread(prop)) {
|
||||
Array_splice(props, prop, i--);
|
||||
spreads.push(prop);
|
||||
}
|
||||
}
|
||||
props.push(...spreads);
|
||||
}
|
||||
}
|
||||
|
||||
function mockBodyNoBody(node: NodeWithBodyNoBody) {
|
||||
// @ts-expect-error
|
||||
node.body = rs.createLocArray(last_of(rs.toTokens(node).ast).loc.clone(), DelimKind["{}"]);
|
||||
}
|
||||
|
||||
function transformMacroDelim(name: string, node: MacroInvocation): 1 | 2 | 3 {
|
||||
if (HARDCODED_MACRO_DELIMS.has(name)) {
|
||||
return HARDCODED_MACRO_DELIMS.get(name)!;
|
||||
}
|
||||
if (node.segments.dk === DelimKind["{}"] && includesTK(node, TK[","])) {
|
||||
return DelimKind["()"];
|
||||
}
|
||||
if (node.segments.dk === DelimKind["()"] && includesTK(node, TK[";"])) {
|
||||
return DelimKind["{}"];
|
||||
}
|
||||
return node.segments.dk;
|
||||
}
|
||||
|
||||
// export function createTransformed<S extends Node>(create: () => S): S {
|
||||
// return transformNode(create());
|
||||
// }
|
||||
|
||||
const seen = new WeakSet<Node>();
|
||||
function transformNode<T extends Node>(node: T, parent?: Node, key?: string, index?: any): T {
|
||||
if (!seen.has(node)) {
|
||||
seen.add(node);
|
||||
if (is_Snippet(node) || is_Program(node)) {
|
||||
registerPogramLike(node);
|
||||
}
|
||||
|
||||
each_childNode(node, transformNode);
|
||||
|
||||
insert_blocks(node, parent, key, index);
|
||||
|
||||
transform[node.nodeType]?.(node as any);
|
||||
|
||||
flatten_typeBounds(node);
|
||||
|
||||
transform_nodeAttributes(node);
|
||||
}
|
||||
return node;
|
||||
}
|
||||
|
||||
function insert_blocks(node: Node, parent?: Node, key?: string, index?: any) {
|
||||
if (parent && key) {
|
||||
if (
|
||||
!is_ExpressionStatement(parent) &&
|
||||
(false ||
|
||||
// "1 + break" -> "1 + { break; }"
|
||||
is_FlowControlExpression(node) ||
|
||||
// "1 + a = b" -> "1 + { a = b; }"
|
||||
(!isReadingSnippet() && is_ReassignmentNode(node) && !(is_ReassignmentNode(parent) && parent.left === node)))
|
||||
) {
|
||||
reassignNodeProperty(blockify(node), parent, key, index);
|
||||
} else if (
|
||||
is_ClosureFunctionExpression(node) &&
|
||||
(false ||
|
||||
// "|| -> T x" -> "|| -> T { x }"
|
||||
(!!node.returnType && !is_BlockExpression(node.expression)) ||
|
||||
// "|| match x {}" -> "|| { match x {} }"
|
||||
(is_ExpressionWithBodyOrCases(node.expression) &&
|
||||
!is_BlockExpression(node.expression) &&
|
||||
!is_IfBlockExpression(node.expression)))
|
||||
) {
|
||||
node.expression = blockify(node.expression);
|
||||
}
|
||||
}
|
||||
function blockify(node: ExpressionNode) {
|
||||
const block = rs.mockNode(NodeType.BlockExpression, node.loc.clone(), {
|
||||
label: undefined,
|
||||
body: rs.createLocArray(DelimKind["{}"], node.loc.clone(), [
|
||||
rs.mockNode(NodeType.ExpressionStatement, node.loc.clone(), { semi: false, expression: node }),
|
||||
]),
|
||||
});
|
||||
transferAttributes(node, block);
|
||||
return block;
|
||||
}
|
||||
}
|
||||
|
||||
function flatten_typeBounds(topNode: Node) {
|
||||
if (hasTypeBounds(topNode)) {
|
||||
const nestedBounds: TypeTraitBound[] = topNode.typeBounds.filter(isBoundWithNestedBounds);
|
||||
const [first, ...subsequent] = nestedBounds;
|
||||
|
||||
const flatten = (bound: TypeTraitBound) =>
|
||||
Array_replace(topNode.typeBounds, bound, ...(bound.typeExpression as unknown as TypeDynBounds).typeBounds);
|
||||
|
||||
if (nestedBounds.every(isBareBoundWithNestedBoundsNoPrefix)) {
|
||||
// A + (B + C)
|
||||
// -> A + B + C
|
||||
each(nestedBounds, flatten);
|
||||
} else if (
|
||||
!hasDefinedPrefix(topNode) &&
|
||||
first === topNode.typeBounds[0] &&
|
||||
!isBareBoundWithNestedBoundsNoPrefix(first) &&
|
||||
subsequent.every(isBareBoundWithNestedBoundsNoPrefix)
|
||||
) {
|
||||
if (is_TypeDynBounds(topNode)) {
|
||||
if (is_TypeImplBounds(first.typeExpression)) {
|
||||
// (impl A) + B
|
||||
// -> impl A + B
|
||||
unsafe_set_nodeType(topNode, NodeType.TypeImplBounds);
|
||||
} else {
|
||||
// (dyn A) + B
|
||||
// -> dyn A + B
|
||||
topNode.dyn = true;
|
||||
}
|
||||
each(nestedBounds, flatten);
|
||||
} else {
|
||||
each(subsequent, flatten);
|
||||
(first.typeExpression as unknown as TypeDynBounds).typeBounds.push(...topNode.typeBounds.slice(1));
|
||||
topNode.typeBounds.length = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function isBoundWithNestedBounds(bound: TypeBound): bound is TypeTraitBound & { typeExpression: TypeBoundsStandaloneNode } {
|
||||
return is_TypeTraitBound(bound) && is_TypeBoundsStandaloneNode(bound.typeExpression);
|
||||
}
|
||||
function isBareBoundWithNestedBounds(bound: TypeBound): bound is TypeTraitBound & { typeExpression: TypeBoundsStandaloneNode } {
|
||||
return isBoundWithNestedBounds(bound) && is_BareTypeTraitBound(bound);
|
||||
}
|
||||
function isBareBoundWithNestedBoundsNoPrefix(bound: TypeBound): bound is TypeTraitBound & { typeExpression: TypeDynBounds } {
|
||||
return isBareBoundWithNestedBounds(bound) && !hasDefinedPrefix(bound.typeExpression);
|
||||
}
|
||||
function hasDefinedPrefix(node: NodeWithTypeBounds) {
|
||||
return (is_TypeDynBounds(node) && node.dyn) || is_TypeImplBounds(node);
|
||||
}
|
||||
}
|
||||
|
||||
function transform_nodeAttributes(node: Node) {
|
||||
/**
|
||||
* # Inside Token trees:
|
||||
*
|
||||
* 1. DocCommentAttribute --is parsed as--> Comment
|
||||
* 2. Attribute --is parsed as--> Token<'#'>, DelimGroup<'[]'>
|
||||
*
|
||||
* # Transforming tokens into a Snippet:
|
||||
*
|
||||
* 1. DocCommentAttribute <--replace from-- Comment
|
||||
* a) Remove node with same loc from comments
|
||||
* b) Merge Snippet.danglingAttributes with Program.danglingAttributes
|
||||
*
|
||||
* 2. Attribute (no action needed)
|
||||
*
|
||||
*/
|
||||
if (hasAttributes(node)) {
|
||||
const attrs = node.attributes;
|
||||
for (let i = 0; i < attrs.length; i++) {
|
||||
const attr = attrs[i];
|
||||
if (isReadingSnippet() && is_DocCommentAttribute(attr)) {
|
||||
const index = binarySearchIn(_COMMENTS, start(attr), start);
|
||||
__DEV__: assert(index !== -1), assert(end(_COMMENTS[index]) === end(attr));
|
||||
_COMMENTS.splice(index, 1);
|
||||
}
|
||||
if (attr.inner) {
|
||||
if (isPrettierIgnoreAttribute(attr)) {
|
||||
setPrettierIgnoreTarget(is_Program(node) ? node.loc.src : node, attr);
|
||||
}
|
||||
// @ts-expect-error Inserting Attribute into StatementNode[]
|
||||
insertNode(is_Snippet(node) ? node.ast : getBodyOrCases(node)!, attr);
|
||||
Array_splice(attrs, attr, i--);
|
||||
}
|
||||
}
|
||||
if (attrs.length === 0) {
|
||||
deleteAttributes(node);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function registerPogramLike(program: Extract<Node, ProgramLike>) {
|
||||
const comments = spliceAll(program.comments);
|
||||
const danglingAttributes = spliceAll(program.danglingAttributes);
|
||||
for (let i = 0; i < danglingAttributes.length; i++) {
|
||||
const attr = danglingAttributes[i];
|
||||
// if (isReadingSnippet() && is_DocCommentAttribute(attr)) {
|
||||
// }
|
||||
if (is_DocCommentAttribute(attr)) {
|
||||
if (isReadingSnippet()) {
|
||||
const index = binarySearchIn(_COMMENTS, start(attr), start);
|
||||
__DEV__: assert(index !== -1), assert(end(_COMMENTS[index]) === end(attr));
|
||||
_COMMENTS.splice(index, 1);
|
||||
}
|
||||
} else {
|
||||
transformNode(danglingAttributes[i], program, "danglingAttributes", i);
|
||||
}
|
||||
}
|
||||
if (!isReadingSnippet()) insertNodes(_COMMENTS, comments);
|
||||
insertNodes(_DANGLING_ATTRIBUTES, danglingAttributes);
|
||||
}
|
||||
|
||||
const CommentChildNodes = new WeakMap<Node, Node[]>();
|
||||
|
||||
export function getCommentChildNodes(n: any): Node[] {
|
||||
const children = Map_get(CommentChildNodes, n, getTransformedNodeChildren);
|
||||
/**
|
||||
* parent {
|
||||
* #[attr]
|
||||
* #![attr] <-------- list misplaced inner attrs as part of "#[attr] child {}"
|
||||
* child {}
|
||||
* }
|
||||
*/
|
||||
if (is_NodeWithBodyOrCases(n) || is_BlockLikeMacroInvocation(n)) {
|
||||
for (let i = 0; i < children.length; i++) {
|
||||
const attr = children[i];
|
||||
if (is_AttributeOrDocComment(attr)) {
|
||||
const target = children.find((n) => start(n) <= start(attr) && ownStart(n) >= end(attr));
|
||||
if (target) {
|
||||
children.splice(i--, 1);
|
||||
insertNode(Map_get(CommentChildNodes, target, getTransformedNodeChildren), attr);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return children;
|
||||
|
||||
function getTransformedNodeChildren(node: Node) {
|
||||
if (is_Program(node)) node.comments ??= []; // prettier core deletes this property
|
||||
const children = getNodeChildren(node);
|
||||
|
||||
if (is_NodeWithBodyNoBody(node)) {
|
||||
insertNodes(children, (node as any).body);
|
||||
}
|
||||
|
||||
__DEV__: {
|
||||
const actual_count = countActualNodeChildren(node);
|
||||
if (
|
||||
children.length !== actual_count &&
|
||||
!(is_MacroInvocation(node) && actual_count - node.segments.length === children.length)
|
||||
) {
|
||||
const actual = getActualNodeChildren(node);
|
||||
const missing = actual.filter((n) => !children.includes(n));
|
||||
const unknown = children.filter((n) => !actual.includes(n));
|
||||
const duplicates_in_object = actual.filter((n, i, a) => i !== 0 && n === a[i - 1]);
|
||||
const duplicates_in_childNodes = children.filter((n, i, a) => i !== 0 && n === a[i - 1]);
|
||||
const ctx = { missing, unknown, duplicates_in_object, duplicates_in_childNodes };
|
||||
for (let key in ctx) if (ctx[key].length === 0) delete ctx[key];
|
||||
exit(`${node.type} was transformed but did not patch its childNodes list`, ctx, node.loc.url(), node);
|
||||
}
|
||||
for (const child of children)
|
||||
if (!is_Node(child)) exit(`${node.type}'s childNodes includes unexpected entries`, { node, child });
|
||||
}
|
||||
return children;
|
||||
}
|
||||
}
|
||||
246
frontend/src/common/prettier/plugins/rust/utils/common.ts
Normal file
246
frontend/src/common/prettier/plugins/rust/utils/common.ts
Normal file
@@ -0,0 +1,246 @@
|
||||
import { createCustomError } from "./debug";
|
||||
|
||||
declare global {
|
||||
interface ImportMeta {
|
||||
url: string;
|
||||
}
|
||||
}
|
||||
|
||||
export function Narrow<T extends R, R = unknown>(value: R): asserts value is T {}
|
||||
export function AssertTypesEq<A extends B, B>(...args: [B] extends [A] ? [] : [RIGHT_TYPES_NOT_ASSIGNABLE_TO_LEFT: Exclude<B, A>]) {}
|
||||
|
||||
// prettier-ignore
|
||||
type indexof<A> = A extends readonly any[] ? A extends 0 ? any : keyof A & number : A extends Set<unknown> ? never : A extends Map<infer U, unknown> ? U
|
||||
: A extends Iterable<unknown> ? never : A extends object ? keyof A & (number | string) : never;
|
||||
// prettier-ignore
|
||||
type valueof<A> = A extends ReadonlyArray<infer U> ? A extends 0 ? any : U : A extends Set<infer U> ? U : A extends Map<unknown, infer U> ? U
|
||||
: A extends Iterable<infer U> ? U : A extends object ? A[keyof A & (number | string)] : never;
|
||||
// prettier-ignore
|
||||
type vObject<V extends unknown = unknown, K extends unknown = unknown> = | object | readonly V[] | { [key: string]: V } | anySet<V> | anyMap<K, V>;
|
||||
export type itfn<A, R> = (value: valueof<A>, key: indexof<A>) => R;
|
||||
type anySet<V extends unknown = unknown> = Set<V>;
|
||||
type anyMap<K extends unknown = unknown, V extends unknown = unknown> = Map<K, V>;
|
||||
type anyfunction<A extends any[] = unknown[], R = unknown> = (...args: A) => R;
|
||||
type objlike = object | anyfunction;
|
||||
type anymap<K extends unknown = unknown, V extends unknown = unknown> = K extends objlike ? Map<K, V> | WeakMap<K, V> : Map<K, V>;
|
||||
|
||||
export function exit(message: string, ...ctx: any[]): never {
|
||||
if (ctx.length > 0) console.log("Error context:", { ...ctx });
|
||||
throw createCustomError({ message });
|
||||
}
|
||||
exit.never = function never(...ctx: any[]): never {
|
||||
exit("Reached unreachable code", ...ctx);
|
||||
};
|
||||
export function assert(predicate: boolean, err?: string, ...ctx: any[]): asserts predicate {
|
||||
__DEV__: if (typeof predicate !== "boolean") exit("Expected boolean", predicate);
|
||||
if (false === predicate) exit(err ?? "Assertion failed", ...ctx);
|
||||
}
|
||||
export function Identity<T>(v: T): T {
|
||||
return v;
|
||||
}
|
||||
|
||||
export function last_of<T extends ArrayLike<any>>(arr: T): T extends readonly [...infer A, infer U] ? U : T[number] {
|
||||
__DEV__: isArrayLike(arr) || exit("Expected Array"), arr.length > 0 || exit("Attempted to retrieve last item of an empty array", arr);
|
||||
return arr[arr.length - 1];
|
||||
}
|
||||
export function maybe_last_of<T extends readonly any[] | undefined>(
|
||||
arr: T
|
||||
): T extends any[] ? (T extends readonly [...infer A, infer U] ? U : T[number]) : undefined {
|
||||
return (undefined === arr || 0 === arr.length ? undefined : last_of(arr as any[])) as any;
|
||||
}
|
||||
|
||||
export function normPath(filepath: string) {
|
||||
return filepath.replace(/^file:\/\/\//, "").replace(/\\\\?/g, "/");
|
||||
}
|
||||
|
||||
export function print_string(str: string) {
|
||||
return /[\u0000-\u0020]/.test(str)
|
||||
? str
|
||||
.replace(/ /g, "•")
|
||||
.replace(/\n/g, "↲")
|
||||
.replace(/\t/g, "╚")
|
||||
.replace(/[\u0000-\u0020]/g, "□")
|
||||
: str;
|
||||
}
|
||||
|
||||
function isArrayLike(value: any): value is ArrayLike<unknown> {
|
||||
return is_object(value) && oisArrayLike(value);
|
||||
}
|
||||
|
||||
function oisArrayLike(value: {}): value is ArrayLike<unknown> {
|
||||
return "length" in value && (0 === (value as any).length || "0" in value);
|
||||
}
|
||||
|
||||
export function binarySearchIn<T extends {}>(array: ArrayLike<T>, target: number, toValue: (item: T) => number) {
|
||||
if (isEmpty(array)) return -1;
|
||||
let i = 0;
|
||||
let low = 0;
|
||||
let high = array.length - 1;
|
||||
let value = toValue(array[high]);
|
||||
if (target >= value) return high;
|
||||
else high--;
|
||||
while (low <= high) {
|
||||
i = low + ((high - low) >> 1);
|
||||
value = toValue(array[i]);
|
||||
if (target === value) return i;
|
||||
if (target > value) low = i + 1;
|
||||
else high = i - 1;
|
||||
}
|
||||
return low - 1;
|
||||
}
|
||||
|
||||
export function getTerminalWidth(fallbackWidth = 200) {
|
||||
return globalThis?.process?.stdout?.columns ?? fallbackWidth;
|
||||
}
|
||||
|
||||
// @ts-ignore
|
||||
const isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
|
||||
export const color = ((cfn, mfn) => ({
|
||||
black: cfn(30),
|
||||
red: cfn(31),
|
||||
green: cfn(32),
|
||||
yellow: cfn(33),
|
||||
blue: cfn(34),
|
||||
magenta: cfn(35),
|
||||
cyan: cfn(36),
|
||||
white: cfn(37),
|
||||
grey: cfn(90),
|
||||
bold: mfn(1, 22),
|
||||
italic: mfn(3, 23),
|
||||
underline: mfn(4, 24),
|
||||
hidden: mfn(8, 28),
|
||||
hiddenCursor: (str: string) => `\x1B[?25l${str}\x1B[?25h`,
|
||||
unstyle: (str: string) => str.replace(/\x1B\[[0-9][0-9]?m/g, ""),
|
||||
unstyledLength: (str: string) => str.replace(/\x1B\[[0-9][0-9]?m/g, "").length,
|
||||
link: (str: string) => color.underline(color.blue(str)),
|
||||
}))(
|
||||
(c1: number) => (isBrowser ? Identity : (str: string) => `\x1B[${c1}m${str.replace(/\x1B\[39m/g, `\x1B[${c1}m`)}\x1B[39m`),
|
||||
(c1: number, c2: number) => (isBrowser ? Identity : (str: string) => `\x1B[${c1}m${str}\x1B[${c2}m`)
|
||||
);
|
||||
export function Map_get<K extends object, V>(map: WeakMap<K, V>, key: K, init: (key: K) => V): V;
|
||||
export function Map_get<K, V>(map: Map<K, V>, key: K, init: (key: K) => V): V;
|
||||
export function Map_get<K, V>(map: anymap<K, V>, key: K, init: (key: K) => V): V {
|
||||
if (!map.has(key)) map.set(key, init(key));
|
||||
return map.get(key)!;
|
||||
}
|
||||
export function isEmpty(array: ArrayLike<any>): boolean {
|
||||
__DEV__: assert(isArrayLike(array));
|
||||
return 0 === array.length;
|
||||
}
|
||||
export function Array_splice<T extends any[]>(array: T, target: T[number], index: number = array.indexOf(target)) {
|
||||
__DEV__: {
|
||||
const i = arguments.length === 2 ? array.indexOf(target) : index;
|
||||
assert(i === index && i !== -1 && i === array.lastIndexOf(target), "", { array, target, index, i });
|
||||
}
|
||||
array.splice(index, 1);
|
||||
}
|
||||
export function Array_replace<T extends any[]>(array: T, target: T[number], ...replacements: T[number][]) {
|
||||
const i = array.indexOf(target);
|
||||
__DEV__: if (i === -1 || i !== array.lastIndexOf(target))
|
||||
exit("Array_replace", { index: i, lastIndex: array.lastIndexOf(target), array, target, replacements });
|
||||
array.splice(array.indexOf(target), 1, ...replacements);
|
||||
}
|
||||
export function has_key_defined<T extends object, K extends T extends never ? never : keyof T>(
|
||||
o: T,
|
||||
k: K
|
||||
): o is K extends never
|
||||
? never
|
||||
: T extends { [k in K]: any }
|
||||
? T & { [k in K]: {} }
|
||||
: T extends { [k in K]?: any }
|
||||
? T & { [k in K]: {} }
|
||||
: never {
|
||||
return k in o && undefined !== o[k];
|
||||
}
|
||||
|
||||
export function is_object(data: unknown): data is object | ({ [key: string]: unknown } | unknown[]) {
|
||||
return "object" === typeof data && null !== data;
|
||||
}
|
||||
|
||||
export function is_array(data: unknown): data is any[] {
|
||||
return Array.isArray(data);
|
||||
}
|
||||
|
||||
function ois_vobject(data: any) {
|
||||
__DEV__: assert(is_object(data));
|
||||
switch (data.constructor) {
|
||||
case Array:
|
||||
case Object:
|
||||
case Set:
|
||||
case Map:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
export function each<A extends vObject>(data: A, callback: itfn<A, void>): void;
|
||||
export function each(data: any, callback: (value: any, index: any) => void): void {
|
||||
__DEV__: assert(ois_vobject(data));
|
||||
// prettier-ignore
|
||||
switch (data.constructor) {
|
||||
case Array: { let i = 0; for (; i < data.length; i++) callback(data[i], i); return; }
|
||||
case Object: { let k; for (k in data) callback(data[k], k); return; }
|
||||
case Set: { let d; for (d of data) callback(d, undefined!); return; }
|
||||
case Map: { let e; for (e of data) callback(e[1], e[0]); return; }
|
||||
default: { let x; for (x of data) callback(x, undefined!); return; }
|
||||
}
|
||||
}
|
||||
|
||||
export function iLast(index: number, array: any[]) {
|
||||
return 1 + index === array.length;
|
||||
}
|
||||
|
||||
export function find_last<T>(arr: T[], test: itfn<T[], boolean>): T | undefined {
|
||||
for (var i = arr.length; --i !== -1; ) if (test(arr[i], i)) return arr[i];
|
||||
}
|
||||
|
||||
export function try_eval<T>(fn: () => T): T | undefined {
|
||||
try {
|
||||
return fn();
|
||||
} catch (e) {
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
|
||||
export function clamp(min: number, max: number, value: number) {
|
||||
return value > min ? (value < max ? value : max) : min;
|
||||
}
|
||||
|
||||
export type MaybeFlatten<T> = T extends ReadonlyArray<infer U> ? MaybeFlatten<Exclude<U, T>> : T;
|
||||
export type FlatArray<T> = MaybeFlatten<T>[];
|
||||
export function flat<T extends readonly any[]>(arr: T): FlatArray<T> {
|
||||
return (arr as any as [any]).flat(Infinity);
|
||||
}
|
||||
export function flatMap<T extends readonly any[], R>(arr: T, mapFn: (item: T[number], index: number, array: T) => R): FlatArray<R> {
|
||||
return flat(arr.map(mapFn as any));
|
||||
}
|
||||
|
||||
export function joinln(...arr: string[]): string {
|
||||
return arr.join("\n");
|
||||
}
|
||||
|
||||
export function join_lines(fn: () => Generator<string, void, void>): string {
|
||||
return [...fn()].join("\n");
|
||||
}
|
||||
|
||||
export function reduce_tagged_template<T>(args: [strings: TemplateStringsArray, ...values: T[]], map: (value: T) => string) {
|
||||
for (var str = "" + args[0][0], i = 1; i < args.length; i++) str += map(args[i] as T) + args[0][i];
|
||||
return str;
|
||||
}
|
||||
|
||||
export function map_tagged_template<T, R>(args: [strings: TemplateStringsArray, ...values: T[]], map: (value: T) => R) {
|
||||
const arr: (R | string)[] = [args[0][0]];
|
||||
for (var i = 1; i < args.length; i++) arr.push(map(args[i] as T), args[0][i]);
|
||||
return arr;
|
||||
}
|
||||
|
||||
export function spliceAll<T extends any[]>(array: T): [...T] {
|
||||
const r: [...T] = [...array];
|
||||
array.length = 0;
|
||||
return r;
|
||||
}
|
||||
|
||||
export function spread<R>(fn: () => Iterable<R>): R[] {
|
||||
return [...fn()];
|
||||
}
|
||||
141
frontend/src/common/prettier/plugins/rust/utils/debug.ts
Normal file
141
frontend/src/common/prettier/plugins/rust/utils/debug.ts
Normal file
@@ -0,0 +1,141 @@
|
||||
import { clamp, color, getTerminalWidth, normPath } from "./common";
|
||||
|
||||
const cwd =
|
||||
typeof process === "object" && typeof process?.cwd === "function" ? /* @__PURE__ */ normPath(/* @__PURE__ */ process.cwd() ?? "") : "";
|
||||
function normPath_strip_cwd(filepath: string) {
|
||||
let normFilePath = normPath(filepath);
|
||||
return normFilePath.startsWith(cwd) ? normFilePath.slice(cwd.length + 1) : normFilePath;
|
||||
}
|
||||
|
||||
type StackStyleFn = (callee: string, item: StackItem) => (str: string) => string;
|
||||
interface Stack extends Array<StackItem> {
|
||||
message: string;
|
||||
style?: { callee?: StackStyleFn; url?: StackStyleFn } | undefined;
|
||||
}
|
||||
|
||||
class StackLine {
|
||||
declare readonly raw: string;
|
||||
declare readonly callee: string;
|
||||
declare readonly filepath: string;
|
||||
declare readonly line: string;
|
||||
declare readonly col: string;
|
||||
declare readonly other: string;
|
||||
declare readonly url: string;
|
||||
constructor(raw: string) {
|
||||
({
|
||||
1: this.callee = "",
|
||||
2: this.filepath = "",
|
||||
3: this.line = "",
|
||||
4: this.col = "",
|
||||
5: this.other = "",
|
||||
} = (this.raw = raw).match(/at (?:(.+?)\s+\()?(?:(.+?):([0-9]+)(?::([0-9]+))?|([^)]+))\)?/) ?? ["", "", "", "", "", ""]);
|
||||
this.url = this.filepath //
|
||||
? normPath_strip_cwd(this.filepath) + (this.line && this.col && `:${this.line}:${this.col}`)
|
||||
: this.other === "native"
|
||||
? "<native>"
|
||||
: "";
|
||||
}
|
||||
}
|
||||
|
||||
function getPrintWidth() {
|
||||
return clamp(0, getTerminalWidth(128), 200) - 4;
|
||||
}
|
||||
|
||||
class StackItem extends StackLine {
|
||||
constructor(private readonly stack: Stack, readonly i: number, raw: string) {
|
||||
super(raw);
|
||||
}
|
||||
hidden = false;
|
||||
hide() {
|
||||
this.hidden = true;
|
||||
return this;
|
||||
}
|
||||
hideNext(n: number) {
|
||||
for (let i = 0; i < n; i++) this.at(i)?.hide();
|
||||
}
|
||||
hideWhileTrue(test: (line: StackItem) => boolean) {
|
||||
let line: StackItem | undefined = this;
|
||||
while (line && test(line)) line = line.hide().next();
|
||||
}
|
||||
at(relIndex: number) {
|
||||
return this.i + relIndex >= this.stack.length || this.i + relIndex < 0 ? undefined : this.stack[this.i + relIndex];
|
||||
}
|
||||
next() {
|
||||
return this.at(+1);
|
||||
}
|
||||
toString() {
|
||||
const url = this.url;
|
||||
const calleeColor = this.stack.style?.callee?.(this.callee, this) ?? color.cyan;
|
||||
const urlColor = this.stack.style?.url?.(url, this) ?? color.grey;
|
||||
return compose2Cols(" at " + calleeColor(this.callee), urlColor(url), getPrintWidth());
|
||||
}
|
||||
}
|
||||
|
||||
// prettier-ignore
|
||||
function createStack(message: string, Error_stack: string, style: Stack["style"]): Stack {
|
||||
for (var STACK: Stack = [] as any, i = 0, stack = Error_stack.split("\n").slice(2); i < stack.length; i++) STACK[i] = new StackItem(STACK, i, stack[i]);
|
||||
return (STACK.message = message), (STACK.style = style), STACK;
|
||||
}
|
||||
|
||||
function composeStack(stack: Stack) {
|
||||
var hidden = 0;
|
||||
var str = stack.message;
|
||||
for (var item of stack) item.hidden ? ++hidden : (str += "\n" + item.toString());
|
||||
return str + (hidden > 0 ? "\n" + color.grey(compose2Cols("", `...filtered ${hidden} lines`, getPrintWidth())) : "");
|
||||
}
|
||||
|
||||
export function get_caller_cmd(offset = 0) {
|
||||
const obj: { stack: string } = {} as any;
|
||||
Error.captureStackTrace(obj, get_caller_cmd);
|
||||
const lines = obj.stack.split("\n");
|
||||
return new StackLine(lines[1 + clamp(0, lines.length - 2, offset)]).url;
|
||||
}
|
||||
|
||||
var Error_prepareStackTrace;
|
||||
let replaced_default_prepareStackTrace = false;
|
||||
function custom_prepareStackTrace(err, calls) {
|
||||
return (Error_prepareStackTrace?.(err, calls) ?? calls.join("\n"))?.replace(/file:\/\/\//g, "").replace(/\\\\?/g, "/") ?? calls;
|
||||
}
|
||||
|
||||
export function overrideDefaultError(silent = false) {
|
||||
if (replaced_default_prepareStackTrace === (replaced_default_prepareStackTrace = true)) return;
|
||||
Error_prepareStackTrace = Error.prepareStackTrace ?? ((_, calls) => calls.join("\n"));
|
||||
Error.prepareStackTrace = custom_prepareStackTrace;
|
||||
if (!silent) console.log(color.grey(`[devtools] Replaced Error.prepareStackTrace at ${get_caller_cmd(1)}`));
|
||||
}
|
||||
|
||||
export function createCustomError({
|
||||
message = "Unknown Error",
|
||||
editStack = (stack: StackItem[]) => {},
|
||||
style = undefined as Stack["style"],
|
||||
stackTraceLimit = 20,
|
||||
}): Error {
|
||||
const _stackTraceLimit = Error.stackTraceLimit;
|
||||
const _prepareStackTrace = Error.prepareStackTrace;
|
||||
if (replaced_default_prepareStackTrace && _prepareStackTrace === custom_prepareStackTrace)
|
||||
Error.prepareStackTrace = Error_prepareStackTrace;
|
||||
|
||||
Error.stackTraceLimit = stackTraceLimit;
|
||||
|
||||
const _ctx: { stack: string } = {} as any;
|
||||
|
||||
Error.captureStackTrace(_ctx, createCustomError);
|
||||
|
||||
const stack = createStack(message, _ctx.stack, style);
|
||||
Error.prepareStackTrace = function (err, calls) {
|
||||
editStack(stack);
|
||||
return composeStack(stack);
|
||||
};
|
||||
|
||||
const err = new Error(message); // (get) to trigger prepareStackTrace, (set) to prevent treeshaking
|
||||
err.stack = err.stack;
|
||||
|
||||
Error.stackTraceLimit = _stackTraceLimit;
|
||||
Error.prepareStackTrace = _prepareStackTrace;
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
function compose2Cols(left: string, right: string, len = 64, min = 1) {
|
||||
return left + " ".repeat(clamp(min, len, len - (color.unstyledLength(left) + color.unstyledLength(right)))) + right;
|
||||
}
|
||||
471
frontend/src/common/prettier/plugins/shell/index.ts
Normal file
471
frontend/src/common/prettier/plugins/shell/index.ts
Normal file
@@ -0,0 +1,471 @@
|
||||
import type { Parser, ParserOptions, Plugin, Printer } from 'prettier'
|
||||
import {
|
||||
type File,
|
||||
LangVariant,
|
||||
type Node,
|
||||
type ParseError,
|
||||
type ShOptions,
|
||||
type ShPrintOptions,
|
||||
getProcessor,
|
||||
} from 'sh-syntax'
|
||||
|
||||
import { languages } from './languages'
|
||||
|
||||
// 创建处理器实例
|
||||
let processorInstance: any = null
|
||||
|
||||
const getProcessorInstance = async () => {
|
||||
if (!processorInstance) {
|
||||
try {
|
||||
// @ts-ignore
|
||||
const initWasm = await import('sh-syntax/main.wasm?init')
|
||||
processorInstance = getProcessor(initWasm.default)
|
||||
} catch {
|
||||
processorInstance = getProcessor(() =>
|
||||
fetch(new URL('sh-syntax/main.wasm', import.meta.url))
|
||||
)
|
||||
}
|
||||
}
|
||||
return processorInstance
|
||||
}
|
||||
|
||||
export interface DockerfilePrintOptions extends ParserOptions<string> {
|
||||
indent?: number
|
||||
spaceRedirects?: boolean
|
||||
}
|
||||
|
||||
export interface ShParserOptions
|
||||
extends Partial<ParserOptions<Node>>,
|
||||
ShOptions {
|
||||
filepath?: string
|
||||
}
|
||||
|
||||
export type { ShPrintOptions }
|
||||
|
||||
export interface ShPrinterOptions extends ShPrintOptions {
|
||||
filepath?: string
|
||||
tabWidth: number
|
||||
}
|
||||
|
||||
export class ShSyntaxParseError<
|
||||
E extends Error = ParseError | SyntaxError,
|
||||
> extends SyntaxError {
|
||||
declare cause: E
|
||||
|
||||
declare loc: { start: { column: number; line: number } } | undefined
|
||||
|
||||
constructor(err: E) {
|
||||
const error = err as ParseError | SyntaxError
|
||||
super(('Text' in error && error.Text) || error.message)
|
||||
this.cause = err
|
||||
// `error instanceof ParseError` won't not work because the error is thrown wrapped by `synckit`
|
||||
if ('Pos' in error && error.Pos != null && typeof error.Pos === 'object') {
|
||||
this.loc = { start: { column: error.Pos.Col, line: error.Pos.Line } }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function hasPragma(text: string) {
|
||||
/**
|
||||
* We don't want to parse every file twice but Prettier's interface isn't
|
||||
* conducive to caching/memoizing an upstream Parser, so we're going with some
|
||||
* minor Regex hackery.
|
||||
*
|
||||
* Only read empty lines, comments, and shebangs at the start of the file. We
|
||||
* do not support Bash's pseudo-block comments.
|
||||
*/
|
||||
|
||||
// No, we don't support unofficial block comments.
|
||||
const commentLineRegex = /^\s*(#(?<comment>.*))?$/gm
|
||||
let lastIndex = -1
|
||||
|
||||
/**
|
||||
* Only read leading comments, skip shebangs, and check for the pragma. We
|
||||
* don't want to have to parse every file twice.
|
||||
*/
|
||||
for (;;) {
|
||||
const match = commentLineRegex.exec(text)
|
||||
|
||||
// Found "real" content, EoF, or stuck in a loop.
|
||||
if (match == null || match.index !== lastIndex + 1) {
|
||||
return false
|
||||
}
|
||||
|
||||
lastIndex = commentLineRegex.lastIndex
|
||||
// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- incorrect typing
|
||||
const comment = match.groups?.comment?.trim()
|
||||
|
||||
// Empty lines and shebangs have no captures
|
||||
if (comment == null) {
|
||||
continue
|
||||
}
|
||||
|
||||
if (comment.startsWith('@prettier') || comment.startsWith('@format')) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const dockerfileParser: Parser<string> = {
|
||||
astFormat: 'dockerfile',
|
||||
hasPragma,
|
||||
parse: text => text,
|
||||
locStart: () => 0,
|
||||
locEnd: node => node.length,
|
||||
}
|
||||
|
||||
let formatDockerfileContents_:
|
||||
| any
|
||||
| undefined
|
||||
|
||||
const getFormatDockerfileContents = async () => {
|
||||
if (!formatDockerfileContents_) {
|
||||
try {
|
||||
// @ts-ignore - 忽略模块解析错误
|
||||
const dockerfmt = await import('@reteps/dockerfmt')
|
||||
formatDockerfileContents_ = dockerfmt.formatDockerfileContents
|
||||
} catch (error) {
|
||||
console.warn('Failed to load @reteps/dockerfmt:', error)
|
||||
formatDockerfileContents_ = null
|
||||
}
|
||||
}
|
||||
return formatDockerfileContents_
|
||||
}
|
||||
|
||||
const dockerPrinter: Printer<string> = {
|
||||
// @ts-expect-error -- https://github.com/prettier/prettier/issues/15080#issuecomment-1630987744
|
||||
async print(
|
||||
path,
|
||||
{
|
||||
filepath,
|
||||
|
||||
// parser options
|
||||
keepComments = true,
|
||||
variant,
|
||||
stopAt,
|
||||
recoverErrors,
|
||||
|
||||
// printer options
|
||||
useTabs,
|
||||
tabWidth,
|
||||
indent = useTabs ? 0 : (tabWidth ?? 2),
|
||||
binaryNextLine = true,
|
||||
switchCaseIndent = true,
|
||||
spaceRedirects,
|
||||
// eslint-disable-next-line sonarjs/deprecation
|
||||
keepPadding,
|
||||
minify,
|
||||
singleLine,
|
||||
functionNextLine,
|
||||
}: ShPrintOptions,
|
||||
) {
|
||||
const formatDockerfileContents = await getFormatDockerfileContents()
|
||||
try {
|
||||
if (formatDockerfileContents) {
|
||||
return await formatDockerfileContents(path.node, {
|
||||
indent,
|
||||
spaceRedirects: spaceRedirects ?? false,
|
||||
trailingNewline: true,
|
||||
})
|
||||
}
|
||||
throw new Error('dockerfmt not available')
|
||||
} catch {
|
||||
/*
|
||||
* `dockerfmt` is buggy now and could throw unexpectedly, so we fallback to
|
||||
* the `sh` printer automatically in this case.
|
||||
*
|
||||
* @see {https://github.com/reteps/dockerfmt/issues/21}
|
||||
* @see {https://github.com/reteps/dockerfmt/issues/25}
|
||||
*/
|
||||
const processor = await getProcessorInstance()
|
||||
return processor(path.node, {
|
||||
print: true,
|
||||
filepath,
|
||||
keepComments,
|
||||
variant,
|
||||
stopAt,
|
||||
recoverErrors,
|
||||
useTabs,
|
||||
tabWidth,
|
||||
indent,
|
||||
binaryNextLine,
|
||||
switchCaseIndent,
|
||||
spaceRedirects: spaceRedirects ?? true,
|
||||
keepPadding,
|
||||
minify,
|
||||
singleLine,
|
||||
functionNextLine,
|
||||
})
|
||||
}
|
||||
},
|
||||
}
|
||||
|
||||
const shParser: Parser<Node> = {
|
||||
astFormat: 'sh',
|
||||
hasPragma,
|
||||
locStart: node => node.Pos.Offset,
|
||||
locEnd: node => node.End.Offset,
|
||||
async parse(
|
||||
text,
|
||||
{
|
||||
filepath = '',
|
||||
keepComments = true,
|
||||
/**
|
||||
* The following `@link` doesn't work as expected, see
|
||||
* {@link https://github.com/microsoft/tsdoc/issues/9}
|
||||
*/
|
||||
/** TODO: support {@link LangVariant.LangAuto} */ // eslint-disable-line sonarjs/todo-tag
|
||||
variant,
|
||||
stopAt,
|
||||
recoverErrors,
|
||||
}: ShParserOptions,
|
||||
) {
|
||||
const processor = await getProcessorInstance()
|
||||
return processor(text, {
|
||||
filepath,
|
||||
keepComments,
|
||||
variant,
|
||||
stopAt,
|
||||
recoverErrors,
|
||||
})
|
||||
},
|
||||
}
|
||||
|
||||
const shPrinter: Printer<Node | string> = {
|
||||
// @ts-expect-error -- https://github.com/prettier/prettier/issues/15080#issuecomment-1630987744
|
||||
async print(
|
||||
path,
|
||||
{
|
||||
originalText,
|
||||
filepath,
|
||||
|
||||
// parser options
|
||||
keepComments = true,
|
||||
variant,
|
||||
stopAt,
|
||||
recoverErrors,
|
||||
|
||||
// printer options
|
||||
useTabs,
|
||||
tabWidth,
|
||||
indent = useTabs ? 0 : tabWidth,
|
||||
binaryNextLine = true,
|
||||
switchCaseIndent = true,
|
||||
spaceRedirects = true,
|
||||
// eslint-disable-next-line sonarjs/deprecation
|
||||
keepPadding,
|
||||
minify,
|
||||
singleLine,
|
||||
functionNextLine,
|
||||
}: ShPrintOptions,
|
||||
) {
|
||||
const processor = await getProcessorInstance()
|
||||
return processor(path.node as File, {
|
||||
originalText,
|
||||
filepath,
|
||||
keepComments,
|
||||
variant,
|
||||
stopAt,
|
||||
recoverErrors,
|
||||
useTabs,
|
||||
tabWidth,
|
||||
indent,
|
||||
binaryNextLine,
|
||||
switchCaseIndent,
|
||||
spaceRedirects,
|
||||
keepPadding,
|
||||
minify,
|
||||
singleLine,
|
||||
functionNextLine,
|
||||
})
|
||||
},
|
||||
}
|
||||
|
||||
export const parsers = {
|
||||
dockerfile: dockerfileParser,
|
||||
sh: shParser,
|
||||
}
|
||||
|
||||
export const printers = {
|
||||
dockerfile: dockerPrinter,
|
||||
sh: shPrinter,
|
||||
}
|
||||
|
||||
export const options: Plugin['options'] = {
|
||||
keepComments: {
|
||||
// since: '0.1.0',
|
||||
category: 'Output',
|
||||
type: 'boolean',
|
||||
default: true,
|
||||
description:
|
||||
'KeepComments makes the parser parse comments and attach them to nodes, as opposed to discarding them.',
|
||||
},
|
||||
variant: {
|
||||
// since: '0.1.0',
|
||||
category: 'Config',
|
||||
type: 'choice',
|
||||
choices: [
|
||||
{
|
||||
value: LangVariant.LangBash,
|
||||
description: [
|
||||
'LangBash corresponds to the GNU Bash language, as described in its manual at https://www.gnu.org/software/bash/manual/bash.html.',
|
||||
'',
|
||||
'We currently follow Bash version 5.2.',
|
||||
'',
|
||||
'Its string representation is "bash".',
|
||||
].join('\n'),
|
||||
},
|
||||
{
|
||||
value: LangVariant.LangPOSIX,
|
||||
description: [
|
||||
'LangPOSIX corresponds to the POSIX Shell language, as described at https://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html.',
|
||||
'',
|
||||
'Its string representation is "posix" or "sh".',
|
||||
].join('\n'),
|
||||
},
|
||||
{
|
||||
value: LangVariant.LangMirBSDKorn,
|
||||
description: [
|
||||
'LangMirBSDKorn corresponds to the MirBSD Korn Shell, also known as mksh, as described at http://www.mirbsd.org/htman/i386/man1/mksh.htm.',
|
||||
'Note that it shares some features with Bash, due to the shared ancestry that is ksh.',
|
||||
'',
|
||||
'We currently follow mksh version 59.',
|
||||
'',
|
||||
'Its string representation is "mksh".',
|
||||
].join('\n'),
|
||||
},
|
||||
{
|
||||
value: LangVariant.LangBats,
|
||||
description: [
|
||||
'LangBats corresponds to the Bash Automated Testing System language, as described at https://github.com/bats-core/bats-core.',
|
||||
"Note that it's just a small extension of the Bash language.",
|
||||
'',
|
||||
'Its string representation is "bats".',
|
||||
].join('\n'),
|
||||
},
|
||||
{
|
||||
value: LangVariant.LangAuto,
|
||||
description: [
|
||||
"LangAuto corresponds to automatic language detection, commonly used by end-user applications like shfmt, which can guess a file's language variant given its filename or shebang.",
|
||||
'',
|
||||
'At this time, [Variant] does not support LangAuto.',
|
||||
].join('\n'),
|
||||
},
|
||||
],
|
||||
description:
|
||||
'Variant changes the shell language variant that the parser will accept.',
|
||||
},
|
||||
stopAt: {
|
||||
// since: '0.1.0',
|
||||
category: 'Config',
|
||||
type: 'path',
|
||||
description: [
|
||||
'StopAt configures the lexer to stop at an arbitrary word, treating it as if it were the end of the input. It can contain any characters except whitespace, and cannot be over four bytes in size.',
|
||||
'This can be useful to embed shell code within another language, as one can use a special word to mark the delimiters between the two.',
|
||||
'As a word, it will only apply when following whitespace or a separating token. For example, StopAt("$$") will act on the inputs "foo $$" and "foo;$$", but not on "foo \'$$\'".',
|
||||
'The match is done by prefix, so the example above will also act on "foo $$bar".',
|
||||
].join('\n'),
|
||||
},
|
||||
recoverErrors: {
|
||||
// since: '0.17.0',
|
||||
category: 'Config',
|
||||
type: 'path',
|
||||
description: [
|
||||
'RecoverErrors allows the parser to skip up to a maximum number of errors in the given input on a best-effort basis.',
|
||||
'This can be useful to tab-complete an interactive shell prompt, or when providing diagnostics on slightly incomplete shell source.',
|
||||
'',
|
||||
'Currently, this only helps with mandatory tokens from the shell grammar which are not present in the input. They result in position fields or nodes whose position report [Pos.IsRecovered] as true.',
|
||||
'',
|
||||
'For example, given the input `(foo |`, the result will contain two recovered positions; first, the pipe requires a statement to follow, and as [Stmt.Pos] reports, the entire node is recovered.',
|
||||
'Second, the subshell needs to be closed, so [Subshell.Rparen] is recovered.',
|
||||
].join('\n'),
|
||||
},
|
||||
indent: {
|
||||
// since: '0.1.0',
|
||||
category: 'Format',
|
||||
type: 'int',
|
||||
description:
|
||||
'Indent sets the number of spaces used for indentation. If set to 0, tabs will be used instead.',
|
||||
},
|
||||
binaryNextLine: {
|
||||
// since: '0.1.0',
|
||||
category: 'Output',
|
||||
type: 'boolean',
|
||||
default: true,
|
||||
description:
|
||||
'BinaryNextLine will make binary operators appear on the next line when a binary command, such as a pipe, spans multiple lines. A backslash will be used.',
|
||||
},
|
||||
switchCaseIndent: {
|
||||
// since: '0.1.0',
|
||||
category: 'Format',
|
||||
type: 'boolean',
|
||||
default: true,
|
||||
description:
|
||||
'SwitchCaseIndent will make switch cases be indented. As such, switch case bodies will be two levels deeper than the switch itself.',
|
||||
},
|
||||
spaceRedirects: {
|
||||
// since: '0.1.0',
|
||||
category: 'Format',
|
||||
type: 'boolean',
|
||||
default: true,
|
||||
description:
|
||||
"SpaceRedirects will put a space after most redirection operators. The exceptions are '>&', '<&', '>(', and '<('.",
|
||||
},
|
||||
keepPadding: {
|
||||
// since: '0.1.0',
|
||||
category: 'Format',
|
||||
type: 'boolean',
|
||||
default: false,
|
||||
description: [
|
||||
'KeepPadding will keep most nodes and tokens in the same column that they were in the original source.',
|
||||
'This allows the user to decide how to align and pad their code with spaces.',
|
||||
'',
|
||||
'Note that this feature is best-effort and will only keep the alignment stable, so it may need some human help the first time it is run.',
|
||||
].join('\n'),
|
||||
deprecated: [
|
||||
'This formatting option is flawed and buggy, and often does not result in what the user wants when the code gets complex enough.',
|
||||
'The next major version, v4, will remove this feature entirely.',
|
||||
'See: https://github.com/mvdan/sh/issues/658',
|
||||
].join('\n'),
|
||||
},
|
||||
minify: {
|
||||
// since: '0.1.0',
|
||||
category: 'Output',
|
||||
type: 'boolean',
|
||||
default: false,
|
||||
description: [
|
||||
'Minify will print programs in a way to save the most bytes possible.',
|
||||
'For example, indentation and comments are skipped, and extra whitespace is avoided when possible.',
|
||||
].join('\n'),
|
||||
},
|
||||
singleLine: {
|
||||
// since: '0.17.0',
|
||||
category: 'Format',
|
||||
type: 'boolean',
|
||||
default: false,
|
||||
description: [
|
||||
'SingleLine will attempt to print programs in one line. For example, lists of commands or nested blocks do not use newlines in this mode.',
|
||||
'Note that some newlines must still appear, such as those following comments or around here-documents.',
|
||||
'',
|
||||
"Print's trailing newline when given a [*File] is not affected by this option.",
|
||||
].join('\n'),
|
||||
},
|
||||
functionNextLine: {
|
||||
// since: '0.1.0',
|
||||
category: 'Format',
|
||||
type: 'boolean',
|
||||
default: false,
|
||||
description:
|
||||
"FunctionNextLine will place a function's opening braces on the next line.",
|
||||
},
|
||||
}
|
||||
|
||||
const shellPlugin: Plugin = {
|
||||
languages,
|
||||
parsers,
|
||||
printers,
|
||||
options,
|
||||
}
|
||||
|
||||
export default shellPlugin
|
||||
export { languages }
|
||||
60
frontend/src/common/prettier/plugins/shell/languages.ts
Normal file
60
frontend/src/common/prettier/plugins/shell/languages.ts
Normal file
@@ -0,0 +1,60 @@
|
||||
export const languages = [
|
||||
{
|
||||
name: "Shell",
|
||||
parsers: ["sh"],
|
||||
extensions: [
|
||||
".sh",
|
||||
".bash",
|
||||
".zsh",
|
||||
".fish",
|
||||
".ksh",
|
||||
".csh",
|
||||
".tcsh",
|
||||
".ash",
|
||||
".dash"
|
||||
],
|
||||
filenames: [
|
||||
"*.sh",
|
||||
"*.bash",
|
||||
".bashrc",
|
||||
".bash_profile",
|
||||
".bash_login",
|
||||
".bash_logout",
|
||||
".zshrc",
|
||||
".profile"
|
||||
],
|
||||
interpreters: [
|
||||
"bash",
|
||||
"sh",
|
||||
"zsh",
|
||||
"fish",
|
||||
"ksh",
|
||||
"csh",
|
||||
"tcsh",
|
||||
"ash",
|
||||
"dash"
|
||||
],
|
||||
tmScope: "source.shell",
|
||||
aceMode: "sh",
|
||||
codemirrorMode: "shell",
|
||||
linguistLanguageId: 302,
|
||||
vscodeLanguageIds: ["shellscript"]
|
||||
},
|
||||
{
|
||||
name: "Dockerfile",
|
||||
parsers: ["dockerfile"],
|
||||
extensions: [".dockerfile"],
|
||||
filenames: [
|
||||
"Dockerfile",
|
||||
"*.dockerfile",
|
||||
"Containerfile",
|
||||
"*.containerfile"
|
||||
],
|
||||
tmScope: "source.dockerfile",
|
||||
aceMode: "dockerfile",
|
||||
codemirrorMode: "dockerfile",
|
||||
linguistLanguageId: 99,
|
||||
vscodeLanguageIds: ["dockerfile"]
|
||||
}
|
||||
];
|
||||
|
||||
1180
frontend/src/common/prettier/plugins/sql/detect.mjs
Normal file
1180
frontend/src/common/prettier/plugins/sql/detect.mjs
Normal file
File diff suppressed because it is too large
Load Diff
30
frontend/src/common/prettier/plugins/sql/languages.js
Normal file
30
frontend/src/common/prettier/plugins/sql/languages.js
Normal file
@@ -0,0 +1,30 @@
|
||||
// SQL语言定义
|
||||
export const languages = [
|
||||
{
|
||||
name: "SQL",
|
||||
parsers: ["sql"],
|
||||
extensions: [
|
||||
".sql",
|
||||
".ddl",
|
||||
".dml",
|
||||
".hql",
|
||||
".psql",
|
||||
".plsql",
|
||||
".mysql",
|
||||
".mssql",
|
||||
".pgsql",
|
||||
".sqlite",
|
||||
".bigquery",
|
||||
".snowflake",
|
||||
".redshift",
|
||||
".db2",
|
||||
".n1ql",
|
||||
".cql"
|
||||
],
|
||||
filenames: [
|
||||
"*.sql",
|
||||
"*.ddl",
|
||||
"*.dml"
|
||||
]
|
||||
}
|
||||
];
|
||||
40
frontend/src/common/prettier/plugins/sql/sql.d.ts
vendored
Normal file
40
frontend/src/common/prettier/plugins/sql/sql.d.ts
vendored
Normal file
@@ -0,0 +1,40 @@
|
||||
import { AST, Option } from 'node-sql-parser';
|
||||
import { Options, ParserOptions, Plugin } from 'prettier';
|
||||
import {
|
||||
FormatOptions,
|
||||
FormatOptionsWithLanguage,
|
||||
} from 'sql-formatter';
|
||||
|
||||
export type SqlBaseOptions = Option &
|
||||
Partial<
|
||||
| (FormatOptions & { dialect: string })
|
||||
| (FormatOptionsWithLanguage & { dialect?: never })
|
||||
> & {
|
||||
formatter?: 'sql-formatter' | 'node-sql-parser' | 'sql-cst';
|
||||
params?: string;
|
||||
paramTypes?: string;
|
||||
autoDetectDialect?: boolean;
|
||||
};
|
||||
|
||||
export type SqlOptions = ParserOptions<AST> & SqlBaseOptions;
|
||||
export type SqlFormatOptions = Options & SqlBaseOptions;
|
||||
export declare const languages: Plugin["languages"];
|
||||
|
||||
export declare const parsers: {
|
||||
sql: {
|
||||
parse(text: string, options?: SqlOptions): AST | string;
|
||||
astFormat: 'sql';
|
||||
locStart(): number;
|
||||
locEnd(): number;
|
||||
};
|
||||
};
|
||||
|
||||
export declare const printers: Plugin["printers"];
|
||||
|
||||
export declare const options: Plugin["options"];
|
||||
|
||||
export declare function detectDialect(sql: string): string;
|
||||
|
||||
declare const SqlPlugin: Plugin<AST | string>;
|
||||
|
||||
export default SqlPlugin;
|
||||
459
frontend/src/common/prettier/plugins/sql/sql.mjs
Normal file
459
frontend/src/common/prettier/plugins/sql/sql.mjs
Normal file
@@ -0,0 +1,459 @@
|
||||
import { JSOX } from 'jsox';
|
||||
import nodeSqlParser from 'node-sql-parser';
|
||||
import {
|
||||
format,
|
||||
formatDialect,
|
||||
} from 'sql-formatter';
|
||||
import { detectDialect } from './detect.mjs';
|
||||
import { languages } from './languages.js';
|
||||
|
||||
const parser = new nodeSqlParser.Parser();
|
||||
|
||||
const SQL_FORMATTER = 'sql-formatter';
|
||||
const NODE_SQL_PARSER = 'node-sql-parser';
|
||||
|
||||
// Parsers
|
||||
export const parsers = {
|
||||
sql: {
|
||||
parse(text, options = {}) {
|
||||
const { formatter, type, database } = options;
|
||||
|
||||
return formatter === SQL_FORMATTER
|
||||
? text
|
||||
: parser.astify(text, { type, database });
|
||||
},
|
||||
astFormat: 'sql',
|
||||
locStart: () => -1,
|
||||
locEnd: () => -1,
|
||||
},
|
||||
};
|
||||
|
||||
// Printers
|
||||
export const printers = {
|
||||
sql: {
|
||||
print(path, options = {}) {
|
||||
const value = path.node;
|
||||
const {
|
||||
formatter = SQL_FORMATTER,
|
||||
type,
|
||||
database,
|
||||
dialect,
|
||||
language,
|
||||
params,
|
||||
paramTypes,
|
||||
autoDetectDialect = true,
|
||||
...formatOptions
|
||||
} = options;
|
||||
|
||||
let formatted;
|
||||
|
||||
if (typeof value === 'string') {
|
||||
// 准备sql-formatter选项
|
||||
const sqlFormatterOptions = {
|
||||
...formatOptions,
|
||||
params:
|
||||
params == null
|
||||
? undefined
|
||||
: JSOX.parse(params),
|
||||
paramTypes:
|
||||
paramTypes == null
|
||||
? undefined
|
||||
: JSOX.parse(paramTypes),
|
||||
};
|
||||
|
||||
let finalLanguage = language;
|
||||
let finalDialect = dialect;
|
||||
|
||||
if (autoDetectDialect && !language && !dialect) {
|
||||
const detectedDialect = detectDialect(value);
|
||||
finalLanguage = detectedDialect;
|
||||
}
|
||||
|
||||
// 使用适当的格式化方法
|
||||
if (finalDialect != null) {
|
||||
// 使用formatDialect方法
|
||||
formatted = formatDialect(value, {
|
||||
...sqlFormatterOptions,
|
||||
dialect: JSOX.parse(finalDialect),
|
||||
});
|
||||
} else {
|
||||
// 使用format方法
|
||||
formatted = format(value, {
|
||||
...sqlFormatterOptions,
|
||||
language: finalLanguage,
|
||||
});
|
||||
}
|
||||
} else {
|
||||
// 使用node-sql-parser进行格式化
|
||||
formatted = parser.sqlify(value, { type, database });
|
||||
}
|
||||
|
||||
return formatted + '\n';
|
||||
},
|
||||
},
|
||||
};
|
||||
|
||||
// 插件选项
|
||||
export const options = {
|
||||
formatter: {
|
||||
category: 'Config',
|
||||
type: 'choice',
|
||||
default: SQL_FORMATTER,
|
||||
description: 'Choose which formatter to be used',
|
||||
choices: [
|
||||
{
|
||||
value: SQL_FORMATTER,
|
||||
description: 'use `sql-formatter` as formatter',
|
||||
},
|
||||
{
|
||||
value: NODE_SQL_PARSER,
|
||||
description: 'use `node-sql-parser` as formatter',
|
||||
},
|
||||
],
|
||||
},
|
||||
autoDetectDialect: {
|
||||
category: 'Config',
|
||||
type: 'boolean',
|
||||
default: true,
|
||||
description: 'Automatically detect SQL dialect if language/dialect is not specified',
|
||||
},
|
||||
dialect: {
|
||||
category: 'Config',
|
||||
type: 'string',
|
||||
description: 'SQL dialect for `sql-formatter` formatDialect()',
|
||||
},
|
||||
language: {
|
||||
category: 'Config',
|
||||
type: 'choice',
|
||||
default: 'sql',
|
||||
description: 'SQL dialect for `sql-formatter` format()',
|
||||
choices: [
|
||||
{
|
||||
value: 'sql',
|
||||
description: 'Standard SQL: https://en.wikipedia.org/wiki/SQL:2011',
|
||||
},
|
||||
{
|
||||
value: 'bigquery',
|
||||
description:
|
||||
'Google Standard SQL (Bigquery): https://cloud.google.com/bigquery',
|
||||
},
|
||||
{
|
||||
value: 'db2',
|
||||
description: 'IBM DB2: https://www.ibm.com/products/db2',
|
||||
},
|
||||
{
|
||||
value: 'db2i',
|
||||
description:
|
||||
'IBM DB2i (experimental): https://www.ibm.com/docs/en/i/7.5?topic=overview-db2-i',
|
||||
},
|
||||
{
|
||||
value: 'hive',
|
||||
description: 'Apache Hive: https://hive.apache.org',
|
||||
},
|
||||
{
|
||||
value: 'mariadb',
|
||||
description: 'MariaDB: https://mariadb.com',
|
||||
},
|
||||
{
|
||||
value: 'mysql',
|
||||
description: 'MySQL: https://www.mysql.com',
|
||||
},
|
||||
{
|
||||
value: 'n1ql',
|
||||
description:
|
||||
'Couchbase N1QL: https://www.couchbase.com/products/n1ql',
|
||||
},
|
||||
{
|
||||
value: 'plsql',
|
||||
description:
|
||||
'Oracle PL/SQL: https://www.oracle.com/database/technologies/appdev/plsql.html',
|
||||
},
|
||||
{
|
||||
value: 'postgresql',
|
||||
description: 'PostgreSQL: https://www.postgresql.org',
|
||||
},
|
||||
{
|
||||
value: 'redshift',
|
||||
description:
|
||||
'Amazon Redshift: https://docs.aws.amazon.com/redshift/latest/dg/cm_chap_SQLCommandRef.html',
|
||||
},
|
||||
{
|
||||
value: 'singlestoredb',
|
||||
description:
|
||||
'SingleStoreDB: https://docs.singlestore.com/db/v7.8/en/introduction/singlestore-documentation.html',
|
||||
},
|
||||
{
|
||||
value: 'snowflake',
|
||||
description: 'Snowflake: https://docs.snowflake.com',
|
||||
},
|
||||
{
|
||||
value: 'spark',
|
||||
description: 'Spark: https://spark.apache.org',
|
||||
},
|
||||
{
|
||||
value: 'sqlite',
|
||||
description: 'SQLite: https://www.sqlite.org',
|
||||
},
|
||||
{
|
||||
value: 'transactsql',
|
||||
description:
|
||||
'SQL Server Transact-SQL: https://docs.microsoft.com/en-us/sql/sql-server/',
|
||||
},
|
||||
{
|
||||
value: 'tsql',
|
||||
description:
|
||||
'SQL Server Transact-SQL: https://docs.microsoft.com/en-us/sql/sql-server/',
|
||||
},
|
||||
{
|
||||
value: 'trino',
|
||||
description: 'Trino: https://trino.io',
|
||||
},
|
||||
],
|
||||
},
|
||||
keywordCase: {
|
||||
category: 'Output',
|
||||
type: 'choice',
|
||||
default: 'preserve',
|
||||
description:
|
||||
'Converts reserved keywords to upper- or lowercase for `sql-formatter`',
|
||||
choices: [
|
||||
{
|
||||
value: 'preserve',
|
||||
description: 'preserves the original case of reserved keywords',
|
||||
},
|
||||
{
|
||||
value: 'upper',
|
||||
description: 'converts reserved keywords to uppercase',
|
||||
},
|
||||
{
|
||||
value: 'lower',
|
||||
description: 'converts reserved keywords to lowercase',
|
||||
},
|
||||
],
|
||||
},
|
||||
dataTypeCase: {
|
||||
category: 'Output',
|
||||
type: 'choice',
|
||||
default: 'preserve',
|
||||
description:
|
||||
'Converts data types to upper- or lowercase for `sql-formatter`',
|
||||
choices: [
|
||||
{
|
||||
value: 'preserve',
|
||||
description: 'preserves the original case of data types',
|
||||
},
|
||||
{
|
||||
value: 'upper',
|
||||
description: 'converts data types to uppercase',
|
||||
},
|
||||
{
|
||||
value: 'lower',
|
||||
description: 'converts data types to lowercase',
|
||||
},
|
||||
],
|
||||
},
|
||||
functionCase: {
|
||||
category: 'Output',
|
||||
type: 'choice',
|
||||
default: 'preserve',
|
||||
description:
|
||||
'Converts functions to upper- or lowercase for `sql-formatter`',
|
||||
choices: [
|
||||
{
|
||||
value: 'preserve',
|
||||
description: 'preserves the original case of functions',
|
||||
},
|
||||
{
|
||||
value: 'upper',
|
||||
description: 'converts functions to uppercase',
|
||||
},
|
||||
{
|
||||
value: 'lower',
|
||||
description: 'converts functions to lowercase',
|
||||
},
|
||||
],
|
||||
},
|
||||
identifierCase: {
|
||||
category: 'Output',
|
||||
type: 'choice',
|
||||
default: 'preserve',
|
||||
description:
|
||||
'Converts identifiers to upper- or lowercase for `sql-formatter`. Only unquoted identifiers are converted. (experimental)',
|
||||
choices: [
|
||||
{
|
||||
value: 'preserve',
|
||||
description: 'preserves the original case of identifiers',
|
||||
},
|
||||
{
|
||||
value: 'upper',
|
||||
description: 'converts identifiers to uppercase',
|
||||
},
|
||||
{
|
||||
value: 'lower',
|
||||
description: 'converts identifiers to lowercase',
|
||||
},
|
||||
],
|
||||
},
|
||||
uppercase: {
|
||||
category: 'Output',
|
||||
type: 'boolean',
|
||||
deprecated: '0.7.0',
|
||||
description: 'Use `keywordCase` option instead',
|
||||
},
|
||||
indentStyle: {
|
||||
category: 'Format',
|
||||
type: 'choice',
|
||||
default: 'standard',
|
||||
description: `Switches between different indentation styles for \`sql-formatter\`.
|
||||
|
||||
Caveats of using \`"tabularLeft"\` and \`"tabularRight"\`:
|
||||
|
||||
- \`tabWidth\` option is ignored. Indentation will always be 10 spaces, regardless of what is specified by \`tabWidth\``,
|
||||
choices: [
|
||||
{
|
||||
value: 'standard',
|
||||
description:
|
||||
'indents code by the amount specified by `tabWidth` option',
|
||||
},
|
||||
{
|
||||
value: 'tabularLeft',
|
||||
description:
|
||||
'indents in tabular style with 10 spaces, aligning keywords to left',
|
||||
},
|
||||
{
|
||||
value: 'tabularRight',
|
||||
description:
|
||||
'indents in tabular style with 10 spaces, aligning keywords to right',
|
||||
},
|
||||
],
|
||||
},
|
||||
logicalOperatorNewline: {
|
||||
category: 'Format',
|
||||
type: 'choice',
|
||||
default: 'before',
|
||||
description:
|
||||
'Decides newline placement before or after logical operators (AND, OR, XOR)',
|
||||
choices: [
|
||||
{
|
||||
value: 'before',
|
||||
description: 'adds newline before the operator',
|
||||
},
|
||||
{
|
||||
value: 'after',
|
||||
description: 'adds newline after the operator',
|
||||
},
|
||||
],
|
||||
},
|
||||
expressionWidth: {
|
||||
category: 'Format',
|
||||
type: 'int',
|
||||
default: 50,
|
||||
description:
|
||||
'Determines maximum length of parenthesized expressions for `sql-formatter`',
|
||||
},
|
||||
linesBetweenQueries: {
|
||||
category: 'Format',
|
||||
type: 'int',
|
||||
default: 1,
|
||||
description:
|
||||
'Decides how many empty lines to leave between SQL statements for `sql-formatter`',
|
||||
},
|
||||
denseOperators: {
|
||||
category: 'Format',
|
||||
type: 'boolean',
|
||||
default: false,
|
||||
description:
|
||||
'Decides whitespace around operators for `sql-formatter`. Does not apply to logical operators (AND, OR, XOR).',
|
||||
},
|
||||
newlineBeforeSemicolon: {
|
||||
category: 'Format',
|
||||
type: 'boolean',
|
||||
default: false,
|
||||
description:
|
||||
'Whether to place query separator (`;`) on a separate line for `sql-formatter`',
|
||||
},
|
||||
params: {
|
||||
category: 'Format',
|
||||
type: 'string',
|
||||
description:
|
||||
'Specifies `JSOX` **stringified** parameter values to fill in for placeholders inside SQL for `sql-formatter`. This option is designed to be used through API (though nothing really prevents usage from command line).',
|
||||
},
|
||||
paramTypes: {
|
||||
category: 'Config',
|
||||
type: 'string',
|
||||
description:
|
||||
'Specifies `JSOX` **stringified** parameter types to support when parsing SQL prepared statements for `sql-formatter`.',
|
||||
},
|
||||
type: {
|
||||
category: 'Config',
|
||||
type: 'choice',
|
||||
default: 'table',
|
||||
description: 'Check the SQL with Authority List for `node-sql-parser`',
|
||||
choices: [
|
||||
{
|
||||
value: 'table',
|
||||
description: '`table` mode',
|
||||
},
|
||||
{
|
||||
value: 'column',
|
||||
description: '`column` mode',
|
||||
},
|
||||
],
|
||||
},
|
||||
database: {
|
||||
category: 'Config',
|
||||
type: 'choice',
|
||||
default: 'mysql',
|
||||
description: 'SQL dialect for `node-sql-parser`',
|
||||
choices: [
|
||||
{
|
||||
value: 'bigquery',
|
||||
description: 'BigQuery: https://cloud.google.com/bigquery',
|
||||
},
|
||||
{
|
||||
value: 'db2',
|
||||
description: 'IBM DB2: https://www.ibm.com/analytics/db2',
|
||||
},
|
||||
{
|
||||
value: 'hive',
|
||||
description: 'Hive: https://hive.apache.org',
|
||||
},
|
||||
{
|
||||
value: 'mariadb',
|
||||
description: 'MariaDB: https://mariadb.com',
|
||||
},
|
||||
{
|
||||
value: 'mysql',
|
||||
description: 'MySQL: https://www.mysql.com',
|
||||
},
|
||||
{
|
||||
value: 'postgresql',
|
||||
description: 'PostgreSQL: https://www.postgresql.org',
|
||||
},
|
||||
{
|
||||
value: 'transactsql',
|
||||
description:
|
||||
'TransactSQL: https://docs.microsoft.com/en-us/sql/t-sql',
|
||||
},
|
||||
{
|
||||
value: 'flinksql',
|
||||
description:
|
||||
'FlinkSQL: https://ci.apache.org/projects/flink/flink-docs-stable',
|
||||
},
|
||||
{
|
||||
value: 'snowflake',
|
||||
description: 'Snowflake (alpha): https://docs.snowflake.com',
|
||||
},
|
||||
],
|
||||
},
|
||||
};
|
||||
|
||||
const SqlPlugin = {
|
||||
languages,
|
||||
parsers,
|
||||
printers,
|
||||
options,
|
||||
};
|
||||
|
||||
export { languages };
|
||||
export default SqlPlugin;
|
||||
Reference in New Issue
Block a user