🚧 Modify toml,powershell prettier plugin(beta)
This commit is contained in:
@@ -79,22 +79,32 @@ const initGoRuntimeNode = async () => {
|
||||
|
||||
// Browser Go runtime initialization
|
||||
const initGoRuntimeBrowser = async () => {
|
||||
if (globalThis.Go) return;
|
||||
|
||||
// 总是重新初始化，因为可能存在版本不兼容问题
|
||||
try {
|
||||
// Load wasm_exec.js dynamically in browser
|
||||
// 移除旧的 Go 运行时
|
||||
delete globalThis.Go;
|
||||
|
||||
// 动态导入本地的 wasm_exec.js 内容
|
||||
const wasmExecResponse = await fetch('/wasm_exec.js');
|
||||
if (!wasmExecResponse.ok) {
|
||||
throw new Error(`Failed to fetch wasm_exec.js: ${wasmExecResponse.status}`);
|
||||
}
|
||||
|
||||
const wasmExecCode = await wasmExecResponse.text();
|
||||
|
||||
// 在全局作用域中执行 wasm_exec.js 代码
|
||||
const script = document.createElement('script');
|
||||
script.src = '/wasm_exec.js';
|
||||
script.textContent = wasmExecCode;
|
||||
document.head.appendChild(script);
|
||||
|
||||
await new Promise((resolve, reject) => {
|
||||
script.onload = resolve;
|
||||
script.onerror = () => reject(new Error('Failed to load wasm_exec.js'));
|
||||
});
|
||||
|
||||
// 等待一小段时间确保脚本执行完成
|
||||
await new Promise(resolve => setTimeout(resolve, 100));
|
||||
|
||||
if (!globalThis.Go) {
|
||||
throw new Error('Go WASM runtime not available after loading wasm_exec.js');
|
||||
throw new Error('Go WASM runtime not available after executing wasm_exec.js');
|
||||
}
|
||||
|
||||
console.log('Go runtime initialized successfully');
|
||||
} catch (error) {
|
||||
console.error('Browser Go runtime initialization failed:', error);
|
||||
throw error;
|
||||
@@ -108,37 +118,70 @@ const initialize = async () => {
|
||||
initializePromise = (async () => {
|
||||
let wasmBuffer;
|
||||
|
||||
console.log('Starting Go WASM initialization...');
|
||||
|
||||
// Environment-specific initialization
|
||||
if (isNode()) {
|
||||
console.log('Initializing for Node.js environment');
|
||||
await initGoRuntimeNode();
|
||||
wasmBuffer = await loadWasmNode();
|
||||
} else if (isBrowser()) {
|
||||
console.log('Initializing for Browser environment');
|
||||
await initGoRuntimeBrowser();
|
||||
wasmBuffer = await loadWasmBrowser();
|
||||
} else {
|
||||
throw new Error('Unsupported environment: neither Node.js nor Browser detected');
|
||||
}
|
||||
|
||||
console.log('Creating Go instance...');
|
||||
const go = new globalThis.Go();
|
||||
const { instance } = await WebAssembly.instantiate(wasmBuffer, go.importObject);
|
||||
|
||||
// Run Go program (don't await as it's a long-running service)
|
||||
go.run(instance).catch(err => {
|
||||
console.error('Go WASM program exit error:', err);
|
||||
});
|
||||
|
||||
// 详细检查 importObject
|
||||
console.log('Go import object keys:', Object.keys(go.importObject));
|
||||
if (go.importObject.gojs) {
|
||||
console.log('gojs import keys:', Object.keys(go.importObject.gojs));
|
||||
console.log('scheduleTimeoutEvent type:', typeof go.importObject.gojs['runtime.scheduleTimeoutEvent']);
|
||||
}
|
||||
|
||||
console.log('Instantiating WebAssembly module...');
|
||||
|
||||
try {
|
||||
const { instance } = await WebAssembly.instantiate(wasmBuffer, go.importObject);
|
||||
console.log('WebAssembly instantiation successful');
|
||||
|
||||
console.log('Running Go program...');
|
||||
// Run Go program (don't await as it's a long-running service)
|
||||
go.run(instance).catch(err => {
|
||||
console.error('Go WASM program exit error:', err);
|
||||
});
|
||||
} catch (instantiateError) {
|
||||
console.error('WebAssembly instantiation failed:', instantiateError);
|
||||
console.error('Error details:', {
|
||||
message: instantiateError.message,
|
||||
name: instantiateError.name,
|
||||
stack: instantiateError.stack
|
||||
});
|
||||
throw instantiateError;
|
||||
}
|
||||
|
||||
// Wait for Go program to initialize and expose formatGo function
|
||||
console.log('Waiting for formatGo function to be available...');
|
||||
let retries = 0;
|
||||
const maxRetries = 10;
|
||||
const maxRetries = 20; // 增加重试次数
|
||||
|
||||
while (typeof globalThis.formatGo !== 'function' && retries < maxRetries) {
|
||||
await new Promise(resolve => setTimeout(resolve, 100));
|
||||
await new Promise(resolve => setTimeout(resolve, 200)); // 增加等待时间
|
||||
retries++;
|
||||
if (retries % 5 === 0) {
|
||||
console.log(`Waiting for formatGo function... (${retries}/${maxRetries})`);
|
||||
}
|
||||
}
|
||||
|
||||
if (typeof globalThis.formatGo !== 'function') {
|
||||
throw new Error('Go WASM module not properly initialized - formatGo function not available');
|
||||
throw new Error('Go WASM module not properly initialized - formatGo function not available after 20 retries');
|
||||
}
|
||||
|
||||
console.log('Go WASM initialization completed successfully');
|
||||
})();
|
||||
|
||||
return initializePromise;
|
||||
@@ -147,14 +190,14 @@ const initialize = async () => {
|
||||
export const languages = [
|
||||
{
|
||||
name: "Go",
|
||||
parsers: ["go"],
|
||||
parsers: ["go-format"],
|
||||
extensions: [".go"],
|
||||
vscodeLanguageIds: ["go"],
|
||||
},
|
||||
];
|
||||
|
||||
export const parsers = {
|
||||
go: {
|
||||
"go-format": {
|
||||
parse: (text) => text,
|
||||
astFormat: "go-format",
|
||||
locStart: (node) => 0,
|
||||
@@ -164,23 +207,35 @@ export const parsers = {
|
||||
|
||||
export const printers = {
|
||||
"go-format": {
|
||||
print: async (path) => {
|
||||
await initialize();
|
||||
print: (path) => {
|
||||
const text = path.getValue();
|
||||
|
||||
if (typeof globalThis.formatGo !== 'function') {
|
||||
throw new Error('Go WASM module not properly initialized - formatGo function missing');
|
||||
// 如果 formatGo 函数不可用，尝试初始化
|
||||
initialize().then(() => {
|
||||
// 初始化完成后，formatGo 应该可用
|
||||
}).catch(err => {
|
||||
console.error('Go WASM initialization failed:', err);
|
||||
});
|
||||
|
||||
// 如果还是不可用，返回原始文本
|
||||
return text;
|
||||
}
|
||||
|
||||
try {
|
||||
return globalThis.formatGo(text);
|
||||
} catch (error) {
|
||||
throw new Error(`Go formatting failed: ${error.message}`);
|
||||
console.error('Go formatting failed:', error);
|
||||
// 返回原始文本而不是抛出错误
|
||||
return text;
|
||||
}
|
||||
},
|
||||
},
|
||||
};
|
||||
|
||||
// Export initialize function for manual initialization
|
||||
export { initialize };
|
||||
|
||||
// Default export for Prettier plugin compatibility
|
||||
export default {
|
||||
languages,
|
||||
|
||||
Binary file not shown.
391
frontend/src/common/prettier/plugins/powershell/ast.ts
Normal file
391
frontend/src/common/prettier/plugins/powershell/ast.ts
Normal file
@@ -0,0 +1,391 @@
|
||||
/**
|
||||
* PowerShell AST 节点定义
|
||||
* 定义抽象语法树的各种节点类型
|
||||
*/
|
||||
|
||||
import { Token } from './lexer';
|
||||
|
||||
export interface ASTNode {
|
||||
type: string;
|
||||
start: number;
|
||||
end: number;
|
||||
line: number;
|
||||
column: number;
|
||||
}
|
||||
|
||||
export interface ScriptBlockAst extends ASTNode {
|
||||
type: 'ScriptBlock';
|
||||
statements: StatementAst[];
|
||||
}
|
||||
|
||||
export interface StatementAst extends ASTNode {
|
||||
type: string;
|
||||
}
|
||||
|
||||
export interface ExpressionAst extends ASTNode {
|
||||
type: string;
|
||||
}
|
||||
|
||||
// 管道表达式
|
||||
export interface PipelineAst extends StatementAst {
|
||||
type: 'Pipeline';
|
||||
elements: PipelineElementAst[];
|
||||
}
|
||||
|
||||
export interface PipelineElementAst extends ASTNode {
|
||||
type: 'PipelineElement';
|
||||
expression: ExpressionAst;
|
||||
}
|
||||
|
||||
// 命令表达式
|
||||
export interface CommandAst extends ExpressionAst {
|
||||
type: 'Command';
|
||||
commandName: string;
|
||||
parameters: ParameterAst[];
|
||||
arguments: ExpressionAst[];
|
||||
}
|
||||
|
||||
export interface ParameterAst extends ASTNode {
|
||||
type: 'Parameter';
|
||||
name: string;
|
||||
value?: ExpressionAst;
|
||||
}
|
||||
|
||||
// 赋值表达式
|
||||
export interface AssignmentAst extends StatementAst {
|
||||
type: 'Assignment';
|
||||
left: ExpressionAst;
|
||||
operator: string;
|
||||
right: ExpressionAst;
|
||||
}
|
||||
|
||||
// 变量表达式
|
||||
export interface VariableAst extends ExpressionAst {
|
||||
type: 'Variable';
|
||||
name: string;
|
||||
}
|
||||
|
||||
// 字面量表达式
|
||||
export interface LiteralAst extends ExpressionAst {
|
||||
type: 'Literal';
|
||||
value: any;
|
||||
literalType: 'String' | 'Number' | 'Boolean' | 'Null';
|
||||
}
|
||||
|
||||
// 数组表达式
|
||||
export interface ArrayAst extends ExpressionAst {
|
||||
type: 'Array';
|
||||
elements: ExpressionAst[];
|
||||
}
|
||||
|
||||
// 哈希表表达式
|
||||
export interface HashtableAst extends ExpressionAst {
|
||||
type: 'Hashtable';
|
||||
entries: HashtableEntryAst[];
|
||||
}
|
||||
|
||||
export interface HashtableEntryAst extends ASTNode {
|
||||
type: 'HashtableEntry';
|
||||
key: ExpressionAst;
|
||||
value: ExpressionAst;
|
||||
}
|
||||
|
||||
// 函数定义
|
||||
export interface FunctionDefinitionAst extends StatementAst {
|
||||
type: 'FunctionDefinition';
|
||||
name: string;
|
||||
parameters: ParameterAst[];
|
||||
body: ScriptBlockAst;
|
||||
}
|
||||
|
||||
// 控制流结构
|
||||
export interface IfStatementAst extends StatementAst {
|
||||
type: 'IfStatement';
|
||||
condition: ExpressionAst;
|
||||
ifBody: ScriptBlockAst;
|
||||
elseIfClauses: ElseIfClauseAst[];
|
||||
elseBody?: ScriptBlockAst;
|
||||
}
|
||||
|
||||
export interface ElseIfClauseAst extends ASTNode {
|
||||
type: 'ElseIfClause';
|
||||
condition: ExpressionAst;
|
||||
body: ScriptBlockAst;
|
||||
}
|
||||
|
||||
export interface WhileStatementAst extends StatementAst {
|
||||
type: 'WhileStatement';
|
||||
condition: ExpressionAst;
|
||||
body: ScriptBlockAst;
|
||||
}
|
||||
|
||||
export interface ForStatementAst extends StatementAst {
|
||||
type: 'ForStatement';
|
||||
initializer?: ExpressionAst;
|
||||
condition?: ExpressionAst;
|
||||
iterator?: ExpressionAst;
|
||||
body: ScriptBlockAst;
|
||||
}
|
||||
|
||||
export interface ForEachStatementAst extends StatementAst {
|
||||
type: 'ForEachStatement';
|
||||
variable: VariableAst;
|
||||
iterable: ExpressionAst;
|
||||
body: ScriptBlockAst;
|
||||
}
|
||||
|
||||
export interface SwitchStatementAst extends StatementAst {
|
||||
type: 'SwitchStatement';
|
||||
value: ExpressionAst;
|
||||
clauses: SwitchClauseAst[];
|
||||
}
|
||||
|
||||
export interface SwitchClauseAst extends ASTNode {
|
||||
type: 'SwitchClause';
|
||||
pattern: ExpressionAst;
|
||||
body: ScriptBlockAst;
|
||||
}
|
||||
|
||||
export interface TryStatementAst extends StatementAst {
|
||||
type: 'TryStatement';
|
||||
body: ScriptBlockAst;
|
||||
catchClauses: CatchClauseAst[];
|
||||
finallyClause?: FinallyClauseAst;
|
||||
}
|
||||
|
||||
export interface CatchClauseAst extends ASTNode {
|
||||
type: 'CatchClause';
|
||||
exceptionType?: string;
|
||||
body: ScriptBlockAst;
|
||||
}
|
||||
|
||||
export interface FinallyClauseAst extends ASTNode {
|
||||
type: 'FinallyClause';
|
||||
body: ScriptBlockAst;
|
||||
}
|
||||
|
||||
// 二元操作表达式
|
||||
export interface BinaryExpressionAst extends ExpressionAst {
|
||||
type: 'BinaryExpression';
|
||||
left: ExpressionAst;
|
||||
operator: string;
|
||||
right: ExpressionAst;
|
||||
}
|
||||
|
||||
// 一元操作表达式
|
||||
export interface UnaryExpressionAst extends ExpressionAst {
|
||||
type: 'UnaryExpression';
|
||||
operator: string;
|
||||
operand: ExpressionAst;
|
||||
}
|
||||
|
||||
// 括号表达式
|
||||
export interface ParenthesizedExpressionAst extends ExpressionAst {
|
||||
type: 'ParenthesizedExpression';
|
||||
expression: ExpressionAst;
|
||||
}
|
||||
|
||||
// 方法调用表达式
|
||||
export interface MethodCallAst extends ExpressionAst {
|
||||
type: 'MethodCall';
|
||||
object: ExpressionAst;
|
||||
methodName: string;
|
||||
arguments: ExpressionAst[];
|
||||
}
|
||||
|
||||
// 属性访问表达式
|
||||
export interface PropertyAccessAst extends ExpressionAst {
|
||||
type: 'PropertyAccess';
|
||||
object: ExpressionAst;
|
||||
propertyName: string;
|
||||
}
|
||||
|
||||
// 索引访问表达式
|
||||
export interface IndexAccessAst extends ExpressionAst {
|
||||
type: 'IndexAccess';
|
||||
object: ExpressionAst;
|
||||
index: ExpressionAst;
|
||||
}
|
||||
|
||||
// 注释节点
|
||||
export interface CommentAst extends ASTNode {
|
||||
type: 'Comment';
|
||||
text: string;
|
||||
isMultiline: boolean;
|
||||
}
|
||||
|
||||
// 空白节点
|
||||
export interface WhitespaceAst extends ASTNode {
|
||||
type: 'Whitespace';
|
||||
text: string;
|
||||
}
|
||||
|
||||
// 工厂函数，用于创建AST节点
|
||||
export class ASTNodeFactory {
|
||||
static createScriptBlock(statements: StatementAst[], start: number, end: number, line: number, column: number): ScriptBlockAst {
|
||||
return {
|
||||
type: 'ScriptBlock',
|
||||
statements,
|
||||
start,
|
||||
end,
|
||||
line,
|
||||
column
|
||||
};
|
||||
}
|
||||
|
||||
static createPipeline(elements: PipelineElementAst[], start: number, end: number, line: number, column: number): PipelineAst {
|
||||
return {
|
||||
type: 'Pipeline',
|
||||
elements,
|
||||
start,
|
||||
end,
|
||||
line,
|
||||
column
|
||||
};
|
||||
}
|
||||
|
||||
static createCommand(commandName: string, parameters: ParameterAst[], args: ExpressionAst[], start: number, end: number, line: number, column: number): CommandAst {
|
||||
return {
|
||||
type: 'Command',
|
||||
commandName,
|
||||
parameters,
|
||||
arguments: args,
|
||||
start,
|
||||
end,
|
||||
line,
|
||||
column
|
||||
};
|
||||
}
|
||||
|
||||
static createAssignment(left: ExpressionAst, operator: string, right: ExpressionAst, start: number, end: number, line: number, column: number): AssignmentAst {
|
||||
return {
|
||||
type: 'Assignment',
|
||||
left,
|
||||
operator,
|
||||
right,
|
||||
start,
|
||||
end,
|
||||
line,
|
||||
column
|
||||
};
|
||||
}
|
||||
|
||||
static createVariable(name: string, start: number, end: number, line: number, column: number): VariableAst {
|
||||
return {
|
||||
type: 'Variable',
|
||||
name,
|
||||
start,
|
||||
end,
|
||||
line,
|
||||
column
|
||||
};
|
||||
}
|
||||
|
||||
static createLiteral(value: any, literalType: 'String' | 'Number' | 'Boolean' | 'Null', start: number, end: number, line: number, column: number): LiteralAst {
|
||||
return {
|
||||
type: 'Literal',
|
||||
value,
|
||||
literalType,
|
||||
start,
|
||||
end,
|
||||
line,
|
||||
column
|
||||
};
|
||||
}
|
||||
|
||||
static createBinaryExpression(left: ExpressionAst, operator: string, right: ExpressionAst, start: number, end: number, line: number, column: number): BinaryExpressionAst {
|
||||
return {
|
||||
type: 'BinaryExpression',
|
||||
left,
|
||||
operator,
|
||||
right,
|
||||
start,
|
||||
end,
|
||||
line,
|
||||
column
|
||||
};
|
||||
}
|
||||
|
||||
static createIfStatement(condition: ExpressionAst, ifBody: ScriptBlockAst, elseIfClauses: ElseIfClauseAst[], elseBody: ScriptBlockAst | undefined, start: number, end: number, line: number, column: number): IfStatementAst {
|
||||
return {
|
||||
type: 'IfStatement',
|
||||
condition,
|
||||
ifBody,
|
||||
elseIfClauses,
|
||||
elseBody,
|
||||
start,
|
||||
end,
|
||||
line,
|
||||
column
|
||||
};
|
||||
}
|
||||
|
||||
static createFunctionDefinition(name: string, parameters: ParameterAst[], body: ScriptBlockAst, start: number, end: number, line: number, column: number): FunctionDefinitionAst {
|
||||
return {
|
||||
type: 'FunctionDefinition',
|
||||
name,
|
||||
parameters,
|
||||
body,
|
||||
start,
|
||||
end,
|
||||
line,
|
||||
column
|
||||
};
|
||||
}
|
||||
|
||||
static createComment(text: string, isMultiline: boolean, start: number, end: number, line: number, column: number): CommentAst {
|
||||
return {
|
||||
type: 'Comment',
|
||||
text,
|
||||
isMultiline,
|
||||
start,
|
||||
end,
|
||||
line,
|
||||
column
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
// AST访问者模式接口
|
||||
export interface ASTVisitor<T> {
|
||||
visitScriptBlock(node: ScriptBlockAst): T;
|
||||
visitPipeline(node: PipelineAst): T;
|
||||
visitCommand(node: CommandAst): T;
|
||||
visitAssignment(node: AssignmentAst): T;
|
||||
visitVariable(node: VariableAst): T;
|
||||
visitLiteral(node: LiteralAst): T;
|
||||
visitBinaryExpression(node: BinaryExpressionAst): T;
|
||||
visitIfStatement(node: IfStatementAst): T;
|
||||
visitFunctionDefinition(node: FunctionDefinitionAst): T;
|
||||
visitComment(node: CommentAst): T;
|
||||
}
|
||||
|
||||
// AST遍历工具类
|
||||
export class ASTTraverser {
|
||||
static traverse<T>(node: ASTNode, visitor: Partial<ASTVisitor<T>>): T | undefined {
|
||||
switch (node.type) {
|
||||
case 'ScriptBlock':
|
||||
return visitor.visitScriptBlock?.(node as ScriptBlockAst);
|
||||
case 'Pipeline':
|
||||
return visitor.visitPipeline?.(node as PipelineAst);
|
||||
case 'Command':
|
||||
return visitor.visitCommand?.(node as CommandAst);
|
||||
case 'Assignment':
|
||||
return visitor.visitAssignment?.(node as AssignmentAst);
|
||||
case 'Variable':
|
||||
return visitor.visitVariable?.(node as VariableAst);
|
||||
case 'Literal':
|
||||
return visitor.visitLiteral?.(node as LiteralAst);
|
||||
case 'BinaryExpression':
|
||||
return visitor.visitBinaryExpression?.(node as BinaryExpressionAst);
|
||||
case 'IfStatement':
|
||||
return visitor.visitIfStatement?.(node as IfStatementAst);
|
||||
case 'FunctionDefinition':
|
||||
return visitor.visitFunctionDefinition?.(node as FunctionDefinitionAst);
|
||||
case 'Comment':
|
||||
return visitor.visitComment?.(node as CommentAst);
|
||||
default:
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,566 @@
|
||||
/**
|
||||
* PowerShell 代码生成器
|
||||
* 遍历AST并根据格式化规则生成格式化的PowerShell代码
|
||||
*/
|
||||
|
||||
import {
|
||||
ASTNode,
|
||||
ScriptBlockAst,
|
||||
StatementAst,
|
||||
ExpressionAst,
|
||||
PipelineAst,
|
||||
CommandAst,
|
||||
AssignmentAst,
|
||||
VariableAst,
|
||||
LiteralAst,
|
||||
BinaryExpressionAst,
|
||||
IfStatementAst,
|
||||
FunctionDefinitionAst,
|
||||
ParameterAst,
|
||||
CommentAst,
|
||||
PipelineElementAst,
|
||||
ElseIfClauseAst,
|
||||
ASTTraverser
|
||||
} from './ast';
|
||||
import { FormatterRules, FormatterOptions } from './formatter-rules';
|
||||
|
||||
export class PowerShellCodeGenerator {
|
||||
private rules: FormatterRules;
|
||||
private indentLevel: number = 0;
|
||||
private output: string[] = [];
|
||||
private currentLineLength: number = 0;
|
||||
private needsNewline: boolean = false;
|
||||
private lastWasComment: boolean = false;
|
||||
|
||||
constructor(options: Partial<FormatterOptions> = {}) {
|
||||
this.rules = new FormatterRules(options);
|
||||
}
|
||||
|
||||
/**
|
||||
* 生成格式化的PowerShell代码
|
||||
*/
|
||||
public generate(ast: ScriptBlockAst, comments: CommentAst[] = []): string {
|
||||
this.output = [];
|
||||
this.indentLevel = 0;
|
||||
this.currentLineLength = 0;
|
||||
this.needsNewline = false;
|
||||
this.lastWasComment = false;
|
||||
|
||||
// 首先处理文档开头的注释
|
||||
this.generateLeadingComments(comments);
|
||||
|
||||
// 生成主体代码
|
||||
this.generateScriptBlock(ast);
|
||||
|
||||
// 处理文档末尾
|
||||
this.handleFinalNewline();
|
||||
|
||||
const result = this.output.join('');
|
||||
return this.postProcess(result);
|
||||
}
|
||||
|
||||
private generateScriptBlock(node: ScriptBlockAst): void {
|
||||
for (let i = 0; i < node.statements.length; i++) {
|
||||
const statement = node.statements[i];
|
||||
const nextStatement = i < node.statements.length - 1 ? node.statements[i + 1] : null;
|
||||
|
||||
this.generateStatement(statement);
|
||||
|
||||
// 在语句之间添加适当的空行
|
||||
if (nextStatement) {
|
||||
this.addStatementSeparation(statement, nextStatement);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private generateStatement(statement: StatementAst): void {
|
||||
switch (statement.type) {
|
||||
case 'Pipeline':
|
||||
this.generatePipeline(statement as PipelineAst);
|
||||
break;
|
||||
case 'Assignment':
|
||||
this.generateAssignment(statement as AssignmentAst);
|
||||
break;
|
||||
case 'IfStatement':
|
||||
this.generateIfStatement(statement as IfStatementAst);
|
||||
break;
|
||||
case 'FunctionDefinition':
|
||||
this.generateFunctionDefinition(statement as FunctionDefinitionAst);
|
||||
break;
|
||||
case 'RawText':
|
||||
// 处理解析失败时的原始文本
|
||||
this.append((statement as any).value);
|
||||
return; // 不需要添加额外的换行
|
||||
default:
|
||||
this.append(`/* Unsupported statement type: ${statement.type} */`);
|
||||
break;
|
||||
}
|
||||
|
||||
this.ensureNewline();
|
||||
}
|
||||
|
||||
private generatePipeline(pipeline: PipelineAst): void {
|
||||
if (!this.rules.formatPipelines) {
|
||||
// 简单连接所有元素
|
||||
for (let i = 0; i < pipeline.elements.length; i++) {
|
||||
if (i > 0) {
|
||||
this.append(' | ');
|
||||
}
|
||||
this.generatePipelineElement(pipeline.elements[i]);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
const style = this.rules.getPipelineStyle(pipeline.elements.length);
|
||||
|
||||
if (style === 'multiline') {
|
||||
this.generateMultilinePipeline(pipeline);
|
||||
} else {
|
||||
this.generateOnelinePipeline(pipeline);
|
||||
}
|
||||
}
|
||||
|
||||
private generateOnelinePipeline(pipeline: PipelineAst): void {
|
||||
for (let i = 0; i < pipeline.elements.length; i++) {
|
||||
if (i > 0) {
|
||||
this.append(' | ');
|
||||
}
|
||||
this.generatePipelineElement(pipeline.elements[i]);
|
||||
}
|
||||
}
|
||||
|
||||
private generateMultilinePipeline(pipeline: PipelineAst): void {
|
||||
for (let i = 0; i < pipeline.elements.length; i++) {
|
||||
if (i > 0) {
|
||||
this.appendLine(' |');
|
||||
this.appendIndent();
|
||||
}
|
||||
this.generatePipelineElement(pipeline.elements[i]);
|
||||
}
|
||||
}
|
||||
|
||||
private generatePipelineElement(element: PipelineElementAst): void {
|
||||
this.generateExpression(element.expression);
|
||||
}
|
||||
|
||||
private generateExpression(expression: ExpressionAst): void {
|
||||
switch (expression.type) {
|
||||
case 'Command':
|
||||
this.generateCommand(expression as CommandAst);
|
||||
break;
|
||||
case 'Variable':
|
||||
this.generateVariable(expression as VariableAst);
|
||||
break;
|
||||
case 'Literal':
|
||||
this.generateLiteral(expression as LiteralAst);
|
||||
break;
|
||||
case 'BinaryExpression':
|
||||
this.generateBinaryExpression(expression as BinaryExpressionAst);
|
||||
break;
|
||||
case 'ParenthesizedExpression':
|
||||
this.append('(');
|
||||
this.generateExpression((expression as any).expression);
|
||||
this.append(')');
|
||||
break;
|
||||
case 'Array':
|
||||
this.generateArray(expression as any);
|
||||
break;
|
||||
case 'Hashtable':
|
||||
this.generateHashtable(expression as any);
|
||||
break;
|
||||
case 'ScriptBlockExpression':
|
||||
this.generateScriptBlockExpression(expression as any);
|
||||
break;
|
||||
default:
|
||||
this.append(`/* Unsupported expression type: ${expression.type} */`);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
private generateCommand(command: CommandAst): void {
|
||||
// 保持cmdlet名称的连字符，不进行破坏性的格式化
|
||||
let commandName = command.commandName;
|
||||
|
||||
// 只有在明确指定要改变大小写时才进行格式化
|
||||
// 但绝对不能删除连字符
|
||||
if (this.rules.shouldFormatCommandCase()) {
|
||||
commandName = this.rules.formatCommandCase(commandName);
|
||||
}
|
||||
|
||||
this.append(commandName);
|
||||
|
||||
// 生成参数
|
||||
for (const param of command.parameters) {
|
||||
this.append(' ');
|
||||
this.generateParameter(param);
|
||||
}
|
||||
|
||||
// 生成位置参数
|
||||
for (const arg of command.arguments) {
|
||||
this.append(' ');
|
||||
this.generateExpression(arg);
|
||||
}
|
||||
}
|
||||
|
||||
private generateParameter(parameter: ParameterAst): void {
|
||||
const paramName = this.rules.formatParameterCase(parameter.name);
|
||||
this.append(paramName);
|
||||
|
||||
if (parameter.value) {
|
||||
this.append(' ');
|
||||
this.generateExpression(parameter.value);
|
||||
}
|
||||
}
|
||||
|
||||
private generateVariable(variable: VariableAst): void {
|
||||
const formattedName = this.rules.formatVariableCase(variable.name);
|
||||
this.append(formattedName);
|
||||
}
|
||||
|
||||
private generateLiteral(literal: LiteralAst): void {
|
||||
if (literal.literalType === 'String') {
|
||||
const formattedString = this.rules.formatQuotes(literal.value as string);
|
||||
this.append(formattedString);
|
||||
} else {
|
||||
this.append(String(literal.value));
|
||||
}
|
||||
}
|
||||
|
||||
private generateBinaryExpression(expression: BinaryExpressionAst): void {
|
||||
this.generateExpression(expression.left);
|
||||
|
||||
// 根据PowerShell官方规范，属性访问操作符绝对不能加空格
|
||||
if (expression.operator === '.' ||
|
||||
expression.operator === '::' ||
|
||||
expression.operator === '[' ||
|
||||
expression.operator === ']' ||
|
||||
expression.operator === '@{') {
|
||||
// 属性访问是PowerShell面向对象的核心，必须保持紧凑
|
||||
this.append(expression.operator);
|
||||
} else {
|
||||
// 使用格式化规则处理其他操作符
|
||||
const formattedOperator = this.rules.formatOperatorSpacing(expression.operator);
|
||||
this.append(formattedOperator);
|
||||
}
|
||||
|
||||
this.generateExpression(expression.right);
|
||||
}
|
||||
|
||||
private generateAssignment(assignment: AssignmentAst): void {
|
||||
this.generateExpression(assignment.left);
|
||||
|
||||
const formattedOperator = this.rules.formatOperatorSpacing(assignment.operator);
|
||||
this.append(formattedOperator);
|
||||
|
||||
this.generateExpression(assignment.right);
|
||||
}
|
||||
|
||||
private generateIfStatement(ifStmt: IfStatementAst): void {
|
||||
// if 条件
|
||||
this.append('if ');
|
||||
this.append(this.rules.formatParentheses(''));
|
||||
this.append('(');
|
||||
this.generateExpression(ifStmt.condition);
|
||||
this.append(')');
|
||||
|
||||
// if 主体
|
||||
this.append(this.rules.getBraceStart());
|
||||
this.appendLine('');
|
||||
this.indent();
|
||||
this.generateScriptBlock(ifStmt.ifBody);
|
||||
this.outdent();
|
||||
this.appendIndent();
|
||||
this.append('}');
|
||||
|
||||
// elseif 子句
|
||||
for (const elseIfClause of ifStmt.elseIfClauses) {
|
||||
this.generateElseIfClause(elseIfClause);
|
||||
}
|
||||
|
||||
// else 子句
|
||||
if (ifStmt.elseBody) {
|
||||
this.append(' else');
|
||||
this.append(this.rules.getBraceStart());
|
||||
this.appendLine('');
|
||||
this.indent();
|
||||
this.generateScriptBlock(ifStmt.elseBody);
|
||||
this.outdent();
|
||||
this.appendIndent();
|
||||
this.append('}');
|
||||
}
|
||||
}
|
||||
|
||||
private generateElseIfClause(elseIf: ElseIfClauseAst): void {
|
||||
this.append(' elseif (');
|
||||
this.generateExpression(elseIf.condition);
|
||||
this.append(')');
|
||||
this.append(this.rules.getBraceStart());
|
||||
this.appendLine('');
|
||||
this.indent();
|
||||
this.generateScriptBlock(elseIf.body);
|
||||
this.outdent();
|
||||
this.appendIndent();
|
||||
this.append('}');
|
||||
}
|
||||
|
||||
private generateFunctionDefinition(func: FunctionDefinitionAst): void {
|
||||
// 函数前的空行
|
||||
if (this.rules.blankLinesAroundFunctions > 0) {
|
||||
for (let i = 0; i < this.rules.blankLinesAroundFunctions; i++) {
|
||||
this.appendLine('');
|
||||
}
|
||||
}
|
||||
|
||||
this.append('function ');
|
||||
this.append(func.name);
|
||||
|
||||
// 参数列表
|
||||
if (func.parameters.length > 0) {
|
||||
this.append('(');
|
||||
for (let i = 0; i < func.parameters.length; i++) {
|
||||
if (i > 0) {
|
||||
this.append(this.rules.formatComma());
|
||||
}
|
||||
this.generateParameter(func.parameters[i]);
|
||||
}
|
||||
this.append(')');
|
||||
}
|
||||
|
||||
// 函数体
|
||||
this.append(this.rules.getBraceStart());
|
||||
this.appendLine('');
|
||||
this.indent();
|
||||
this.generateScriptBlock(func.body);
|
||||
this.outdent();
|
||||
this.appendIndent();
|
||||
this.append('}');
|
||||
|
||||
// 函数后的空行
|
||||
if (this.rules.blankLinesAroundFunctions > 0) {
|
||||
for (let i = 0; i < this.rules.blankLinesAroundFunctions; i++) {
|
||||
this.appendLine('');
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private generateLeadingComments(comments: CommentAst[]): void {
|
||||
const leadingComments = comments.filter(c => this.isLeadingComment(c));
|
||||
for (const comment of leadingComments) {
|
||||
this.generateComment(comment);
|
||||
this.appendLine('');
|
||||
}
|
||||
}
|
||||
|
||||
private generateComment(comment: CommentAst): void {
|
||||
if (!this.rules.formatComments) {
|
||||
this.append(comment.text);
|
||||
return;
|
||||
}
|
||||
|
||||
if (comment.isMultiline) {
|
||||
this.generateMultilineComment(comment.text);
|
||||
} else {
|
||||
this.generateSingleLineComment(comment.text);
|
||||
}
|
||||
|
||||
this.lastWasComment = true;
|
||||
}
|
||||
|
||||
private generateArray(arrayExpr: any): void {
|
||||
this.append('@(');
|
||||
if (arrayExpr.elements && arrayExpr.elements.length > 0) {
|
||||
for (let i = 0; i < arrayExpr.elements.length; i++) {
|
||||
if (i > 0) {
|
||||
this.append(this.rules.formatComma());
|
||||
}
|
||||
this.generateExpression(arrayExpr.elements[i]);
|
||||
}
|
||||
}
|
||||
this.append(')');
|
||||
}
|
||||
|
||||
private generateHashtable(hashtableExpr: any): void {
|
||||
this.append('@{');
|
||||
|
||||
if (hashtableExpr.entries && hashtableExpr.entries.length > 0) {
|
||||
// 强制使用紧凑格式，避免换行问题
|
||||
for (let i = 0; i < hashtableExpr.entries.length; i++) {
|
||||
const entry = hashtableExpr.entries[i];
|
||||
|
||||
this.generateExpression(entry.key);
|
||||
this.append('=');
|
||||
this.generateExpression(entry.value);
|
||||
|
||||
// 如果不是最后一个条目，添加分号和空格
|
||||
if (i < hashtableExpr.entries.length - 1) {
|
||||
this.append('; ');
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
this.append('}');
|
||||
}
|
||||
|
||||
private generateScriptBlockExpression(scriptBlockExpr: any): void {
|
||||
this.append('{');
|
||||
|
||||
// 对原始内容应用基本的格式化规则
|
||||
if (scriptBlockExpr.rawContent) {
|
||||
const formattedContent = this.formatScriptBlockContent(scriptBlockExpr.rawContent);
|
||||
this.append(formattedContent);
|
||||
} else if (scriptBlockExpr.expression) {
|
||||
// 兼容旧格式
|
||||
this.generateExpression(scriptBlockExpr.expression);
|
||||
}
|
||||
|
||||
this.append('}');
|
||||
}
|
||||
|
||||
private formatScriptBlockContent(content: string): string {
|
||||
if (!content || !content.trim()) {
|
||||
return content;
|
||||
}
|
||||
|
||||
// 应用PowerShell官方规范的格式化规则
|
||||
let formatted = content.trim();
|
||||
|
||||
// 1. 保护所有属性访问操作符 - 这是最关键的
|
||||
// 匹配所有形式的属性访问：$var.Property, $_.Property, $obj.Method.Property等
|
||||
formatted = formatted.replace(/(\$[a-zA-Z_][a-zA-Z0-9_]*|\$_)\s*\.\s*([a-zA-Z_][a-zA-Z0-9_]*)/g, '$1.$2');
|
||||
|
||||
// 2. 保护方法调用中的点号
|
||||
formatted = formatted.replace(/(\w)\s*\.\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\(/g, '$1.$2(');
|
||||
|
||||
// 3. 确保数字单位不被分离
|
||||
formatted = formatted.replace(/(\d+)\s*(KB|MB|GB|TB|PB)/gi, '$1$2');
|
||||
|
||||
// 4. PowerShell比较和逻辑操作符需要前后空格
|
||||
const powershellOps = [
|
||||
'-eq', '-ne', '-lt', '-le', '-gt', '-ge',
|
||||
'-like', '-notlike', '-match', '-notmatch',
|
||||
'-contains', '-notcontains', '-in', '-notin',
|
||||
'-is', '-isnot', '-as', '-and', '-or', '-not', '-xor'
|
||||
];
|
||||
|
||||
for (const op of powershellOps) {
|
||||
const regex = new RegExp(`\\s*${op.replace('-', '\\-')}\\s*`, 'gi');
|
||||
formatted = formatted.replace(regex, ` ${op} `);
|
||||
}
|
||||
|
||||
// 5. 清理多余空格，但保护属性访问
|
||||
formatted = formatted.replace(/\s{2,}/g, ' ').trim();
|
||||
|
||||
// 6. 最终检查：确保没有属性访问被破坏
|
||||
formatted = formatted.replace(/(\$\w+|\$_)\s+\.\s*/g, '$1.');
|
||||
|
||||
return formatted;
|
||||
}
|
||||
|
||||
|
||||
private generateSingleLineComment(text: string): void {
|
||||
// 确保单行注释以 # 开头
|
||||
const cleanText = text.startsWith('#') ? text : `# ${text}`;
|
||||
this.append(cleanText);
|
||||
}
|
||||
|
||||
private generateMultilineComment(text: string): void {
|
||||
// 多行注释保持原格式
|
||||
this.append(text);
|
||||
}
|
||||
|
||||
private isLeadingComment(comment: CommentAst): boolean {
|
||||
// 简单判断：如果注释在文档开头，就认为是前导注释
|
||||
return comment.line <= 3;
|
||||
}
|
||||
|
||||
private addStatementSeparation(current: StatementAst, next: StatementAst): void {
|
||||
// 函数之间添加空行
|
||||
if (current.type === 'FunctionDefinition' || next.type === 'FunctionDefinition') {
|
||||
this.appendLine('');
|
||||
}
|
||||
|
||||
// 控制结构前添加空行
|
||||
if (next.type === 'IfStatement' && !this.lastWasComment) {
|
||||
this.appendLine('');
|
||||
}
|
||||
}
|
||||
|
||||
private handleFinalNewline(): void {
|
||||
if (this.rules.insertFinalNewline && this.output.length > 0) {
|
||||
const lastLine = this.output[this.output.length - 1];
|
||||
if (!lastLine.endsWith(this.rules.getNewline())) {
|
||||
this.appendLine('');
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private postProcess(code: string): string {
|
||||
let result = code;
|
||||
|
||||
// 清理多余的空行
|
||||
if (this.rules.maxConsecutiveEmptyLines >= 0) {
|
||||
const maxEmpty = this.rules.maxConsecutiveEmptyLines;
|
||||
const emptyLinePattern = new RegExp(`(${this.rules.getNewline()}){${maxEmpty + 2},}`, 'g');
|
||||
const replacement = this.rules.getNewline().repeat(maxEmpty + 1);
|
||||
result = result.replace(emptyLinePattern, replacement);
|
||||
}
|
||||
|
||||
// 清理行尾空白
|
||||
if (this.rules.trimTrailingWhitespace) {
|
||||
result = result.replace(/ +$/gm, '');
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
// 辅助方法
|
||||
private append(text: string): void {
|
||||
this.output.push(text);
|
||||
this.currentLineLength += text.length;
|
||||
this.needsNewline = false;
|
||||
this.lastWasComment = false;
|
||||
}
|
||||
|
||||
private appendLine(text: string): void {
|
||||
this.output.push(text + this.rules.getNewline());
|
||||
this.currentLineLength = 0;
|
||||
this.needsNewline = false;
|
||||
this.lastWasComment = false;
|
||||
}
|
||||
|
||||
private appendIndent(): void {
|
||||
const indent = this.rules.getIndent(this.indentLevel);
|
||||
this.append(indent);
|
||||
}
|
||||
|
||||
private ensureNewline(): void {
|
||||
if (!this.needsNewline) {
|
||||
this.appendLine('');
|
||||
this.needsNewline = true;
|
||||
}
|
||||
}
|
||||
|
||||
private indent(): void {
|
||||
this.indentLevel++;
|
||||
}
|
||||
|
||||
private outdent(): void {
|
||||
this.indentLevel = Math.max(0, this.indentLevel - 1);
|
||||
}
|
||||
|
||||
private shouldWrapLine(): boolean {
|
||||
return this.currentLineLength > this.rules.printWidth;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 便捷函数：格式化PowerShell AST
|
||||
*/
|
||||
export function formatPowerShellAST(
|
||||
ast: ScriptBlockAst,
|
||||
comments: CommentAst[] = [],
|
||||
options: Partial<FormatterOptions> = {}
|
||||
): string {
|
||||
const generator = new PowerShellCodeGenerator(options);
|
||||
return generator.generate(ast, comments);
|
||||
}
|
||||
@@ -0,0 +1,440 @@
|
||||
/**
|
||||
* PowerShell 格式化规则引擎
|
||||
* 定义各种可配置的代码格式化规则和策略
|
||||
*/
|
||||
|
||||
export interface FormatterOptions {
|
||||
// 基本格式化选项
|
||||
indentSize: number; // 缩进大小
|
||||
useTabsForIndentation: boolean; // 使用制表符还是空格
|
||||
printWidth: number; // 行最大长度
|
||||
endOfLine: 'lf' | 'crlf' | 'cr' | 'auto'; // 行尾符类型
|
||||
|
||||
// 空格和间距
|
||||
spaceAroundOperators: boolean; // 操作符周围的空格
|
||||
spaceAfterCommas: boolean; // 逗号后的空格
|
||||
spaceAfterSemicolons: boolean; // 分号后的空格
|
||||
spaceInsideParentheses: boolean; // 括号内的空格
|
||||
spaceInsideBrackets: boolean; // 方括号内的空格
|
||||
spaceInsideBraces: boolean; // 大括号内的空格
|
||||
|
||||
// 换行和空行
|
||||
maxConsecutiveEmptyLines: number; // 最大连续空行数
|
||||
insertFinalNewline: boolean; // 文件末尾插入换行符
|
||||
trimTrailingWhitespace: boolean; // 删除行尾空白
|
||||
blankLinesAroundFunctions: number; // 函数前后的空行数
|
||||
blankLinesAroundClasses: number; // 类前后的空行数
|
||||
blankLinesAroundIfStatements: boolean; // if语句前后的空行
|
||||
|
||||
// 括号和大括号
|
||||
braceStyle: 'allman' | 'otbs' | 'stroustrup'; // 大括号风格
|
||||
alwaysParenthesizeArrowFunctions: boolean; // 箭头函数总是用括号
|
||||
|
||||
// PowerShell特定选项
|
||||
formatPipelines: boolean; // 格式化管道
|
||||
pipelineStyle: 'oneline' | 'multiline' | 'auto'; // 管道风格
|
||||
formatParameters: boolean; // 格式化参数
|
||||
parameterAlignment: 'left' | 'right' | 'auto'; // 参数对齐方式
|
||||
formatHashtables: boolean; // 格式化哈希表
|
||||
hashtableStyle: 'compact' | 'expanded'; // 哈希表风格
|
||||
formatArrays: boolean; // 格式化数组
|
||||
arrayStyle: 'compact' | 'expanded'; // 数组风格
|
||||
formatComments: boolean; // 格式化注释
|
||||
commentAlignment: 'left' | 'preserve'; // 注释对齐方式
|
||||
|
||||
// 命名和大小写
|
||||
preferredCommandCase: 'lowercase' | 'uppercase' | 'pascalcase' | 'preserve'; // 命令大小写
|
||||
preferredParameterCase: 'lowercase' | 'uppercase' | 'pascalcase' | 'preserve'; // 参数大小写
|
||||
preferredVariableCase: 'camelcase' | 'pascalcase' | 'preserve'; // 变量大小写
|
||||
|
||||
// 引号和字符串
|
||||
quotestyle: 'single' | 'double' | 'preserve'; // 引号风格
|
||||
escapeNonAscii: boolean; // 转义非ASCII字符
|
||||
|
||||
// 长度和换行
|
||||
wrapLongLines: boolean; // 自动换行长行
|
||||
wrapParameters: boolean; // 换行长参数列表
|
||||
wrapArrays: boolean; // 换行长数组
|
||||
wrapHashtables: boolean; // 换行长哈希表
|
||||
}
|
||||
|
||||
export const DEFAULT_OPTIONS: FormatterOptions = {
|
||||
// 基本选项
|
||||
indentSize: 4,
|
||||
useTabsForIndentation: false,
|
||||
printWidth: 120,
|
||||
endOfLine: 'auto',
|
||||
|
||||
// 空格设置
|
||||
spaceAroundOperators: true,
|
||||
spaceAfterCommas: true,
|
||||
spaceAfterSemicolons: true,
|
||||
spaceInsideParentheses: false,
|
||||
spaceInsideBrackets: false,
|
||||
spaceInsideBraces: true,
|
||||
|
||||
// 空行设置
|
||||
maxConsecutiveEmptyLines: 2,
|
||||
insertFinalNewline: true,
|
||||
trimTrailingWhitespace: true,
|
||||
blankLinesAroundFunctions: 1,
|
||||
blankLinesAroundClasses: 1,
|
||||
blankLinesAroundIfStatements: false,
|
||||
|
||||
// 括号风格
|
||||
braceStyle: 'otbs', // One True Brace Style
|
||||
alwaysParenthesizeArrowFunctions: false,
|
||||
|
||||
// PowerShell特定
|
||||
formatPipelines: true,
|
||||
pipelineStyle: 'auto',
|
||||
formatParameters: true,
|
||||
parameterAlignment: 'left',
|
||||
formatHashtables: true,
|
||||
hashtableStyle: 'compact',
|
||||
formatArrays: true,
|
||||
arrayStyle: 'compact',
|
||||
formatComments: true,
|
||||
commentAlignment: 'preserve',
|
||||
|
||||
// 命名约定
|
||||
preferredCommandCase: 'pascalcase',
|
||||
preferredParameterCase: 'preserve',
|
||||
preferredVariableCase: 'preserve',
|
||||
|
||||
// 字符串设置
|
||||
quotestyle: 'preserve',
|
||||
escapeNonAscii: false,
|
||||
|
||||
// 长度处理
|
||||
wrapLongLines: true,
|
||||
wrapParameters: true,
|
||||
wrapArrays: true,
|
||||
wrapHashtables: true
|
||||
};
|
||||
|
||||
/**
|
||||
* 格式化规则类，包含各种格式化策略的实现
|
||||
*/
|
||||
export class FormatterRules {
|
||||
private options: FormatterOptions;
|
||||
|
||||
constructor(options: Partial<FormatterOptions> = {}) {
|
||||
this.options = { ...DEFAULT_OPTIONS, ...options };
|
||||
}
|
||||
|
||||
/**
|
||||
* 获取缩进字符串
|
||||
*/
|
||||
getIndent(level: number): string {
|
||||
if (level <= 0) return '';
|
||||
|
||||
const indentChar = this.options.useTabsForIndentation ? '\t' : ' ';
|
||||
const indentSize = this.options.useTabsForIndentation ? 1 : this.options.indentSize;
|
||||
|
||||
return indentChar.repeat(level * indentSize);
|
||||
}
|
||||
|
||||
/**
|
||||
* 获取换行符
|
||||
*/
|
||||
getNewline(): string {
|
||||
switch (this.options.endOfLine) {
|
||||
case 'lf': return '\n';
|
||||
case 'crlf': return '\r\n';
|
||||
case 'cr': return '\r';
|
||||
case 'auto':
|
||||
default:
|
||||
// 在浏览器环境中默认使用 LF
|
||||
return '\n';
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 格式化操作符周围的空格
|
||||
*/
|
||||
formatOperatorSpacing(operator: string): string {
|
||||
if (!this.options.spaceAroundOperators) {
|
||||
return operator;
|
||||
}
|
||||
|
||||
// PowerShell语法中绝对不能加空格的操作符（官方规范）
|
||||
const noSpaceOperators = [
|
||||
'.', '::', // 属性访问和静态成员访问 - 这是PowerShell面向对象的核心
|
||||
'[', ']', // 数组索引和类型转换
|
||||
'(', ')', '{', '}', // 括号
|
||||
'@{', // 哈希表字面量开始
|
||||
';', // 哈希表和语句分隔符
|
||||
'-', // cmdlet连字符（Get-ChildItem中的-）
|
||||
'::' // 静态成员访问
|
||||
];
|
||||
|
||||
if (noSpaceOperators.includes(operator)) {
|
||||
return operator;
|
||||
}
|
||||
|
||||
// PowerShell比较操作符需要空格
|
||||
const powershellOperators = ['-eq', '-ne', '-lt', '-le', '-gt', '-ge',
|
||||
'-like', '-notlike', '-match', '-notmatch',
|
||||
'-contains', '-notcontains', '-in', '-notin',
|
||||
'-is', '-isnot', '-as', '-and', '-or', '-not', '-xor'];
|
||||
|
||||
if (powershellOperators.some(op => operator.toLowerCase() === op)) {
|
||||
return ` ${operator} `;
|
||||
}
|
||||
|
||||
// 算术和赋值操作符需要空格
|
||||
const spaceOperators = ['=', '+=', '-=', '*=', '/=', '%=', '+', '*', '/', '%'];
|
||||
if (spaceOperators.includes(operator)) {
|
||||
return ` ${operator} `;
|
||||
}
|
||||
|
||||
return operator;
|
||||
}
|
||||
|
||||
/**
|
||||
* 格式化逗号后的空格
|
||||
*/
|
||||
formatComma(): string {
|
||||
return this.options.spaceAfterCommas ? ', ' : ',';
|
||||
}
|
||||
|
||||
/**
|
||||
* 格式化分号后的空格
|
||||
*/
|
||||
formatSemicolon(): string {
|
||||
return this.options.spaceAfterSemicolons ? '; ' : ';';
|
||||
}
|
||||
|
||||
/**
|
||||
* 格式化括号内的空格
|
||||
*/
|
||||
formatParentheses(content: string): string {
|
||||
if (this.options.spaceInsideParentheses) {
|
||||
return `( ${content} )`;
|
||||
}
|
||||
return `(${content})`;
|
||||
}
|
||||
|
||||
/**
|
||||
* 格式化方括号内的空格
|
||||
*/
|
||||
formatBrackets(content: string): string {
|
||||
if (this.options.spaceInsideBrackets) {
|
||||
return `[ ${content} ]`;
|
||||
}
|
||||
return `[${content}]`;
|
||||
}
|
||||
|
||||
/**
|
||||
* 格式化大括号内的空格
|
||||
*/
|
||||
formatBraces(content: string): string {
|
||||
if (this.options.spaceInsideBraces) {
|
||||
return `{ ${content} }`;
|
||||
}
|
||||
return `{${content}}`;
|
||||
}
|
||||
|
||||
/**
|
||||
* 获取大括号的开始位置
|
||||
*/
|
||||
getBraceStart(): string {
|
||||
switch (this.options.braceStyle) {
|
||||
case 'allman':
|
||||
return this.getNewline() + '{';
|
||||
case 'stroustrup':
|
||||
return this.getNewline() + '{';
|
||||
case 'otbs':
|
||||
default:
|
||||
return ' {';
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 格式化命令名的大小写
|
||||
*/
|
||||
formatCommandCase(command: string): string {
|
||||
switch (this.options.preferredCommandCase) {
|
||||
case 'lowercase':
|
||||
return command.toLowerCase();
|
||||
case 'uppercase':
|
||||
return command.toUpperCase();
|
||||
case 'pascalcase':
|
||||
return this.toPascalCasePreservingHyphens(command);
|
||||
case 'preserve':
|
||||
default:
|
||||
return command;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 检查是否应该格式化命令大小写
|
||||
*/
|
||||
shouldFormatCommandCase(): boolean {
|
||||
return this.options.preferredCommandCase !== 'preserve';
|
||||
}
|
||||
|
||||
/**
|
||||
* 格式化参数名的大小写
|
||||
*/
|
||||
formatParameterCase(parameter: string): string {
|
||||
switch (this.options.preferredParameterCase) {
|
||||
case 'lowercase':
|
||||
return parameter.toLowerCase();
|
||||
case 'uppercase':
|
||||
return parameter.toUpperCase();
|
||||
case 'pascalcase':
|
||||
return this.toPascalCase(parameter);
|
||||
case 'preserve':
|
||||
default:
|
||||
return parameter;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 格式化变量名的大小写
|
||||
*/
|
||||
formatVariableCase(variable: string): string {
|
||||
if (!variable.startsWith('$')) {
|
||||
return variable;
|
||||
}
|
||||
|
||||
const variableName = variable.substring(1);
|
||||
let formattedName: string;
|
||||
|
||||
switch (this.options.preferredVariableCase) {
|
||||
case 'camelcase':
|
||||
formattedName = this.toCamelCase(variableName);
|
||||
break;
|
||||
case 'pascalcase':
|
||||
formattedName = this.toPascalCase(variableName);
|
||||
break;
|
||||
case 'preserve':
|
||||
default:
|
||||
formattedName = variableName;
|
||||
break;
|
||||
}
|
||||
|
||||
return '$' + formattedName;
|
||||
}
|
||||
|
||||
/**
|
||||
* 格式化字符串引号
|
||||
*/
|
||||
formatQuotes(value: string): string {
|
||||
if (this.options.quotestyle === 'preserve') {
|
||||
return value;
|
||||
}
|
||||
|
||||
const content = this.extractStringContent(value);
|
||||
|
||||
switch (this.options.quotestyle) {
|
||||
case 'single':
|
||||
return `'${content.replace(/'/g, "''")}'`;
|
||||
case 'double':
|
||||
return `"${content.replace(/"/g, '""')}"`;
|
||||
default:
|
||||
return value;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 检查是否需要换行
|
||||
*/
|
||||
shouldWrapLine(line: string): boolean {
|
||||
return this.options.wrapLongLines && line.length > this.options.printWidth;
|
||||
}
|
||||
|
||||
/**
|
||||
* 获取管道样式
|
||||
*/
|
||||
getPipelineStyle(elementCount: number): 'oneline' | 'multiline' {
|
||||
switch (this.options.pipelineStyle) {
|
||||
case 'oneline':
|
||||
return 'oneline';
|
||||
case 'multiline':
|
||||
return 'multiline';
|
||||
case 'auto':
|
||||
default:
|
||||
return elementCount > 2 ? 'multiline' : 'oneline';
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 获取哈希表样式
|
||||
*/
|
||||
getHashtableStyle(entryCount: number): 'compact' | 'expanded' {
|
||||
if (this.options.hashtableStyle === 'compact') {
|
||||
return 'compact';
|
||||
}
|
||||
if (this.options.hashtableStyle === 'expanded') {
|
||||
return 'expanded';
|
||||
}
|
||||
// auto logic: 对于小型哈希表默认使用compact，避免不必要的换行
|
||||
return entryCount > 5 ? 'expanded' : 'compact';
|
||||
}
|
||||
|
||||
/**
|
||||
* 获取数组样式
|
||||
*/
|
||||
getArrayStyle(elementCount: number): 'compact' | 'expanded' {
|
||||
if (this.options.arrayStyle === 'compact') {
|
||||
return 'compact';
|
||||
}
|
||||
if (this.options.arrayStyle === 'expanded') {
|
||||
return 'expanded';
|
||||
}
|
||||
// auto logic could be added here
|
||||
return elementCount > 5 ? 'expanded' : 'compact';
|
||||
}
|
||||
|
||||
// 辅助方法
|
||||
private toPascalCase(str: string): string {
|
||||
return str.split(/[-_\s]/)
|
||||
.map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
|
||||
.join('');
|
||||
}
|
||||
|
||||
/**
|
||||
* 转换为PascalCase但保留连字符（专门用于PowerShell cmdlet）
|
||||
*/
|
||||
private toPascalCasePreservingHyphens(str: string): string {
|
||||
return str.split('-')
|
||||
.map(part => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
|
||||
.join('-');
|
||||
}
|
||||
|
||||
private toCamelCase(str: string): string {
|
||||
const pascalCase = this.toPascalCase(str);
|
||||
return pascalCase.charAt(0).toLowerCase() + pascalCase.slice(1);
|
||||
}
|
||||
|
||||
private extractStringContent(str: string): string {
|
||||
if ((str.startsWith('"') && str.endsWith('"')) ||
|
||||
(str.startsWith("'") && str.endsWith("'"))) {
|
||||
return str.slice(1, -1);
|
||||
}
|
||||
return str;
|
||||
}
|
||||
|
||||
// Getter methods for options
|
||||
get indentSize(): number { return this.options.indentSize; }
|
||||
get printWidth(): number { return this.options.printWidth; }
|
||||
get maxConsecutiveEmptyLines(): number { return this.options.maxConsecutiveEmptyLines; }
|
||||
get insertFinalNewline(): boolean { return this.options.insertFinalNewline; }
|
||||
get trimTrailingWhitespace(): boolean { return this.options.trimTrailingWhitespace; }
|
||||
get blankLinesAroundFunctions(): number { return this.options.blankLinesAroundFunctions; }
|
||||
get formatPipelines(): boolean { return this.options.formatPipelines; }
|
||||
get formatParameters(): boolean { return this.options.formatParameters; }
|
||||
get formatHashtables(): boolean { return this.options.formatHashtables; }
|
||||
get formatArrays(): boolean { return this.options.formatArrays; }
|
||||
get formatComments(): boolean { return this.options.formatComments; }
|
||||
|
||||
/**
|
||||
* 创建规则的副本，可以重写部分选项
|
||||
*/
|
||||
withOptions(overrides: Partial<FormatterOptions>): FormatterRules {
|
||||
return new FormatterRules({ ...this.options, ...overrides });
|
||||
}
|
||||
}
|
||||
@@ -1,20 +1,21 @@
|
||||
/**
|
||||
* Prettier Plugin for PowerShell file formatting
|
||||
* Prettier Plugin for PowerShell file formatting - Modular Version
|
||||
*
|
||||
* This plugin provides support for formatting PowerShell files (.ps1, .psm1, .psd1)
|
||||
* using PowerShell's native AST parser for accurate syntax analysis.
|
||||
* using a modular architecture with lexer, parser, AST, and code generator.
|
||||
*/
|
||||
import type { Plugin, Parser, Printer, AstPath, Doc } from 'prettier';
|
||||
import parse, { formatPowerShellCode } from './parse';
|
||||
import { PowerShellLexer } from './lexer';
|
||||
import { PowerShellParser } from './parser';
|
||||
import { ScriptBlockAst, CommentAst } from './ast';
|
||||
import { formatPowerShellAST } from './code-generator';
|
||||
import { FormatterOptions, DEFAULT_OPTIONS } from './formatter-rules';
|
||||
|
||||
// PowerShell AST节点接口
|
||||
interface PowerShellAstNode {
|
||||
type: string;
|
||||
value: string;
|
||||
start?: number;
|
||||
end?: number;
|
||||
parent?: PowerShellAstNode;
|
||||
extent?: any;
|
||||
// PowerShell格式化结果接口
|
||||
interface PowerShellParseResult {
|
||||
ast: ScriptBlockAst;
|
||||
comments: CommentAst[];
|
||||
originalText: string;
|
||||
}
|
||||
|
||||
const parserName = 'powershell';
|
||||
@@ -35,62 +36,159 @@ const languages = [
|
||||
];
|
||||
|
||||
// 解析器配置
|
||||
const powershellParser: Parser<PowerShellAstNode | PowerShellAstNode[]> = {
|
||||
parse,
|
||||
const powershellParser: Parser<PowerShellParseResult> = {
|
||||
parse: parseCode,
|
||||
astFormat: 'powershell',
|
||||
locStart: () => 0,
|
||||
locEnd: () => 0,
|
||||
locStart: (node: PowerShellParseResult) => 0,
|
||||
locEnd: (node: PowerShellParseResult) => node.originalText.length,
|
||||
};
|
||||
|
||||
const printPosh = (path: AstPath<PowerShellAstNode | PowerShellAstNode[]>, options: any, print: any): Doc => {
|
||||
const pathNode = path.node;
|
||||
|
||||
if (Array.isArray(pathNode)) {
|
||||
return pathNode.map(node => handleAst(node, path, options, print)).join('\n');
|
||||
}
|
||||
|
||||
return handleAst(pathNode, path, options, print);
|
||||
};
|
||||
|
||||
const handleAst = (node: PowerShellAstNode, path: AstPath<any>, options: any, print: any): Doc => {
|
||||
if (typeof node === 'undefined') {
|
||||
return '';
|
||||
}
|
||||
|
||||
// 使用修复后的PowerShell格式化器
|
||||
/**
|
||||
* 解析PowerShell代码
|
||||
*/
|
||||
async function parseCode(text: string, parsers?: any, options?: any): Promise<PowerShellParseResult> {
|
||||
try {
|
||||
const formattedCode = formatPowerShellCode(node.value, {
|
||||
indentSize: options.tabWidth || 4,
|
||||
useTabsForIndentation: options.useTabs || false,
|
||||
printWidth: options.printWidth || 120,
|
||||
// 词法分析
|
||||
const lexer = new PowerShellLexer(text);
|
||||
const tokens = lexer.tokenize();
|
||||
|
||||
// 语法分析
|
||||
const parser = new PowerShellParser(tokens, text);
|
||||
const ast = parser.parse();
|
||||
const comments = parser.getComments();
|
||||
|
||||
return {
|
||||
ast,
|
||||
comments,
|
||||
originalText: text
|
||||
};
|
||||
} catch (error) {
|
||||
console.warn('PowerShell parsing failed, using fallback:', error);
|
||||
|
||||
// 解析失败时，创建一个包含原始文本的简单AST
|
||||
// 这样可以确保格式化失败时返回原始代码而不是空内容
|
||||
return {
|
||||
ast: {
|
||||
type: 'ScriptBlock',
|
||||
statements: [{
|
||||
type: 'RawText',
|
||||
value: text,
|
||||
start: 0,
|
||||
end: text.length,
|
||||
line: 1,
|
||||
column: 1
|
||||
} as any],
|
||||
start: 0,
|
||||
end: text.length,
|
||||
line: 1,
|
||||
column: 1
|
||||
},
|
||||
comments: [],
|
||||
originalText: text
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* PowerShell代码打印器
|
||||
*/
|
||||
const printPowerShell = (path: AstPath<PowerShellParseResult>, options: any): Doc => {
|
||||
const parseResult = path.node;
|
||||
|
||||
try {
|
||||
// 构建格式化选项 - 优先保持原有格式，避免破坏PowerShell语法
|
||||
const formatterOptions: Partial<FormatterOptions> = {
|
||||
indentSize: options.tabWidth || DEFAULT_OPTIONS.indentSize,
|
||||
useTabsForIndentation: options.useTabs || DEFAULT_OPTIONS.useTabsForIndentation,
|
||||
printWidth: options.printWidth || DEFAULT_OPTIONS.printWidth,
|
||||
spaceAroundOperators: true,
|
||||
formatComments: true,
|
||||
removeExtraBlankLines: true,
|
||||
formatPipelines: true,
|
||||
formatParentheses: true,
|
||||
formatArraysAndHashtables: true,
|
||||
formatParameters: true,
|
||||
formatHashtables: true,
|
||||
hashtableStyle: 'compact', // 强制使用紧凑格式，避免不必要的换行
|
||||
formatArrays: true,
|
||||
arrayStyle: 'compact',
|
||||
formatComments: true,
|
||||
maxConsecutiveEmptyLines: 1,
|
||||
addBlankLinesAroundBlocks: true,
|
||||
formatLongLines: true,
|
||||
formatFunctionDefinitions: true,
|
||||
formatPowerShellSyntax: true,
|
||||
});
|
||||
insertFinalNewline: true,
|
||||
trimTrailingWhitespace: true,
|
||||
blankLinesAroundFunctions: 1,
|
||||
braceStyle: 'otbs',
|
||||
preferredCommandCase: 'preserve', // 保持原有命令大小写，不破坏语法
|
||||
preferredParameterCase: 'preserve',
|
||||
preferredVariableCase: 'preserve',
|
||||
quotestyle: 'preserve',
|
||||
wrapLongLines: true
|
||||
};
|
||||
|
||||
// 使用新的模块化格式化器
|
||||
const formattedCode = formatPowerShellAST(
|
||||
parseResult.ast,
|
||||
parseResult.comments,
|
||||
formatterOptions
|
||||
);
|
||||
|
||||
return formattedCode;
|
||||
} catch (error) {
|
||||
console.warn('PowerShell formatting failed, returning original code:', error);
|
||||
return node.value || '';
|
||||
return parseResult.originalText;
|
||||
}
|
||||
};
|
||||
|
||||
// 打印器配置
|
||||
const powershellPrinter: Printer<PowerShellAstNode | PowerShellAstNode[]> = {
|
||||
print: printPosh,
|
||||
const powershellPrinter: Printer<PowerShellParseResult> = {
|
||||
print: printPowerShell,
|
||||
};
|
||||
|
||||
// 插件选项
|
||||
// 插件选项配置
|
||||
const options = {
|
||||
|
||||
// PowerShell特定格式化选项
|
||||
powershellBraceStyle: {
|
||||
type: 'choice' as const,
|
||||
category: 'PowerShell',
|
||||
default: DEFAULT_OPTIONS.braceStyle,
|
||||
description: 'PowerShell大括号样式',
|
||||
choices: [
|
||||
{ value: 'allman', description: 'Allman风格（大括号另起一行）' },
|
||||
{ value: 'otbs', description: '1TBS风格（大括号同行）' },
|
||||
{ value: 'stroustrup', description: 'Stroustrup风格' }
|
||||
]
|
||||
},
|
||||
powershellCommandCase: {
|
||||
type: 'choice' as const,
|
||||
category: 'PowerShell',
|
||||
default: DEFAULT_OPTIONS.preferredCommandCase,
|
||||
description: 'PowerShell命令大小写风格',
|
||||
choices: [
|
||||
{ value: 'lowercase', description: '小写' },
|
||||
{ value: 'uppercase', description: '大写' },
|
||||
{ value: 'pascalcase', description: 'Pascal大小写' },
|
||||
{ value: 'preserve', description: '保持原样' }
|
||||
]
|
||||
},
|
||||
powershellPipelineStyle: {
|
||||
type: 'choice' as const,
|
||||
category: 'PowerShell',
|
||||
default: DEFAULT_OPTIONS.pipelineStyle,
|
||||
description: 'PowerShell管道样式',
|
||||
choices: [
|
||||
{ value: 'oneline', description: '单行' },
|
||||
{ value: 'multiline', description: '多行' },
|
||||
{ value: 'auto', description: '自动' }
|
||||
]
|
||||
},
|
||||
powershellSpaceAroundOperators: {
|
||||
type: 'boolean' as const,
|
||||
category: 'PowerShell',
|
||||
default: DEFAULT_OPTIONS.spaceAroundOperators,
|
||||
description: '在操作符周围添加空格'
|
||||
},
|
||||
powershellMaxEmptyLines: {
|
||||
type: 'int' as const,
|
||||
category: 'PowerShell',
|
||||
default: DEFAULT_OPTIONS.maxConsecutiveEmptyLines,
|
||||
description: '最大连续空行数'
|
||||
}
|
||||
};
|
||||
|
||||
const powershellPlugin: Plugin = {
|
||||
|
||||
722
frontend/src/common/prettier/plugins/powershell/lexer.ts
Normal file
722
frontend/src/common/prettier/plugins/powershell/lexer.ts
Normal file
@@ -0,0 +1,722 @@
|
||||
/**
|
||||
* PowerShell 词法分析器 (Lexer)
|
||||
* 将PowerShell代码分解为tokens，用于后续的语法分析和格式化
|
||||
*/
|
||||
|
||||
export enum TokenType {
|
||||
// 字面量
|
||||
STRING = 'STRING',
|
||||
NUMBER = 'NUMBER',
|
||||
VARIABLE = 'VARIABLE',
|
||||
|
||||
// 关键字
|
||||
KEYWORD = 'KEYWORD',
|
||||
FUNCTION = 'FUNCTION',
|
||||
|
||||
// 操作符
|
||||
OPERATOR = 'OPERATOR',
|
||||
ASSIGNMENT = 'ASSIGNMENT',
|
||||
COMPARISON = 'COMPARISON',
|
||||
LOGICAL = 'LOGICAL',
|
||||
ARITHMETIC = 'ARITHMETIC',
|
||||
|
||||
// 分隔符
|
||||
LEFT_PAREN = 'LEFT_PAREN',
|
||||
RIGHT_PAREN = 'RIGHT_PAREN',
|
||||
LEFT_BRACE = 'LEFT_BRACE',
|
||||
RIGHT_BRACE = 'RIGHT_BRACE',
|
||||
LEFT_BRACKET = 'LEFT_BRACKET',
|
||||
RIGHT_BRACKET = 'RIGHT_BRACKET',
|
||||
SEMICOLON = 'SEMICOLON',
|
||||
COMMA = 'COMMA',
|
||||
DOT = 'DOT',
|
||||
PIPE = 'PIPE',
|
||||
|
||||
// 特殊
|
||||
WHITESPACE = 'WHITESPACE',
|
||||
NEWLINE = 'NEWLINE',
|
||||
COMMENT = 'COMMENT',
|
||||
MULTILINE_COMMENT = 'MULTILINE_COMMENT',
|
||||
HERE_STRING = 'HERE_STRING',
|
||||
|
||||
// 控制结构
|
||||
IF = 'IF',
|
||||
ELSE = 'ELSE',
|
||||
ELSEIF = 'ELSEIF',
|
||||
WHILE = 'WHILE',
|
||||
FOR = 'FOR',
|
||||
FOREACH = 'FOREACH',
|
||||
SWITCH = 'SWITCH',
|
||||
TRY = 'TRY',
|
||||
CATCH = 'CATCH',
|
||||
FINALLY = 'FINALLY',
|
||||
|
||||
// 其他
|
||||
IDENTIFIER = 'IDENTIFIER',
|
||||
CMDLET = 'CMDLET',
|
||||
PARAMETER = 'PARAMETER',
|
||||
EOF = 'EOF',
|
||||
UNKNOWN = 'UNKNOWN'
|
||||
}
|
||||
|
||||
export interface Token {
|
||||
type: TokenType;
|
||||
value: string;
|
||||
line: number;
|
||||
column: number;
|
||||
startIndex: number;
|
||||
endIndex: number;
|
||||
}
|
||||
|
||||
export class PowerShellLexer {
|
||||
private code: string;
|
||||
private position: number = 0;
|
||||
private line: number = 1;
|
||||
private column: number = 1;
|
||||
private tokens: Token[] = [];
|
||||
|
||||
// PowerShell关键字
|
||||
private readonly keywords = new Set([
|
||||
'if', 'else', 'elseif', 'switch', 'while', 'for', 'foreach', 'do',
|
||||
'try', 'catch', 'finally', 'throw', 'return', 'break', 'continue',
|
||||
'function', 'filter', 'param', 'begin', 'process', 'end',
|
||||
'class', 'enum', 'using', 'namespace', 'workflow', 'configuration',
|
||||
'dynamicparam', 'exit'
|
||||
]);
|
||||
|
||||
// PowerShell比较操作符
|
||||
private readonly comparisonOperators = new Set([
|
||||
'-eq', '-ne', '-lt', '-le', '-gt', '-ge',
|
||||
'-like', '-notlike', '-match', '-notmatch',
|
||||
'-contains', '-notcontains', '-in', '-notin',
|
||||
'-is', '-isnot', '-as'
|
||||
]);
|
||||
|
||||
// PowerShell逻辑操作符
|
||||
private readonly logicalOperators = new Set([
|
||||
'-and', '-or', '-not', '-xor', '-band', '-bor', '-bxor', '-bnot'
|
||||
]);
|
||||
|
||||
constructor(code: string) {
|
||||
this.code = code;
|
||||
}
|
||||
|
||||
/**
|
||||
* 对代码进行词法分析，返回token数组
|
||||
*/
|
||||
public tokenize(): Token[] {
|
||||
this.position = 0;
|
||||
this.line = 1;
|
||||
this.column = 1;
|
||||
this.tokens = [];
|
||||
|
||||
while (this.position < this.code.length) {
|
||||
this.skipWhitespace();
|
||||
|
||||
if (this.position >= this.code.length) {
|
||||
break;
|
||||
}
|
||||
|
||||
const token = this.nextToken();
|
||||
if (token) {
|
||||
this.tokens.push(token);
|
||||
}
|
||||
}
|
||||
|
||||
this.tokens.push({
|
||||
type: TokenType.EOF,
|
||||
value: '',
|
||||
line: this.line,
|
||||
column: this.column,
|
||||
startIndex: this.position,
|
||||
endIndex: this.position
|
||||
});
|
||||
|
||||
return this.tokens;
|
||||
}
|
||||
|
||||
private nextToken(): Token | null {
|
||||
const startPos = this.position;
|
||||
const startLine = this.line;
|
||||
const startColumn = this.column;
|
||||
|
||||
const char = this.code[this.position];
|
||||
|
||||
// 处理换行
|
||||
if (char === '\n') {
|
||||
this.advance();
|
||||
return this.createToken(TokenType.NEWLINE, '\n', startPos, startLine, startColumn);
|
||||
}
|
||||
|
||||
// 处理注释
|
||||
if (char === '#') {
|
||||
return this.tokenizeComment(startPos, startLine, startColumn);
|
||||
}
|
||||
|
||||
// 处理多行注释
|
||||
if (char === '<' && this.peek() === '#') {
|
||||
return this.tokenizeMultilineComment(startPos, startLine, startColumn);
|
||||
}
|
||||
|
||||
// 处理字符串
|
||||
if (char === '"' || char === "'") {
|
||||
return this.tokenizeString(startPos, startLine, startColumn);
|
||||
}
|
||||
|
||||
// 处理Here-String
|
||||
if (char === '@' && (this.peek() === '"' || this.peek() === "'")) {
|
||||
return this.tokenizeHereString(startPos, startLine, startColumn);
|
||||
}
|
||||
|
||||
// 处理哈希表字面量 @{
|
||||
if (char === '@' && this.peek() === '{') {
|
||||
this.advance(); // skip '@'
|
||||
this.advance(); // skip '{'
|
||||
return this.createToken(TokenType.LEFT_BRACE, '@{', startPos, startLine, startColumn);
|
||||
}
|
||||
|
||||
// 处理变量
|
||||
if (char === '$') {
|
||||
return this.tokenizeVariable(startPos, startLine, startColumn);
|
||||
}
|
||||
|
||||
// 处理数字
|
||||
if (this.isDigit(char) || (char === '.' && this.isDigit(this.peek()))) {
|
||||
return this.tokenizeNumber(startPos, startLine, startColumn);
|
||||
}
|
||||
|
||||
// 处理操作符和分隔符
|
||||
const operatorToken = this.tokenizeOperator(startPos, startLine, startColumn);
|
||||
if (operatorToken) {
|
||||
return operatorToken;
|
||||
}
|
||||
|
||||
// 优先处理PowerShell比较操作符（以-开头）
|
||||
if (char === '-' && this.isIdentifierStart(this.peek())) {
|
||||
const potentialOperator = this.peekPowerShellOperator();
|
||||
if (potentialOperator) {
|
||||
return this.tokenizePowerShellOperator(startPos, startLine, startColumn);
|
||||
}
|
||||
// 如果不是操作符，可能是参数
|
||||
return this.tokenizeParameter(startPos, startLine, startColumn);
|
||||
}
|
||||
|
||||
// 处理标识符（包括cmdlet和关键字）
|
||||
if (this.isIdentifierStart(char)) {
|
||||
return this.tokenizeIdentifier(startPos, startLine, startColumn);
|
||||
}
|
||||
|
||||
// 处理PowerShell特殊字符
|
||||
if (char === '?') {
|
||||
this.advance();
|
||||
return this.createToken(TokenType.OPERATOR, char, startPos, startLine, startColumn);
|
||||
}
|
||||
|
||||
// 处理独立的减号（可能是负数或减法）
|
||||
if (char === '-') {
|
||||
this.advance();
|
||||
return this.createToken(TokenType.ARITHMETIC, char, startPos, startLine, startColumn);
|
||||
}
|
||||
|
||||
// 处理其他可能的特殊字符，作为标识符处理而不是未知字符
|
||||
if (this.isPrintableChar(char)) {
|
||||
this.advance();
|
||||
return this.createToken(TokenType.IDENTIFIER, char, startPos, startLine, startColumn);
|
||||
}
|
||||
|
||||
// 真正的未知字符（非打印字符等）
|
||||
this.advance();
|
||||
return this.createToken(TokenType.UNKNOWN, char, startPos, startLine, startColumn);
|
||||
}
|
||||
|
||||
private tokenizeComment(startPos: number, startLine: number, startColumn: number): Token {
|
||||
let value = '';
|
||||
while (this.position < this.code.length && this.code[this.position] !== '\n') {
|
||||
value += this.code[this.position];
|
||||
this.advance();
|
||||
}
|
||||
return this.createToken(TokenType.COMMENT, value, startPos, startLine, startColumn);
|
||||
}
|
||||
|
||||
private tokenizeMultilineComment(startPos: number, startLine: number, startColumn: number): Token {
|
||||
let value = '';
|
||||
this.advance(); // skip '<'
|
||||
this.advance(); // skip '#'
|
||||
value += '<#';
|
||||
|
||||
while (this.position < this.code.length - 1) {
|
||||
if (this.code[this.position] === '#' && this.code[this.position + 1] === '>') {
|
||||
value += '#>';
|
||||
this.advance();
|
||||
this.advance();
|
||||
break;
|
||||
}
|
||||
value += this.code[this.position];
|
||||
this.advance();
|
||||
}
|
||||
|
||||
return this.createToken(TokenType.MULTILINE_COMMENT, value, startPos, startLine, startColumn);
|
||||
}
|
||||
|
||||
private tokenizeString(startPos: number, startLine: number, startColumn: number): Token {
|
||||
const quote = this.code[this.position];
|
||||
let value = quote;
|
||||
this.advance();
|
||||
|
||||
while (this.position < this.code.length) {
|
||||
const char = this.code[this.position];
|
||||
value += char;
|
||||
|
||||
if (char === quote) {
|
||||
this.advance();
|
||||
break;
|
||||
}
|
||||
|
||||
// 处理转义字符
|
||||
if (char === '`' && quote === '"') {
|
||||
this.advance();
|
||||
if (this.position < this.code.length) {
|
||||
value += this.code[this.position];
|
||||
this.advance();
|
||||
}
|
||||
} else {
|
||||
this.advance();
|
||||
}
|
||||
}
|
||||
|
||||
return this.createToken(TokenType.STRING, value, startPos, startLine, startColumn);
|
||||
}
|
||||
|
||||
private tokenizeHereString(startPos: number, startLine: number, startColumn: number): Token {
|
||||
const quote = this.code[this.position + 1]; // " or '
|
||||
let value = `@${quote}`;
|
||||
this.advance(); // skip '@'
|
||||
this.advance(); // skip quote
|
||||
|
||||
while (this.position < this.code.length - 1) {
|
||||
if (this.code[this.position] === quote && this.code[this.position + 1] === '@') {
|
||||
value += `${quote}@`;
|
||||
this.advance();
|
||||
this.advance();
|
||||
break;
|
||||
}
|
||||
value += this.code[this.position];
|
||||
this.advance();
|
||||
}
|
||||
|
||||
return this.createToken(TokenType.HERE_STRING, value, startPos, startLine, startColumn);
|
||||
}
|
||||
|
||||
private tokenizeVariable(startPos: number, startLine: number, startColumn: number): Token {
|
||||
let value = '$';
|
||||
this.advance(); // skip '$'
|
||||
|
||||
// 处理特殊变量如 $_, $$, $^
|
||||
const specialVars = ['_', '$', '^', '?'];
|
||||
if (specialVars.includes(this.code[this.position])) {
|
||||
value += this.code[this.position];
|
||||
this.advance();
|
||||
return this.createToken(TokenType.VARIABLE, value, startPos, startLine, startColumn);
|
||||
}
|
||||
|
||||
// 处理大括号变量 ${variable name}
|
||||
if (this.code[this.position] === '{') {
|
||||
this.advance(); // skip '{'
|
||||
value += '{';
|
||||
while (this.position < this.code.length && this.code[this.position] !== '}') {
|
||||
value += this.code[this.position];
|
||||
this.advance();
|
||||
}
|
||||
if (this.position < this.code.length) {
|
||||
value += '}';
|
||||
this.advance(); // skip '}'
|
||||
}
|
||||
return this.createToken(TokenType.VARIABLE, value, startPos, startLine, startColumn);
|
||||
}
|
||||
|
||||
// 普通变量名
|
||||
while (this.position < this.code.length && this.isIdentifierChar(this.code[this.position])) {
|
||||
value += this.code[this.position];
|
||||
this.advance();
|
||||
}
|
||||
|
||||
return this.createToken(TokenType.VARIABLE, value, startPos, startLine, startColumn);
|
||||
}
|
||||
|
||||
private tokenizeNumber(startPos: number, startLine: number, startColumn: number): Token {
|
||||
let value = '';
|
||||
let hasDecimal = false;
|
||||
|
||||
while (this.position < this.code.length) {
|
||||
const char = this.code[this.position];
|
||||
|
||||
if (this.isDigit(char)) {
|
||||
value += char;
|
||||
this.advance();
|
||||
} else if (char === '.' && !hasDecimal && this.isDigit(this.peek())) {
|
||||
hasDecimal = true;
|
||||
value += char;
|
||||
this.advance();
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// 检查是否有PowerShell数字单位后缀（KB, MB, GB, TB, PB）
|
||||
const unitPattern = /^(KB|MB|GB|TB|PB)/i;
|
||||
const remainingCode = this.code.substring(this.position);
|
||||
const unitMatch = remainingCode.match(unitPattern);
|
||||
|
||||
if (unitMatch) {
|
||||
value += unitMatch[0]; // 使用 [0] 获取完整匹配
|
||||
// 移动position到单位后面
|
||||
for (let i = 0; i < unitMatch[0].length; i++) {
|
||||
this.advance();
|
||||
}
|
||||
}
|
||||
|
||||
return this.createToken(TokenType.NUMBER, value, startPos, startLine, startColumn);
|
||||
}
|
||||
|
||||
private tokenizeOperator(startPos: number, startLine: number, startColumn: number): Token | null {
|
||||
const char = this.code[this.position];
|
||||
|
||||
// 双字符操作符
|
||||
const twoChar = this.code.substring(this.position, this.position + 2);
|
||||
const doubleOperators = ['==', '!=', '<=', '>=', '++', '--', '+=', '-=', '*=', '/=', '%='];
|
||||
|
||||
if (doubleOperators.includes(twoChar)) {
|
||||
this.advance();
|
||||
this.advance();
|
||||
return this.createToken(TokenType.OPERATOR, twoChar, startPos, startLine, startColumn);
|
||||
}
|
||||
|
||||
// 单字符操作符
|
||||
switch (char) {
|
||||
case '=':
|
||||
this.advance();
|
||||
return this.createToken(TokenType.ASSIGNMENT, char, startPos, startLine, startColumn);
|
||||
case '+':
|
||||
case '*':
|
||||
case '/':
|
||||
case '%':
|
||||
this.advance();
|
||||
return this.createToken(TokenType.ARITHMETIC, char, startPos, startLine, startColumn);
|
||||
case '-':
|
||||
// 不在这里处理'-'，让PowerShell操作符检查优先处理
|
||||
return null;
|
||||
case '(':
|
||||
this.advance();
|
||||
return this.createToken(TokenType.LEFT_PAREN, char, startPos, startLine, startColumn);
|
||||
case ')':
|
||||
this.advance();
|
||||
return this.createToken(TokenType.RIGHT_PAREN, char, startPos, startLine, startColumn);
|
||||
case '{':
|
||||
this.advance();
|
||||
return this.createToken(TokenType.LEFT_BRACE, char, startPos, startLine, startColumn);
|
||||
case '}':
|
||||
this.advance();
|
||||
return this.createToken(TokenType.RIGHT_BRACE, char, startPos, startLine, startColumn);
|
||||
case '[':
|
||||
// 检查是否是PowerShell类型转换 [type]
|
||||
const typePattern = this.peekTypeConversion();
|
||||
if (typePattern) {
|
||||
return this.tokenizeTypeConversion(startPos, startLine, startColumn);
|
||||
}
|
||||
this.advance();
|
||||
return this.createToken(TokenType.LEFT_BRACKET, char, startPos, startLine, startColumn);
|
||||
case ']':
|
||||
this.advance();
|
||||
return this.createToken(TokenType.RIGHT_BRACKET, char, startPos, startLine, startColumn);
|
||||
case ';':
|
||||
this.advance();
|
||||
return this.createToken(TokenType.SEMICOLON, char, startPos, startLine, startColumn);
|
||||
case ',':
|
||||
this.advance();
|
||||
return this.createToken(TokenType.COMMA, char, startPos, startLine, startColumn);
|
||||
case '.':
|
||||
this.advance();
|
||||
return this.createToken(TokenType.DOT, char, startPos, startLine, startColumn);
|
||||
case '|':
|
||||
this.advance();
|
||||
return this.createToken(TokenType.PIPE, char, startPos, startLine, startColumn);
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
private tokenizeIdentifier(startPos: number, startLine: number, startColumn: number): Token {
|
||||
let value = '';
|
||||
|
||||
// 改进的标识符识别，支持PowerShell cmdlet格式（动词-名词）
|
||||
while (this.position < this.code.length) {
|
||||
const char = this.code[this.position];
|
||||
|
||||
if (this.isIdentifierChar(char)) {
|
||||
value += char;
|
||||
this.advance();
|
||||
} else if (char === '-' && value.length > 0 && this.isIdentifierStart(this.peek())) {
|
||||
// 检查是否是cmdlet格式（动词-名词）
|
||||
const nextPart = this.peekIdentifierPart();
|
||||
if (nextPart && !this.isPowerShellOperator('-' + nextPart)) {
|
||||
// 这是cmdlet名字的一部分，继续
|
||||
value += char;
|
||||
this.advance();
|
||||
} else {
|
||||
// 这可能是操作符，停止
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
const lowerValue = value.toLowerCase();
|
||||
|
||||
// 检查是否是关键字
|
||||
if (this.keywords.has(lowerValue)) {
|
||||
return this.createToken(this.getKeywordTokenType(lowerValue), value, startPos, startLine, startColumn);
|
||||
}
|
||||
|
||||
// 检查是否是函数（以动词-名词格式）
|
||||
if (this.isCmdletName(value)) {
|
||||
return this.createToken(TokenType.CMDLET, value, startPos, startLine, startColumn);
|
||||
}
|
||||
|
||||
return this.createToken(TokenType.IDENTIFIER, value, startPos, startLine, startColumn);
|
||||
}
|
||||
|
||||
private tokenizeParameter(startPos: number, startLine: number, startColumn: number): Token {
|
||||
let value = '';
|
||||
|
||||
while (this.position < this.code.length && (this.isIdentifierChar(this.code[this.position]) || this.code[this.position] === '-')) {
|
||||
value += this.code[this.position];
|
||||
this.advance();
|
||||
}
|
||||
|
||||
const lowerValue = value.toLowerCase();
|
||||
|
||||
// 检查是否是比较操作符
|
||||
if (this.comparisonOperators.has(lowerValue)) {
|
||||
return this.createToken(TokenType.COMPARISON, value, startPos, startLine, startColumn);
|
||||
}
|
||||
|
||||
// 检查是否是逻辑操作符
|
||||
if (this.logicalOperators.has(lowerValue)) {
|
||||
return this.createToken(TokenType.LOGICAL, value, startPos, startLine, startColumn);
|
||||
}
|
||||
|
||||
return this.createToken(TokenType.PARAMETER, value, startPos, startLine, startColumn);
|
||||
}
|
||||
|
||||
private getKeywordTokenType(keyword: string): TokenType {
|
||||
switch (keyword) {
|
||||
case 'if': return TokenType.IF;
|
||||
case 'else': return TokenType.ELSE;
|
||||
case 'elseif': return TokenType.ELSEIF;
|
||||
case 'while': return TokenType.WHILE;
|
||||
case 'for': return TokenType.FOR;
|
||||
case 'foreach': return TokenType.FOREACH;
|
||||
case 'switch': return TokenType.SWITCH;
|
||||
case 'try': return TokenType.TRY;
|
||||
case 'catch': return TokenType.CATCH;
|
||||
case 'finally': return TokenType.FINALLY;
|
||||
case 'function': return TokenType.FUNCTION;
|
||||
default: return TokenType.KEYWORD;
|
||||
}
|
||||
}
|
||||
|
||||
private isCmdletName(name: string): boolean {
|
||||
// PowerShell cmdlet通常遵循 Verb-Noun 格式，可能包含多个连字符
|
||||
const verbNounPattern = /^[A-Za-z]+(-[A-Za-z]+)+$/;
|
||||
return verbNounPattern.test(name);
|
||||
}
|
||||
|
||||
private peekPowerShellOperator(): string | null {
|
||||
// 检查是否是PowerShell比较或逻辑操作符
|
||||
const operatorPatterns = [
|
||||
'-eq', '-ne', '-lt', '-le', '-gt', '-ge',
|
||||
'-like', '-notlike', '-match', '-notmatch',
|
||||
'-contains', '-notcontains', '-in', '-notin',
|
||||
'-is', '-isnot', '-as',
|
||||
'-and', '-or', '-not', '-xor',
|
||||
'-band', '-bor', '-bxor', '-bnot'
|
||||
];
|
||||
|
||||
for (const op of operatorPatterns) {
|
||||
if (this.matchesOperator(op)) {
|
||||
return op;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private matchesOperator(operator: string): boolean {
|
||||
if (this.position + operator.length > this.code.length) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const substr = this.code.substring(this.position, this.position + operator.length);
|
||||
if (substr.toLowerCase() !== operator.toLowerCase()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// 确保操作符后面不是字母数字字符（避免匹配部分单词）
|
||||
const nextChar = this.position + operator.length < this.code.length
|
||||
? this.code[this.position + operator.length]
|
||||
: ' ';
|
||||
return !this.isIdentifierChar(nextChar);
|
||||
}
|
||||
|
||||
private tokenizePowerShellOperator(startPos: number, startLine: number, startColumn: number): Token {
|
||||
const operator = this.peekPowerShellOperator();
|
||||
if (!operator) {
|
||||
// 如果不是操作符，作为参数处理
|
||||
return this.tokenizeParameter(startPos, startLine, startColumn);
|
||||
}
|
||||
|
||||
// 消费操作符字符
|
||||
for (let i = 0; i < operator.length; i++) {
|
||||
this.advance();
|
||||
}
|
||||
|
||||
const lowerOp = operator.toLowerCase();
|
||||
|
||||
// 确定操作符类型
|
||||
if (this.comparisonOperators.has(lowerOp)) {
|
||||
return this.createToken(TokenType.COMPARISON, operator, startPos, startLine, startColumn);
|
||||
} else if (this.logicalOperators.has(lowerOp)) {
|
||||
return this.createToken(TokenType.LOGICAL, operator, startPos, startLine, startColumn);
|
||||
} else {
|
||||
return this.createToken(TokenType.OPERATOR, operator, startPos, startLine, startColumn);
|
||||
}
|
||||
}
|
||||
|
||||
private peekIdentifierPart(): string | null {
|
||||
if (this.position + 1 >= this.code.length) {
|
||||
return null;
|
||||
}
|
||||
|
||||
let result = '';
|
||||
let pos = this.position + 1; // 跳过连字符
|
||||
|
||||
while (pos < this.code.length && this.isIdentifierChar(this.code[pos])) {
|
||||
result += this.code[pos];
|
||||
pos++;
|
||||
}
|
||||
|
||||
return result.length > 0 ? result : null;
|
||||
}
|
||||
|
||||
private isPowerShellOperator(text: string): boolean {
|
||||
const lowerText = text.toLowerCase();
|
||||
return this.comparisonOperators.has(lowerText) || this.logicalOperators.has(lowerText);
|
||||
}
|
||||
|
||||
private peekTypeConversion(): string | null {
|
||||
// 检查是否是PowerShell类型转换，如 [int], [string], [datetime] 等
|
||||
if (this.code[this.position] !== '[') {
|
||||
return null;
|
||||
}
|
||||
|
||||
let pos = this.position + 1; // 跳过 '['
|
||||
let typeContent = '';
|
||||
|
||||
// 查找类型名称
|
||||
while (pos < this.code.length && this.code[pos] !== ']') {
|
||||
typeContent += this.code[pos];
|
||||
pos++;
|
||||
}
|
||||
|
||||
if (pos >= this.code.length || this.code[pos] !== ']') {
|
||||
return null; // 没有找到匹配的 ']'
|
||||
}
|
||||
|
||||
// 检查是否是有效的PowerShell类型
|
||||
const validTypes = [
|
||||
'int', 'int32', 'int64', 'string', 'bool', 'boolean', 'char', 'byte',
|
||||
'double', 'float', 'decimal', 'long', 'short', 'datetime', 'timespan',
|
||||
'array', 'hashtable', 'object', 'psobject', 'xml', 'scriptblock',
|
||||
'guid', 'uri', 'version', 'regex', 'mailaddress', 'ipaddress'
|
||||
];
|
||||
|
||||
const lowerType = typeContent.toLowerCase().trim();
|
||||
if (validTypes.includes(lowerType) || lowerType.includes('.')) {
|
||||
return `[${typeContent}]`;
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
private tokenizeTypeConversion(startPos: number, startLine: number, startColumn: number): Token {
|
||||
const typeConversion = this.peekTypeConversion();
|
||||
if (!typeConversion) {
|
||||
// 这不应该发生，但作为安全措施
|
||||
this.advance();
|
||||
return this.createToken(TokenType.LEFT_BRACKET, '[', startPos, startLine, startColumn);
|
||||
}
|
||||
|
||||
// 消费整个类型转换
|
||||
for (let i = 0; i < typeConversion.length; i++) {
|
||||
this.advance();
|
||||
}
|
||||
|
||||
return this.createToken(TokenType.IDENTIFIER, typeConversion, startPos, startLine, startColumn);
|
||||
}
|
||||
|
||||
private isIdentifierStart(char: string): boolean {
|
||||
return /[a-zA-Z_]/.test(char);
|
||||
}
|
||||
|
||||
private isIdentifierChar(char: string): boolean {
|
||||
return /[a-zA-Z0-9_]/.test(char);
|
||||
}
|
||||
|
||||
private isDigit(char: string): boolean {
|
||||
return char >= '0' && char <= '9';
|
||||
}
|
||||
|
||||
private isPrintableChar(char: string): boolean {
|
||||
// 检查是否为可打印字符（非控制字符）
|
||||
const charCode = char.charCodeAt(0);
|
||||
return charCode >= 32 && charCode <= 126;
|
||||
}
|
||||
|
||||
private advance(): void {
|
||||
if (this.position < this.code.length) {
|
||||
if (this.code[this.position] === '\n') {
|
||||
this.line++;
|
||||
this.column = 1;
|
||||
} else {
|
||||
this.column++;
|
||||
}
|
||||
this.position++;
|
||||
}
|
||||
}
|
||||
|
||||
private peek(): string {
|
||||
return this.position + 1 < this.code.length ? this.code[this.position + 1] : '';
|
||||
}
|
||||
|
||||
private skipWhitespace(): void {
|
||||
while (this.position < this.code.length) {
|
||||
const char = this.code[this.position];
|
||||
if (char === ' ' || char === '\t' || char === '\r') {
|
||||
this.advance();
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private createToken(type: TokenType, value: string, startPos: number, line: number, column: number): Token {
|
||||
return {
|
||||
type,
|
||||
value,
|
||||
line,
|
||||
column,
|
||||
startIndex: startPos,
|
||||
endIndex: this.position
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -1,787 +0,0 @@
|
||||
/**
|
||||
* PowerShell 代码解析器和格式化器
|
||||
*/
|
||||
|
||||
// PowerShell AST节点类型
|
||||
interface PowerShellAstNode {
|
||||
type: string;
|
||||
value: string;
|
||||
start?: number;
|
||||
end?: number;
|
||||
parent?: PowerShellAstNode;
|
||||
extent?: any;
|
||||
}
|
||||
|
||||
// 解析器函数类型
|
||||
type PowerShellParserResult = PowerShellAstNode | PowerShellAstNode[];
|
||||
|
||||
// PowerShell格式化选项
|
||||
export interface PowerShellFormatterOptions {
|
||||
/** 缩进大小，默认为4 */
|
||||
indentSize?: number;
|
||||
/** 使用制表符还是空格，默认为空格 */
|
||||
useTabsForIndentation?: boolean;
|
||||
/** 行最大长度，默认为120 */
|
||||
printWidth?: number;
|
||||
/** 是否在操作符周围添加空格，默认为true */
|
||||
spaceAroundOperators?: boolean;
|
||||
/** 是否格式化注释，默认为true */
|
||||
formatComments?: boolean;
|
||||
/** 是否去除多余的空行，默认为true */
|
||||
removeExtraBlankLines?: boolean;
|
||||
/** 是否格式化管道符，默认为true */
|
||||
formatPipelines?: boolean;
|
||||
/** 是否格式化括号内空格，默认为true */
|
||||
formatParentheses?: boolean;
|
||||
/** 是否格式化数组和哈希表，默认为true */
|
||||
formatArraysAndHashtables?: boolean;
|
||||
/** 最大连续空行数，默认为1 */
|
||||
maxConsecutiveEmptyLines?: number;
|
||||
/** 是否在代码块前后添加空行，默认为true */
|
||||
addBlankLinesAroundBlocks?: boolean;
|
||||
/** 是否格式化长行（自动换行），默认为true */
|
||||
formatLongLines?: boolean;
|
||||
/** 是否格式化函数定义，默认为true */
|
||||
formatFunctionDefinitions?: boolean;
|
||||
/** 是否格式化PowerShell特有语法（switch、try-catch、param等），默认为true */
|
||||
formatPowerShellSyntax?: boolean;
|
||||
}
|
||||
|
||||
/**
|
||||
* PowerShell代码格式化器 - 修复版本
|
||||
*/
|
||||
class PowerShellFormatter {
|
||||
private options: Required<PowerShellFormatterOptions>;
|
||||
|
||||
constructor(options: PowerShellFormatterOptions = {}) {
|
||||
this.options = {
|
||||
indentSize: options.indentSize ?? 4,
|
||||
useTabsForIndentation: options.useTabsForIndentation ?? false,
|
||||
printWidth: options.printWidth ?? 120,
|
||||
spaceAroundOperators: options.spaceAroundOperators ?? true,
|
||||
formatComments: options.formatComments ?? true,
|
||||
removeExtraBlankLines: options.removeExtraBlankLines ?? true,
|
||||
formatPipelines: options.formatPipelines ?? true,
|
||||
formatParentheses: options.formatParentheses ?? true,
|
||||
formatArraysAndHashtables: options.formatArraysAndHashtables ?? true,
|
||||
maxConsecutiveEmptyLines: options.maxConsecutiveEmptyLines ?? 1,
|
||||
addBlankLinesAroundBlocks: options.addBlankLinesAroundBlocks ?? true,
|
||||
formatLongLines: options.formatLongLines ?? true,
|
||||
formatFunctionDefinitions: options.formatFunctionDefinitions ?? true,
|
||||
formatPowerShellSyntax: options.formatPowerShellSyntax ?? true,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* 格式化PowerShell代码
|
||||
*/
|
||||
format(code: string): string {
|
||||
if (!code || code.trim().length === 0) {
|
||||
return code;
|
||||
}
|
||||
|
||||
try {
|
||||
const lines = code.split('\n');
|
||||
let formattedLines = this.formatLines(lines);
|
||||
|
||||
// 处理多余空行
|
||||
if (this.options.removeExtraBlankLines) {
|
||||
formattedLines = this.removeExtraBlankLines(formattedLines);
|
||||
}
|
||||
|
||||
// 在代码块前后添加适当的空行
|
||||
if (this.options.addBlankLinesAroundBlocks) {
|
||||
formattedLines = this.addBlankLinesAroundBlocks(formattedLines);
|
||||
}
|
||||
|
||||
return formattedLines.join('\n');
|
||||
} catch (error) {
|
||||
console.warn('PowerShell formatting failed:', error);
|
||||
return code; // 返回原始代码
|
||||
}
|
||||
}
|
||||
|
||||
private formatLines(lines: string[]): string[] {
|
||||
const result: string[] = [];
|
||||
let indentLevel = 0;
|
||||
let inMultiLineComment = false;
|
||||
let inHereString = false;
|
||||
|
||||
for (let i = 0; i < lines.length; i++) {
|
||||
const line = lines[i];
|
||||
const trimmedLine = line.trim();
|
||||
|
||||
// 检查 Here-String (@"..."@ 或 @'...'@)
|
||||
if (trimmedLine.startsWith('@"') || trimmedLine.startsWith("@'")) {
|
||||
if (!trimmedLine.endsWith('"@') && !trimmedLine.endsWith("'@")) {
|
||||
inHereString = true;
|
||||
}
|
||||
}
|
||||
if (inHereString && (trimmedLine.endsWith('"@') || trimmedLine.endsWith("'@"))) {
|
||||
inHereString = false;
|
||||
result.push(line); // Here-String 结束行保持原样
|
||||
continue;
|
||||
}
|
||||
|
||||
// 在 Here-String 内部不处理
|
||||
if (inHereString) {
|
||||
result.push(line);
|
||||
continue;
|
||||
}
|
||||
|
||||
// 检查多行注释
|
||||
if (trimmedLine.includes('<#')) {
|
||||
inMultiLineComment = true;
|
||||
}
|
||||
if (trimmedLine.includes('#>')) {
|
||||
inMultiLineComment = false;
|
||||
result.push(this.getIndent(indentLevel) + trimmedLine);
|
||||
continue;
|
||||
}
|
||||
if (inMultiLineComment) {
|
||||
result.push(this.getIndent(indentLevel) + trimmedLine);
|
||||
continue;
|
||||
}
|
||||
|
||||
// 处理空行
|
||||
if (trimmedLine.length === 0) {
|
||||
result.push('');
|
||||
continue;
|
||||
}
|
||||
|
||||
// 检查是否需要减少缩进级别
|
||||
if (this.shouldDecreaseIndent(trimmedLine)) {
|
||||
indentLevel = Math.max(0, indentLevel - 1);
|
||||
}
|
||||
|
||||
// 格式化当前行
|
||||
const formattedLine = this.formatLine(trimmedLine);
|
||||
result.push(this.getIndent(indentLevel) + formattedLine);
|
||||
|
||||
// 检查是否需要增加缩进级别
|
||||
if (this.shouldIncreaseIndent(trimmedLine)) {
|
||||
indentLevel++;
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
private formatLine(line: string): string {
|
||||
let formatted = line;
|
||||
|
||||
// 处理操作符周围的空格
|
||||
if (this.options.spaceAroundOperators) {
|
||||
formatted = this.addSpacesAroundOperators(formatted);
|
||||
}
|
||||
|
||||
// 格式化注释
|
||||
if (this.options.formatComments) {
|
||||
formatted = this.formatComment(formatted);
|
||||
}
|
||||
|
||||
// 格式化管道符
|
||||
if (this.options.formatPipelines) {
|
||||
formatted = this.formatPipelines(formatted);
|
||||
}
|
||||
|
||||
// 格式化括号
|
||||
if (this.options.formatParentheses) {
|
||||
formatted = this.formatParentheses(formatted);
|
||||
}
|
||||
|
||||
// 格式化数组和哈希表
|
||||
if (this.options.formatArraysAndHashtables) {
|
||||
formatted = this.formatArraysAndHashtables(formatted);
|
||||
}
|
||||
|
||||
// 格式化函数定义
|
||||
if (this.options.formatFunctionDefinitions) {
|
||||
formatted = this.formatFunctionDefinitions(formatted);
|
||||
}
|
||||
|
||||
// 格式化PowerShell特有语法
|
||||
if (this.options.formatPowerShellSyntax) {
|
||||
formatted = this.formatPowerShellSyntax(formatted);
|
||||
}
|
||||
|
||||
// 格式化长行（如果需要）
|
||||
if (this.options.formatLongLines && formatted.length > this.options.printWidth) {
|
||||
formatted = this.formatLongLine(formatted);
|
||||
}
|
||||
|
||||
return formatted;
|
||||
}
|
||||
|
||||
private addSpacesAroundOperators(line: string): string {
|
||||
// 定义PowerShell操作符映射 - 修复版本
|
||||
const operatorMappings = [
|
||||
// 赋值操作符
|
||||
{ pattern: /\s*=\s*/g, replacement: ' = ' },
|
||||
{ pattern: /\s*\+=\s*/g, replacement: ' += ' },
|
||||
{ pattern: /\s*-=\s*/g, replacement: ' -= ' },
|
||||
{ pattern: /\s*\*=\s*/g, replacement: ' *= ' },
|
||||
{ pattern: /\s*\/=\s*/g, replacement: ' /= ' },
|
||||
{ pattern: /\s*%=\s*/g, replacement: ' %= ' },
|
||||
|
||||
// 算术操作符 (避免与参数冲突)
|
||||
{ pattern: /(\w)\s*\+\s*(\w)/g, replacement: '$1 + $2' },
|
||||
{ pattern: /(\w)\s*-\s*(\w)/g, replacement: '$1 - $2' },
|
||||
{ pattern: /(\w)\s*\*\s*(\w)/g, replacement: '$1 * $2' },
|
||||
{ pattern: /(\w)\s*\/\s*(\w)/g, replacement: '$1 / $2' },
|
||||
{ pattern: /(\w)\s*%\s*(\w)/g, replacement: '$1 % $2' },
|
||||
|
||||
// 比较操作符
|
||||
{ pattern: /\s*-eq\s*/g, replacement: ' -eq ' },
|
||||
{ pattern: /\s*-ne\s*/g, replacement: ' -ne ' },
|
||||
{ pattern: /\s*-lt\s*/g, replacement: ' -lt ' },
|
||||
{ pattern: /\s*-le\s*/g, replacement: ' -le ' },
|
||||
{ pattern: /\s*-gt\s*/g, replacement: ' -gt ' },
|
||||
{ pattern: /\s*-ge\s*/g, replacement: ' -ge ' },
|
||||
{ pattern: /\s*-like\s*/g, replacement: ' -like ' },
|
||||
{ pattern: /\s*-notlike\s*/g, replacement: ' -notlike ' },
|
||||
{ pattern: /\s*-match\s*/g, replacement: ' -match ' },
|
||||
{ pattern: /\s*-notmatch\s*/g, replacement: ' -notmatch ' },
|
||||
{ pattern: /\s*-contains\s*/g, replacement: ' -contains ' },
|
||||
{ pattern: /\s*-notcontains\s*/g, replacement: ' -notcontains ' },
|
||||
{ pattern: /\s*-in\s*/g, replacement: ' -in ' },
|
||||
{ pattern: /\s*-notin\s*/g, replacement: ' -notin ' },
|
||||
|
||||
// 逻辑操作符
|
||||
{ pattern: /\s*-and\s*/g, replacement: ' -and ' },
|
||||
{ pattern: /\s*-or\s*/g, replacement: ' -or ' },
|
||||
{ pattern: /\s*-not\s*/g, replacement: ' -not ' },
|
||||
{ pattern: /\s*-xor\s*/g, replacement: ' -xor ' },
|
||||
];
|
||||
|
||||
let result = line;
|
||||
|
||||
// 先保护字符串字面量
|
||||
const strings: string[] = [];
|
||||
let stringIndex = 0;
|
||||
|
||||
// 保护双引号字符串
|
||||
result = result.replace(/"([^"\\]*(\\.[^"\\]*)*)"/g, (match) => {
|
||||
const placeholder = `__STRING_${stringIndex++}__`;
|
||||
strings.push(match);
|
||||
return placeholder;
|
||||
});
|
||||
|
||||
// 保护单引号字符串
|
||||
result = result.replace(/'([^'\\]*(\\.[^'\\]*)*)'/g, (match) => {
|
||||
const placeholder = `__STRING_${stringIndex++}__`;
|
||||
strings.push(match);
|
||||
return placeholder;
|
||||
});
|
||||
|
||||
// 应用操作符格式化
|
||||
operatorMappings.forEach(({ pattern, replacement }) => {
|
||||
result = result.replace(pattern, replacement);
|
||||
});
|
||||
|
||||
// 清理多余的空格，但不要合并所有空格
|
||||
result = result.replace(/\s{2,}/g, ' ');
|
||||
|
||||
// 还原字符串
|
||||
strings.forEach((str, index) => {
|
||||
result = result.replace(`__STRING_${index}__`, str);
|
||||
});
|
||||
|
||||
return result.trim();
|
||||
}
|
||||
|
||||
private removeExtraBlankLines(lines: string[]): string[] {
|
||||
const result: string[] = [];
|
||||
let consecutiveEmptyLines = 0;
|
||||
|
||||
for (let i = 0; i < lines.length; i++) {
|
||||
const line = lines[i];
|
||||
const isEmptyLine = line.trim() === '';
|
||||
|
||||
if (isEmptyLine) {
|
||||
consecutiveEmptyLines++;
|
||||
// 只保留指定数量的连续空行
|
||||
if (consecutiveEmptyLines <= this.options.maxConsecutiveEmptyLines) {
|
||||
result.push(line);
|
||||
}
|
||||
} else {
|
||||
consecutiveEmptyLines = 0;
|
||||
result.push(line);
|
||||
}
|
||||
}
|
||||
|
||||
// 去除文件开头和结尾的空行
|
||||
while (result.length > 0 && result[0].trim() === '') {
|
||||
result.shift();
|
||||
}
|
||||
while (result.length > 0 && result[result.length - 1].trim() === '') {
|
||||
result.pop();
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
private formatPipelines(line: string): string {
|
||||
// 格式化管道符 |
|
||||
let result = line;
|
||||
|
||||
// 保护字符串字面量
|
||||
const strings: string[] = [];
|
||||
let stringIndex = 0;
|
||||
|
||||
result = result.replace(/(["'])(?:(?=(\\?))\2.)*?\1/g, (match) => {
|
||||
const placeholder = `__STRING_${stringIndex++}__`;
|
||||
strings.push(match);
|
||||
return placeholder;
|
||||
});
|
||||
|
||||
// 格式化管道符，确保前后有空格
|
||||
result = result.replace(/\s*\|\s*/g, ' | ');
|
||||
|
||||
// 还原字符串
|
||||
strings.forEach((str, index) => {
|
||||
result = result.replace(`__STRING_${index}__`, str);
|
||||
});
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
private formatParentheses(line: string): string {
|
||||
// 格式化括号内的空格
|
||||
let result = line;
|
||||
|
||||
// 保护字符串字面量
|
||||
const strings: string[] = [];
|
||||
let stringIndex = 0;
|
||||
|
||||
result = result.replace(/(["'])(?:(?=(\\?))\2.)*?\1/g, (match) => {
|
||||
const placeholder = `__STRING_${stringIndex++}__`;
|
||||
strings.push(match);
|
||||
return placeholder;
|
||||
});
|
||||
|
||||
// 格式化括号：( 后和 ) 前不要多余空格，但参数之间要有空格
|
||||
result = result.replace(/\(\s+/g, '(');
|
||||
result = result.replace(/\s+\)/g, ')');
|
||||
|
||||
// 格式化逗号：逗号后加空格
|
||||
result = result.replace(/,\s*/g, ', ');
|
||||
|
||||
// 格式化分号：分号后加空格
|
||||
result = result.replace(/;\s*/g, '; ');
|
||||
|
||||
// 还原字符串
|
||||
strings.forEach((str, index) => {
|
||||
result = result.replace(`__STRING_${index}__`, str);
|
||||
});
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
private formatArraysAndHashtables(line: string): string {
|
||||
// 格式化数组 @() 和哈希表 @{}
|
||||
let result = line;
|
||||
|
||||
// 保护字符串字面量
|
||||
const strings: string[] = [];
|
||||
let stringIndex = 0;
|
||||
|
||||
result = result.replace(/(["'])(?:(?=(\\?))\2.)*?\1/g, (match) => {
|
||||
const placeholder = `__STRING_${stringIndex++}__`;
|
||||
strings.push(match);
|
||||
return placeholder;
|
||||
});
|
||||
|
||||
// 格式化数组符号
|
||||
result = result.replace(/@\(\s*/g, '@(');
|
||||
result = result.replace(/\s*\)/g, ')');
|
||||
|
||||
// 格式化哈希表符号
|
||||
result = result.replace(/@\{\s*/g, '@{');
|
||||
result = result.replace(/\s*\}/g, '}');
|
||||
|
||||
// 格式化方括号
|
||||
result = result.replace(/\[\s+/g, '[');
|
||||
result = result.replace(/\s+\]/g, ']');
|
||||
|
||||
// 还原字符串
|
||||
strings.forEach((str, index) => {
|
||||
result = result.replace(`__STRING_${index}__`, str);
|
||||
});
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
private addBlankLinesAroundBlocks(lines: string[]): string[] {
|
||||
const result: string[] = [];
|
||||
|
||||
for (let i = 0; i < lines.length; i++) {
|
||||
const line = lines[i];
|
||||
const trimmedLine = line.trim();
|
||||
const previousLine = i > 0 ? lines[i - 1].trim() : '';
|
||||
const nextLine = i < lines.length - 1 ? lines[i + 1].trim() : '';
|
||||
|
||||
// 在函数定义前添加空行（除非是文件开头或前面已经有空行）
|
||||
if (this.isFunctionDefinition(trimmedLine)) {
|
||||
if (i > 0 && previousLine !== '' && result.length > 0) {
|
||||
result.push('');
|
||||
}
|
||||
}
|
||||
|
||||
// 在控制结构前添加空行（if, while, for, foreach, switch等）
|
||||
if (this.isControlStructure(trimmedLine)) {
|
||||
if (i > 0 && previousLine !== '' && !this.isElseOrElseIf(trimmedLine) && result.length > 0) {
|
||||
result.push('');
|
||||
}
|
||||
}
|
||||
|
||||
result.push(line);
|
||||
|
||||
// 在函数定义后的右大括号后添加空行
|
||||
if (trimmedLine === '}' && this.isPreviousLineFunctionEnd(lines, i)) {
|
||||
if (i < lines.length - 1 && nextLine !== '') {
|
||||
result.push('');
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
private formatFunctionDefinitions(line: string): string {
|
||||
// 格式化函数定义
|
||||
let result = line;
|
||||
|
||||
// 函数定义的模式匹配
|
||||
const functionPattern = /^(\s*)(function\s+)([^\s\(]+)(\s*)(\(.*?\))(\s*)(\{?)(.*)$/i;
|
||||
const match = result.match(functionPattern);
|
||||
|
||||
if (match) {
|
||||
const [, indent, funcKeyword, funcName, , params, , openBrace, rest] = match;
|
||||
|
||||
// 标准化函数定义格式：function FunctionName(Parameters) {
|
||||
if (openBrace === '{' && rest.trim() === '') {
|
||||
// 单独一行的开括号
|
||||
result = `${indent}${funcKeyword}${funcName}${params} {`;
|
||||
} else if (openBrace === '' && rest.trim().startsWith('{')) {
|
||||
// 括号在下一行，移到同一行
|
||||
result = `${indent}${funcKeyword}${funcName}${params} {`;
|
||||
} else {
|
||||
// 标准格式化
|
||||
result = `${indent}${funcKeyword}${funcName}${params} {`;
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
private formatLongLine(line: string): string {
|
||||
// 处理长行，在适当的位置换行
|
||||
if (line.length <= this.options.printWidth) {
|
||||
return line;
|
||||
}
|
||||
|
||||
const indent = line.match(/^\s*/)?.[0] || '';
|
||||
const content = line.trim();
|
||||
|
||||
// 查找可以换行的位置：管道符、逗号、操作符等
|
||||
const breakPoints = [
|
||||
{ char: ' | ', priority: 1 },
|
||||
{ char: ', ', priority: 2 },
|
||||
{ char: ' -and ', priority: 3 },
|
||||
{ char: ' -or ', priority: 3 },
|
||||
{ char: ' = ', priority: 4 },
|
||||
{ char: ' + ', priority: 5 },
|
||||
{ char: ' -', priority: 6 }
|
||||
];
|
||||
|
||||
// 寻找最佳换行点
|
||||
for (const breakPoint of breakPoints) {
|
||||
const index = content.lastIndexOf(breakPoint.char, this.options.printWidth - indent.length);
|
||||
if (index > 0) {
|
||||
const firstPart = content.substring(0, index + breakPoint.char.length).trim();
|
||||
const secondPart = content.substring(index + breakPoint.char.length).trim();
|
||||
|
||||
if (secondPart.length > 0) {
|
||||
const continuationIndent = indent + ' '; // 额外缩进
|
||||
return `${indent}${firstPart}\n${continuationIndent}${secondPart}`;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return line; // 如果找不到合适的断点，保持原样
|
||||
}
|
||||
|
||||
private isFunctionDefinition(line: string): boolean {
|
||||
return /^\s*function\s+\w+/i.test(line);
|
||||
}
|
||||
|
||||
private isControlStructure(line: string): boolean {
|
||||
const controlKeywords = [
|
||||
/^\s*if\s*\(/i,
|
||||
/^\s*while\s*\(/i,
|
||||
/^\s*for\s*\(/i,
|
||||
/^\s*foreach\s*\(/i,
|
||||
/^\s*switch\s*\(/i,
|
||||
/^\s*try\s*\{?$/i,
|
||||
/^\s*do\s*\{?$/i
|
||||
];
|
||||
|
||||
return controlKeywords.some(pattern => pattern.test(line));
|
||||
}
|
||||
|
||||
private isElseOrElseIf(line: string): boolean {
|
||||
return /^\s*(else|elseif)\b/i.test(line);
|
||||
}
|
||||
|
||||
private isPreviousLineFunctionEnd(lines: string[], currentIndex: number): boolean {
|
||||
// 检查是否是函数结束的大括号
|
||||
let braceCount = 0;
|
||||
let foundFunction = false;
|
||||
|
||||
for (let i = currentIndex - 1; i >= 0; i--) {
|
||||
const line = lines[i].trim();
|
||||
|
||||
if (line.includes('}')) {
|
||||
braceCount += (line.match(/\}/g) || []).length;
|
||||
}
|
||||
if (line.includes('{')) {
|
||||
braceCount -= (line.match(/\{/g) || []).length;
|
||||
}
|
||||
|
||||
if (this.isFunctionDefinition(line)) {
|
||||
foundFunction = true;
|
||||
break;
|
||||
}
|
||||
|
||||
if (braceCount < 0) break; // 遇到不匹配的括号
|
||||
}
|
||||
|
||||
return foundFunction && braceCount === 1;
|
||||
}
|
||||
|
||||
private formatPowerShellSyntax(line: string): string {
|
||||
let result = line;
|
||||
|
||||
// 格式化switch语句
|
||||
result = this.formatSwitchStatement(result);
|
||||
|
||||
// 格式化try-catch-finally语句
|
||||
result = this.formatTryCatchFinally(result);
|
||||
|
||||
// 格式化param块
|
||||
result = this.formatParamBlock(result);
|
||||
|
||||
// 格式化PowerShell操作符和关键字
|
||||
result = this.formatPowerShellKeywords(result);
|
||||
|
||||
// 格式化变量声明
|
||||
result = this.formatVariableDeclarations(result);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
private formatSwitchStatement(line: string): string {
|
||||
let result = line;
|
||||
|
||||
// 格式化switch语句: switch ($variable) {
|
||||
const switchPattern = /^(\s*)(switch)\s*(\(.*?\))\s*(\{?)(.*)$/i;
|
||||
const match = result.match(switchPattern);
|
||||
|
||||
if (match) {
|
||||
const [, indent, switchKeyword, condition, brace, rest] = match;
|
||||
result = `${indent}${switchKeyword} ${condition} {`;
|
||||
}
|
||||
|
||||
// 格式化switch case标签
|
||||
if (/^\s*\{?\s*[^}]*\s*\{\s*$/.test(result) || /^\s*default\s*\{\s*$/.test(result)) {
|
||||
result = result.replace(/\s*\{\s*$/, ' {');
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
private formatTryCatchFinally(line: string): string {
|
||||
let result = line;
|
||||
|
||||
// 格式化try语句
|
||||
if (/^\s*try\s*\{?/i.test(result)) {
|
||||
result = result.replace(/^(\s*)(try)\s*\{?(.*)$/i, '$1$2 {$3');
|
||||
}
|
||||
|
||||
// 格式化catch语句
|
||||
const catchPattern = /^(\s*)(catch)\s*(\[[^\]]*\])?\s*\{?(.*)$/i;
|
||||
const catchMatch = result.match(catchPattern);
|
||||
if (catchMatch) {
|
||||
const [, indent, catchKeyword, exceptionType, rest] = catchMatch;
|
||||
const exception = exceptionType || '';
|
||||
result = `${indent}${catchKeyword}${exception} {${rest}`;
|
||||
}
|
||||
|
||||
// 格式化finally语句
|
||||
if (/^\s*finally\s*\{?/i.test(result)) {
|
||||
result = result.replace(/^(\s*)(finally)\s*\{?(.*)$/i, '$1$2 {$3');
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
private formatParamBlock(line: string): string {
|
||||
let result = line;
|
||||
|
||||
// 格式化param块开始
|
||||
if (/^\s*param\s*\(/i.test(result)) {
|
||||
result = result.replace(/^(\s*)(param)\s*\(/i, '$1$2(');
|
||||
}
|
||||
|
||||
// 格式化参数属性
|
||||
const paramAttributePattern = /^\s*(\[Parameter\([^\]]*\)\])\s*(.*)$/i;
|
||||
const attrMatch = result.match(paramAttributePattern);
|
||||
if (attrMatch) {
|
||||
const [, attribute, rest] = attrMatch;
|
||||
result = ` ${attribute}\n ${rest}`;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
private formatPowerShellKeywords(line: string): string {
|
||||
let result = line;
|
||||
|
||||
// PowerShell关键字列表
|
||||
const keywords = [
|
||||
'begin', 'process', 'end', 'filter', 'class', 'enum',
|
||||
'using', 'namespace', 'return', 'throw', 'break', 'continue',
|
||||
'exit', 'param', 'dynamicparam', 'workflow', 'configuration'
|
||||
];
|
||||
|
||||
// 确保关键字后有适当的空格
|
||||
keywords.forEach(keyword => {
|
||||
const pattern = new RegExp(`\\b(${keyword})\\s*`, 'gi');
|
||||
result = result.replace(pattern, `$1 `);
|
||||
});
|
||||
|
||||
// 特殊处理某些关键字
|
||||
result = result.replace(/\breturn\s+/gi, 'return ');
|
||||
result = result.replace(/\bthrow\s+/gi, 'throw ');
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
private formatVariableDeclarations(line: string): string {
|
||||
let result = line;
|
||||
|
||||
// 格式化变量类型声明: [string]$variable = value
|
||||
const typeVarPattern = /^(\s*)(\[[^\]]+\])\s*(\$\w+)\s*(=.*)?$/;
|
||||
const match = result.match(typeVarPattern);
|
||||
|
||||
if (match) {
|
||||
const [, indent, type, variable, assignment] = match;
|
||||
result = `${indent}${type}${variable}${assignment || ''}`;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
private formatComment(line: string): string {
|
||||
// 单行注释格式化
|
||||
if (line.includes('#') && !line.includes('<#') && !line.includes('#>')) {
|
||||
const commentIndex = line.indexOf('#');
|
||||
const beforeComment = line.substring(0, commentIndex).trim();
|
||||
const comment = line.substring(commentIndex).trim();
|
||||
|
||||
if (beforeComment.length > 0) {
|
||||
// 确保注释前有适当的空格
|
||||
return `${beforeComment} ${comment}`;
|
||||
}
|
||||
return comment;
|
||||
}
|
||||
return line;
|
||||
}
|
||||
|
||||
private shouldIncreaseIndent(line: string): boolean {
|
||||
// PowerShell 块开始模式
|
||||
const blockStartPatterns = [
|
||||
/\{\s*$/, // 单独的大括号
|
||||
/\bif\s*\([^)]*\)\s*\{\s*$/i,
|
||||
/\belseif\s*\([^)]*\)\s*\{\s*$/i,
|
||||
/\belse\s*\{\s*$/i,
|
||||
/\bwhile\s*\([^)]*\)\s*\{\s*$/i,
|
||||
/\bfor\s*\([^)]*\)\s*\{\s*$/i,
|
||||
/\bforeach\s*\([^)]*\)\s*\{\s*$/i,
|
||||
/\bdo\s*\{\s*$/i,
|
||||
/\btry\s*\{\s*$/i,
|
||||
/\bcatch\s*(\[[^\]]*\])?\s*\{\s*$/i,
|
||||
/\bfinally\s*\{\s*$/i,
|
||||
/\bfunction\s+\w+.*\{\s*$/i,
|
||||
];
|
||||
|
||||
return blockStartPatterns.some(pattern => pattern.test(line));
|
||||
}
|
||||
|
||||
private shouldDecreaseIndent(line: string): boolean {
|
||||
// PowerShell 块结束模式
|
||||
const blockEndPatterns = [
|
||||
/^\s*\}\s*$/, // 单独的右大括号
|
||||
/^\s*\}\s*else/i,
|
||||
/^\s*\}\s*elseif/i,
|
||||
/^\s*\}\s*catch/i,
|
||||
/^\s*\}\s*finally/i,
|
||||
];
|
||||
|
||||
return blockEndPatterns.some(pattern => pattern.test(line));
|
||||
}
|
||||
|
||||
private getIndent(level: number): string {
|
||||
if (level <= 0) return '';
|
||||
const indentChar = this.options.useTabsForIndentation ? '\t' : ' ';
|
||||
const indentSize = this.options.useTabsForIndentation ? 1 : this.options.indentSize;
|
||||
return indentChar.repeat(level * indentSize);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 便捷的格式化函数
|
||||
*/
|
||||
export function formatPowerShellCode(
|
||||
code: string,
|
||||
options?: PowerShellFormatterOptions
|
||||
): string {
|
||||
const formatter = new PowerShellFormatter(options);
|
||||
return formatter.format(code);
|
||||
}
|
||||
|
||||
/**
|
||||
* PowerShell代码解析器
|
||||
*/
|
||||
const parser = (scriptContent: string): Promise<PowerShellParserResult> => {
|
||||
return new Promise((resolve) => {
|
||||
try {
|
||||
const astNode: PowerShellAstNode = {
|
||||
type: 'ScriptBlockAst',
|
||||
value: scriptContent,
|
||||
start: 0,
|
||||
end: scriptContent.length
|
||||
};
|
||||
|
||||
resolve(astNode);
|
||||
} catch (error) {
|
||||
console.warn('PowerShell parsing fallback used:', error);
|
||||
resolve({
|
||||
type: 'ScriptBlockAst',
|
||||
value: scriptContent,
|
||||
start: 0,
|
||||
end: scriptContent.length
|
||||
});
|
||||
}
|
||||
});
|
||||
};
|
||||
|
||||
/**
|
||||
* Prettier解析函数
|
||||
*/
|
||||
const parse = async (scriptContent: string, parsers?: any, opts?: any): Promise<PowerShellParserResult> => {
|
||||
return await parser(scriptContent);
|
||||
};
|
||||
|
||||
export default parse;
|
||||
821
frontend/src/common/prettier/plugins/powershell/parser.ts
Normal file
821
frontend/src/common/prettier/plugins/powershell/parser.ts
Normal file
@@ -0,0 +1,821 @@
|
||||
/**
|
||||
* PowerShell 语法分析器 (Parser)
|
||||
* 将词法分析器产生的tokens转换为抽象语法树(AST)
|
||||
*/
|
||||
|
||||
import { Token, TokenType } from './lexer';
|
||||
import {
|
||||
ASTNode,
|
||||
ScriptBlockAst,
|
||||
StatementAst,
|
||||
ExpressionAst,
|
||||
PipelineAst,
|
||||
CommandAst,
|
||||
AssignmentAst,
|
||||
VariableAst,
|
||||
LiteralAst,
|
||||
BinaryExpressionAst,
|
||||
IfStatementAst,
|
||||
FunctionDefinitionAst,
|
||||
ParameterAst,
|
||||
ASTNodeFactory,
|
||||
CommentAst,
|
||||
PipelineElementAst,
|
||||
ElseIfClauseAst,
|
||||
UnaryExpressionAst,
|
||||
ParenthesizedExpressionAst
|
||||
} from './ast';
|
||||
|
||||
export class PowerShellParser {
|
||||
private tokens: Token[];
|
||||
private currentIndex: number = 0;
|
||||
private comments: CommentAst[] = [];
|
||||
|
||||
private originalCode: string;
|
||||
|
||||
constructor(tokens: Token[], originalCode: string = '') {
|
||||
this.tokens = tokens;
|
||||
this.currentIndex = 0;
|
||||
this.originalCode = originalCode;
|
||||
}
|
||||
|
||||
/**
|
||||
* 解析tokens生成AST
|
||||
*/
|
||||
public parse(): ScriptBlockAst {
|
||||
const statements: StatementAst[] = [];
|
||||
|
||||
while (!this.isAtEnd()) {
|
||||
// 跳过空白和换行
|
||||
this.skipWhitespaceAndNewlines();
|
||||
|
||||
if (this.isAtEnd()) {
|
||||
break;
|
||||
}
|
||||
|
||||
// 处理注释
|
||||
if (this.match(TokenType.COMMENT, TokenType.MULTILINE_COMMENT)) {
|
||||
const comment = this.parseComment();
|
||||
this.comments.push(comment);
|
||||
continue;
|
||||
}
|
||||
|
||||
const statement = this.parseStatement();
|
||||
if (statement) {
|
||||
statements.push(statement);
|
||||
}
|
||||
}
|
||||
|
||||
const start = this.tokens.length > 0 ? this.tokens[0].startIndex : 0;
|
||||
const end = this.tokens.length > 0 ? this.tokens[this.tokens.length - 1].endIndex : 0;
|
||||
const line = this.tokens.length > 0 ? this.tokens[0].line : 1;
|
||||
const column = this.tokens.length > 0 ? this.tokens[0].column : 1;
|
||||
|
||||
return ASTNodeFactory.createScriptBlock(statements, start, end, line, column);
|
||||
}
|
||||
|
||||
public getComments(): CommentAst[] {
|
||||
return this.comments;
|
||||
}
|
||||
|
||||
private parseStatement(): StatementAst | null {
|
||||
// 函数定义
|
||||
if (this.check(TokenType.FUNCTION)) {
|
||||
return this.parseFunctionDefinition();
|
||||
}
|
||||
|
||||
// 控制流语句
|
||||
if (this.check(TokenType.IF)) {
|
||||
return this.parseIfStatement();
|
||||
}
|
||||
|
||||
// 赋值或管道
|
||||
return this.parsePipeline();
|
||||
}
|
||||
|
||||
private parseFunctionDefinition(): FunctionDefinitionAst {
|
||||
const start = this.current().startIndex;
|
||||
const line = this.current().line;
|
||||
const column = this.current().column;
|
||||
|
||||
this.consume(TokenType.FUNCTION, "Expected 'function'");
|
||||
|
||||
// 函数名可能是CMDLET类型（如Get-Something）或IDENTIFIER
|
||||
let nameToken: Token;
|
||||
if (this.check(TokenType.CMDLET)) {
|
||||
nameToken = this.consume(TokenType.CMDLET, "Expected function name");
|
||||
} else {
|
||||
nameToken = this.consume(TokenType.IDENTIFIER, "Expected function name");
|
||||
}
|
||||
const name = nameToken.value;
|
||||
|
||||
// 解析参数
|
||||
const parameters: ParameterAst[] = [];
|
||||
if (this.match(TokenType.LEFT_PAREN)) {
|
||||
if (!this.check(TokenType.RIGHT_PAREN)) {
|
||||
do {
|
||||
const param = this.parseParameter();
|
||||
if (param) {
|
||||
parameters.push(param);
|
||||
}
|
||||
} while (this.match(TokenType.COMMA));
|
||||
}
|
||||
this.consume(TokenType.RIGHT_PAREN, "Expected ')' after parameters");
|
||||
}
|
||||
|
||||
// 解析函数体
|
||||
const body = this.parseScriptBlock();
|
||||
|
||||
const end = this.previous().endIndex;
|
||||
|
||||
return ASTNodeFactory.createFunctionDefinition(name, parameters, body, start, end, line, column);
|
||||
}
|
||||
|
||||
private parseIfStatement(): IfStatementAst {
|
||||
const start = this.current().startIndex;
|
||||
const line = this.current().line;
|
||||
const column = this.current().column;
|
||||
|
||||
this.consume(TokenType.IF, "Expected 'if'");
|
||||
|
||||
// PowerShell的if语句可能有括号，也可能没有
|
||||
const hasParens = this.check(TokenType.LEFT_PAREN);
|
||||
if (hasParens) {
|
||||
this.consume(TokenType.LEFT_PAREN, "Expected '(' after 'if'");
|
||||
}
|
||||
|
||||
const condition = this.parseExpression();
|
||||
|
||||
if (hasParens) {
|
||||
this.consume(TokenType.RIGHT_PAREN, "Expected ')' after if condition");
|
||||
}
|
||||
|
||||
const ifBody = this.parseScriptBlock();
|
||||
|
||||
const elseIfClauses: ElseIfClauseAst[] = [];
|
||||
let elseBody: ScriptBlockAst | undefined;
|
||||
|
||||
// 处理 elseif 子句
|
||||
while (this.match(TokenType.ELSEIF)) {
|
||||
const elseIfStart = this.previous().startIndex;
|
||||
const elseIfLine = this.previous().line;
|
||||
const elseIfColumn = this.previous().column;
|
||||
|
||||
this.consume(TokenType.LEFT_PAREN, "Expected '(' after 'elseif'");
|
||||
const elseIfCondition = this.parseExpression();
|
||||
this.consume(TokenType.RIGHT_PAREN, "Expected ')' after elseif condition");
|
||||
const elseIfBody = this.parseScriptBlock();
|
||||
|
||||
const elseIfEnd = this.previous().endIndex;
|
||||
|
||||
elseIfClauses.push({
|
||||
type: 'ElseIfClause',
|
||||
condition: elseIfCondition,
|
||||
body: elseIfBody,
|
||||
start: elseIfStart,
|
||||
end: elseIfEnd,
|
||||
line: elseIfLine,
|
||||
column: elseIfColumn
|
||||
});
|
||||
}
|
||||
|
||||
// 处理 else 子句
|
||||
if (this.match(TokenType.ELSE)) {
|
||||
elseBody = this.parseScriptBlock();
|
||||
}
|
||||
|
||||
const end = this.previous().endIndex;
|
||||
|
||||
return ASTNodeFactory.createIfStatement(condition, ifBody, elseIfClauses, elseBody, start, end, line, column);
|
||||
}
|
||||
|
||||
private parsePipeline(): PipelineAst {
|
||||
const start = this.current().startIndex;
|
||||
const line = this.current().line;
|
||||
const column = this.current().column;
|
||||
|
||||
const elements: PipelineElementAst[] = [];
|
||||
|
||||
// 解析第一个元素
|
||||
const firstElement = this.parsePipelineElement();
|
||||
elements.push(firstElement);
|
||||
|
||||
// 解析管道链
|
||||
while (this.match(TokenType.PIPE)) {
|
||||
const element = this.parsePipelineElement();
|
||||
elements.push(element);
|
||||
}
|
||||
|
||||
const end = this.previous().endIndex;
|
||||
|
||||
return ASTNodeFactory.createPipeline(elements, start, end, line, column);
|
||||
}
|
||||
|
||||
private parsePipelineElement(): PipelineElementAst {
|
||||
const start = this.current().startIndex;
|
||||
const line = this.current().line;
|
||||
const column = this.current().column;
|
||||
|
||||
const expression = this.parseAssignment();
|
||||
const end = this.previous().endIndex;
|
||||
|
||||
return {
|
||||
type: 'PipelineElement',
|
||||
expression,
|
||||
start,
|
||||
end,
|
||||
line,
|
||||
column
|
||||
};
|
||||
}
|
||||
|
||||
private parseAssignment(): ExpressionAst {
|
||||
const expr = this.parseLogicalOr();
|
||||
|
||||
if (this.match(TokenType.ASSIGNMENT)) {
|
||||
const operator = this.previous().value;
|
||||
const right = this.parseAssignment();
|
||||
|
||||
return ASTNodeFactory.createAssignment(
|
||||
expr,
|
||||
operator,
|
||||
right,
|
||||
expr.start,
|
||||
right.end,
|
||||
expr.line,
|
||||
expr.column
|
||||
);
|
||||
}
|
||||
|
||||
return expr;
|
||||
}
|
||||
|
||||
private parseLogicalOr(): ExpressionAst {
|
||||
let expr = this.parseLogicalAnd();
|
||||
|
||||
while (this.match(TokenType.LOGICAL)) {
|
||||
const operator = this.previous().value.toLowerCase();
|
||||
if (operator === '-or' || operator === '-xor') {
|
||||
const right = this.parseLogicalAnd();
|
||||
expr = ASTNodeFactory.createBinaryExpression(
|
||||
expr,
|
||||
this.previous().value, // 使用原始大小写
|
||||
right,
|
||||
expr.start,
|
||||
right.end,
|
||||
expr.line,
|
||||
expr.column
|
||||
);
|
||||
} else {
|
||||
// 如果不是预期的操作符，回退
|
||||
this.currentIndex--;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return expr;
|
||||
}
|
||||
|
||||
private parseLogicalAnd(): ExpressionAst {
|
||||
let expr = this.parseComparison();
|
||||
|
||||
while (this.match(TokenType.LOGICAL)) {
|
||||
const operator = this.previous().value.toLowerCase();
|
||||
if (operator === '-and') {
|
||||
const right = this.parseComparison();
|
||||
expr = ASTNodeFactory.createBinaryExpression(
|
||||
expr,
|
||||
this.previous().value, // 使用原始大小写
|
||||
right,
|
||||
expr.start,
|
||||
right.end,
|
||||
expr.line,
|
||||
expr.column
|
||||
);
|
||||
} else {
|
||||
// 如果不是预期的操作符，回退
|
||||
this.currentIndex--;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return expr;
|
||||
}
|
||||
|
||||
private parseComparison(): ExpressionAst {
|
||||
let expr = this.parseArithmetic();
|
||||
|
||||
while (this.match(TokenType.COMPARISON)) {
|
||||
const operator = this.previous().value;
|
||||
const right = this.parseArithmetic();
|
||||
expr = ASTNodeFactory.createBinaryExpression(
|
||||
expr,
|
||||
operator,
|
||||
right,
|
||||
expr.start,
|
||||
right.end,
|
||||
expr.line,
|
||||
expr.column
|
||||
);
|
||||
}
|
||||
|
||||
return expr;
|
||||
}
|
||||
|
||||
private parseArithmetic(): ExpressionAst {
|
||||
let expr = this.parseMultiplicative();
|
||||
|
||||
while (this.match(TokenType.ARITHMETIC)) {
|
||||
const token = this.previous();
|
||||
if (token.value === '+' || token.value === '-') {
|
||||
const operator = token.value;
|
||||
const right = this.parseMultiplicative();
|
||||
expr = ASTNodeFactory.createBinaryExpression(
|
||||
expr,
|
||||
operator,
|
||||
right,
|
||||
expr.start,
|
||||
right.end,
|
||||
expr.line,
|
||||
expr.column
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
return expr;
|
||||
}
|
||||
|
||||
private parseMultiplicative(): ExpressionAst {
|
||||
let expr = this.parseUnary();
|
||||
|
||||
while (this.match(TokenType.ARITHMETIC)) {
|
||||
const token = this.previous();
|
||||
if (token.value === '*' || token.value === '/' || token.value === '%') {
|
||||
const operator = token.value;
|
||||
const right = this.parseUnary();
|
||||
expr = ASTNodeFactory.createBinaryExpression(
|
||||
expr,
|
||||
operator,
|
||||
right,
|
||||
expr.start,
|
||||
right.end,
|
||||
expr.line,
|
||||
expr.column
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
return expr;
|
||||
}
|
||||
|
||||
private parseUnary(): ExpressionAst {
|
||||
if (this.match(TokenType.LOGICAL)) {
|
||||
const token = this.previous();
|
||||
const operator = token.value.toLowerCase();
|
||||
if (operator === '-not') {
|
||||
const operand = this.parseUnary();
|
||||
return {
|
||||
type: 'UnaryExpression',
|
||||
operator: token.value, // 使用原始大小写
|
||||
operand,
|
||||
start: token.startIndex,
|
||||
end: operand.end,
|
||||
line: token.line,
|
||||
column: token.column
|
||||
} as UnaryExpressionAst;
|
||||
} else {
|
||||
// 如果不是-not，回退token
|
||||
this.currentIndex--;
|
||||
}
|
||||
}
|
||||
|
||||
// 处理算术一元操作符（+, -）
|
||||
if (this.match(TokenType.ARITHMETIC)) {
|
||||
const token = this.previous();
|
||||
if (token.value === '+' || token.value === '-') {
|
||||
const operand = this.parseUnary();
|
||||
return {
|
||||
type: 'UnaryExpression',
|
||||
operator: token.value,
|
||||
operand,
|
||||
start: token.startIndex,
|
||||
end: operand.end,
|
||||
line: token.line,
|
||||
column: token.column
|
||||
} as UnaryExpressionAst;
|
||||
} else {
|
||||
// 如果不是一元操作符，回退
|
||||
this.currentIndex--;
|
||||
}
|
||||
}
|
||||
|
||||
return this.parsePrimary();
|
||||
}
|
||||
|
||||
private parsePrimary(): ExpressionAst {
|
||||
// 变量
|
||||
if (this.match(TokenType.VARIABLE)) {
|
||||
const token = this.previous();
|
||||
return ASTNodeFactory.createVariable(
|
||||
token.value,
|
||||
token.startIndex,
|
||||
token.endIndex,
|
||||
token.line,
|
||||
token.column
|
||||
);
|
||||
}
|
||||
|
||||
// 字符串字面量
|
||||
if (this.match(TokenType.STRING, TokenType.HERE_STRING)) {
|
||||
const token = this.previous();
|
||||
return ASTNodeFactory.createLiteral(
|
||||
token.value,
|
||||
'String',
|
||||
token.startIndex,
|
||||
token.endIndex,
|
||||
token.line,
|
||||
token.column
|
||||
);
|
||||
}
|
||||
|
||||
// 数字字面量
|
||||
if (this.match(TokenType.NUMBER)) {
|
||||
const token = this.previous();
|
||||
const value = parseFloat(token.value);
|
||||
return ASTNodeFactory.createLiteral(
|
||||
value,
|
||||
'Number',
|
||||
token.startIndex,
|
||||
token.endIndex,
|
||||
token.line,
|
||||
token.column
|
||||
);
|
||||
}
|
||||
|
||||
// 命令调用 - 扩展支持更多token类型
|
||||
if (this.match(TokenType.CMDLET, TokenType.IDENTIFIER)) {
|
||||
return this.parseCommand();
|
||||
}
|
||||
|
||||
// 处理看起来像cmdlet但被错误标记的标识符
|
||||
if (this.check(TokenType.IDENTIFIER) && this.current().value.includes('-')) {
|
||||
this.advance();
|
||||
return this.parseCommand();
|
||||
}
|
||||
|
||||
// 哈希表 @{...}
|
||||
if (this.check(TokenType.LEFT_BRACE) && this.current().value === '@{') {
|
||||
return this.parseHashtable();
|
||||
}
|
||||
|
||||
// 脚本块表达式 {...} - 已在parseHashtableValue中处理
|
||||
// 这里不需要处理，因为独立的脚本块很少见
|
||||
|
||||
// 括号表达式
|
||||
if (this.match(TokenType.LEFT_PAREN)) {
|
||||
const expr = this.parseExpression();
|
||||
this.consume(TokenType.RIGHT_PAREN, "Expected ')' after expression");
|
||||
return {
|
||||
type: 'ParenthesizedExpression',
|
||||
expression: expr,
|
||||
start: this.previous().startIndex,
|
||||
end: this.previous().endIndex,
|
||||
line: this.previous().line,
|
||||
column: this.previous().column
|
||||
} as ParenthesizedExpressionAst;
|
||||
}
|
||||
|
||||
// 对于不认识的token，作为普通标识符处理而不是抛出异常
|
||||
const token = this.advance();
|
||||
return ASTNodeFactory.createLiteral(
|
||||
token.value,
|
||||
'String', // 将未识别的token作为字符串处理
|
||||
token.startIndex,
|
||||
token.endIndex,
|
||||
token.line,
|
||||
token.column
|
||||
);
|
||||
}
|
||||
|
||||
private parseCommand(): CommandAst {
|
||||
const start = this.previous().startIndex;
|
||||
const line = this.previous().line;
|
||||
const column = this.previous().column;
|
||||
const commandName = this.previous().value;
|
||||
|
||||
const parameters: ParameterAst[] = [];
|
||||
const args: ExpressionAst[] = [];
|
||||
|
||||
// 解析参数和参数值
|
||||
while (!this.isAtEnd() &&
|
||||
!this.check(TokenType.PIPE) &&
|
||||
!this.check(TokenType.NEWLINE) &&
|
||||
!this.check(TokenType.SEMICOLON) &&
|
||||
!this.check(TokenType.RIGHT_PAREN) &&
|
||||
!this.check(TokenType.RIGHT_BRACE)) {
|
||||
|
||||
if (this.match(TokenType.PARAMETER)) {
|
||||
const paramToken = this.previous();
|
||||
const param: ParameterAst = {
|
||||
type: 'Parameter',
|
||||
name: paramToken.value,
|
||||
start: paramToken.startIndex,
|
||||
end: paramToken.endIndex,
|
||||
line: paramToken.line,
|
||||
column: paramToken.column
|
||||
};
|
||||
|
||||
// 检查参数是否有值
|
||||
if (!this.check(TokenType.PARAMETER) &&
|
||||
!this.check(TokenType.PIPE) &&
|
||||
!this.check(TokenType.NEWLINE) &&
|
||||
!this.check(TokenType.SEMICOLON)) {
|
||||
param.value = this.parsePrimary();
|
||||
}
|
||||
|
||||
parameters.push(param);
|
||||
} else {
|
||||
// 位置参数
|
||||
const arg = this.parsePrimary();
|
||||
args.push(arg);
|
||||
}
|
||||
}
|
||||
|
||||
const end = this.previous().endIndex;
|
||||
|
||||
return ASTNodeFactory.createCommand(commandName, parameters, args, start, end, line, column);
|
||||
}
|
||||
|
||||
private parseParameter(): ParameterAst | null {
|
||||
if (this.match(TokenType.PARAMETER)) {
|
||||
const token = this.previous();
|
||||
const param: ParameterAst = {
|
||||
type: 'Parameter',
|
||||
name: token.value,
|
||||
start: token.startIndex,
|
||||
end: token.endIndex,
|
||||
line: token.line,
|
||||
column: token.column
|
||||
};
|
||||
|
||||
// 检查是否有参数值
|
||||
if (this.match(TokenType.ASSIGNMENT)) {
|
||||
param.value = this.parseExpression();
|
||||
}
|
||||
|
||||
return param;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private parseScriptBlock(): ScriptBlockAst {
|
||||
const start = this.current().startIndex;
|
||||
const line = this.current().line;
|
||||
const column = this.current().column;
|
||||
|
||||
this.consume(TokenType.LEFT_BRACE, "Expected '{'");
|
||||
|
||||
const statements: StatementAst[] = [];
|
||||
|
||||
while (!this.check(TokenType.RIGHT_BRACE) && !this.isAtEnd()) {
|
||||
this.skipWhitespaceAndNewlines();
|
||||
|
||||
if (this.check(TokenType.RIGHT_BRACE)) {
|
||||
break;
|
||||
}
|
||||
|
||||
const statement = this.parseStatement();
|
||||
if (statement) {
|
||||
statements.push(statement);
|
||||
}
|
||||
}
|
||||
|
||||
this.consume(TokenType.RIGHT_BRACE, "Expected '}'");
|
||||
|
||||
const end = this.previous().endIndex;
|
||||
|
||||
return ASTNodeFactory.createScriptBlock(statements, start, end, line, column);
|
||||
}
|
||||
|
||||
private parseExpression(): ExpressionAst {
|
||||
return this.parseAssignment();
|
||||
}
|
||||
|
||||
private parseComment(): CommentAst {
|
||||
const token = this.previous();
|
||||
const isMultiline = token.type === TokenType.MULTILINE_COMMENT;
|
||||
|
||||
return ASTNodeFactory.createComment(
|
||||
token.value,
|
||||
isMultiline,
|
||||
token.startIndex,
|
||||
token.endIndex,
|
||||
token.line,
|
||||
token.column
|
||||
);
|
||||
}
|
||||
|
||||
// 辅助方法
|
||||
private match(...types: TokenType[]): boolean {
|
||||
for (const type of types) {
|
||||
if (this.check(type)) {
|
||||
this.advance();
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
private check(type: TokenType): boolean {
|
||||
if (this.isAtEnd()) return false;
|
||||
return this.current().type === type;
|
||||
}
|
||||
|
||||
private advance(): Token {
|
||||
if (!this.isAtEnd()) this.currentIndex++;
|
||||
return this.previous();
|
||||
}
|
||||
|
||||
private isAtEnd(): boolean {
|
||||
return this.currentIndex >= this.tokens.length || this.current().type === TokenType.EOF;
|
||||
}
|
||||
|
||||
private current(): Token {
|
||||
if (this.currentIndex >= this.tokens.length) {
|
||||
return this.tokens[this.tokens.length - 1];
|
||||
}
|
||||
return this.tokens[this.currentIndex];
|
||||
}
|
||||
|
||||
private previous(): Token {
|
||||
return this.tokens[this.currentIndex - 1];
|
||||
}
|
||||
|
||||
private consume(type: TokenType, message: string): Token {
|
||||
if (this.check(type)) return this.advance();
|
||||
|
||||
const current = this.current();
|
||||
throw new Error(`${message}. Got ${current.type}(${current.value}) at line ${current.line}, column ${current.column}`);
|
||||
}
|
||||
|
||||
|
||||
private parseHashtable(): ExpressionAst {
|
||||
const start = this.current().startIndex;
|
||||
const line = this.current().line;
|
||||
const column = this.current().column;
|
||||
|
||||
// 消费 @{
|
||||
this.advance();
|
||||
|
||||
const entries: any[] = [];
|
||||
|
||||
// 解析哈希表内容
|
||||
if (!this.check(TokenType.RIGHT_BRACE)) {
|
||||
do {
|
||||
// 解析键 - 只接受简单的标识符或字符串
|
||||
const key = this.parseHashtableKey();
|
||||
|
||||
// 消费 =
|
||||
this.consume(TokenType.ASSIGNMENT, "Expected '=' after hashtable key");
|
||||
|
||||
// 解析值
|
||||
const value = this.parseHashtableValue();
|
||||
|
||||
entries.push({
|
||||
type: 'HashtableEntry',
|
||||
key,
|
||||
value,
|
||||
start: key.start,
|
||||
end: value.end,
|
||||
line: key.line,
|
||||
column: key.column
|
||||
});
|
||||
|
||||
} while (this.match(TokenType.SEMICOLON));
|
||||
}
|
||||
|
||||
this.consume(TokenType.RIGHT_BRACE, "Expected '}' after hashtable entries");
|
||||
const end = this.previous().endIndex;
|
||||
|
||||
return {
|
||||
type: 'Hashtable',
|
||||
entries,
|
||||
start,
|
||||
end,
|
||||
line,
|
||||
column
|
||||
} as any;
|
||||
}
|
||||
|
||||
private parseHashtableKey(): ExpressionAst {
|
||||
// 哈希表键只能是简单的标识符或字符串
|
||||
if (this.match(TokenType.STRING, TokenType.HERE_STRING)) {
|
||||
const token = this.previous();
|
||||
return ASTNodeFactory.createLiteral(
|
||||
token.value,
|
||||
'String',
|
||||
token.startIndex,
|
||||
token.endIndex,
|
||||
token.line,
|
||||
token.column
|
||||
);
|
||||
}
|
||||
|
||||
// 接受各种可能的标识符类型作为哈希表键
|
||||
if (this.match(TokenType.IDENTIFIER, TokenType.CMDLET, TokenType.KEYWORD)) {
|
||||
const token = this.previous();
|
||||
return ASTNodeFactory.createLiteral(
|
||||
token.value,
|
||||
'String',
|
||||
token.startIndex,
|
||||
token.endIndex,
|
||||
token.line,
|
||||
token.column
|
||||
);
|
||||
}
|
||||
|
||||
// 对于任何其他类型的token，尝试作为字面量处理
|
||||
const currentToken = this.current();
|
||||
this.advance();
|
||||
return ASTNodeFactory.createLiteral(
|
||||
currentToken.value,
|
||||
'String',
|
||||
currentToken.startIndex,
|
||||
currentToken.endIndex,
|
||||
currentToken.line,
|
||||
currentToken.column
|
||||
);
|
||||
}
|
||||
|
||||
private parseHashtableValue(): ExpressionAst {
|
||||
// 哈希表值可以是任何表达式
|
||||
if (this.check(TokenType.LEFT_BRACE)) {
|
||||
// 这是一个脚本块 {expression} - 完全绕过复杂解析
|
||||
const start = this.current().startIndex;
|
||||
const line = this.current().line;
|
||||
const column = this.current().column;
|
||||
|
||||
// 直接从原始代码中提取脚本块内容
|
||||
const startPos = this.current().startIndex;
|
||||
this.advance(); // 消费 {
|
||||
|
||||
let braceLevel = 1;
|
||||
let endPos = this.current().startIndex;
|
||||
|
||||
// 找到匹配的右大括号位置
|
||||
while (!this.isAtEnd() && braceLevel > 0) {
|
||||
const token = this.current();
|
||||
if (token.type === TokenType.LEFT_BRACE) {
|
||||
braceLevel++;
|
||||
} else if (token.type === TokenType.RIGHT_BRACE) {
|
||||
braceLevel--;
|
||||
if (braceLevel === 0) {
|
||||
endPos = token.startIndex;
|
||||
break;
|
||||
}
|
||||
}
|
||||
this.advance();
|
||||
}
|
||||
|
||||
this.consume(TokenType.RIGHT_BRACE, "Expected '}' after script block");
|
||||
const end = this.previous().endIndex;
|
||||
|
||||
// 从原始代码中提取内容（从 { 后到 } 前）
|
||||
const rawContent = this.getOriginalCodeSlice(startPos + 1, endPos);
|
||||
|
||||
return {
|
||||
type: 'ScriptBlockExpression',
|
||||
rawContent: rawContent.trim(), // 去掉首尾空白
|
||||
start,
|
||||
end,
|
||||
line,
|
||||
column
|
||||
} as any;
|
||||
}
|
||||
|
||||
// 对于其他值，使用简单的解析
|
||||
return this.parsePrimary();
|
||||
}
|
||||
|
||||
private getOriginalCodeSlice(start: number, end: number): string {
|
||||
// 直接从原始代码中提取片段
|
||||
if (this.originalCode) {
|
||||
return this.originalCode.substring(start, end);
|
||||
}
|
||||
|
||||
// 回退到基于token重建（如果没有原始代码）
|
||||
let result = '';
|
||||
for (const token of this.tokens) {
|
||||
if (token.startIndex >= start && token.endIndex <= end) {
|
||||
result += token.value;
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
private skipWhitespaceAndNewlines(): void {
|
||||
while (this.match(TokenType.WHITESPACE, TokenType.NEWLINE)) {
|
||||
// 继续跳过
|
||||
}
|
||||
}
|
||||
}
|
||||
72
frontend/src/common/prettier/plugins/toml/index.ts
Normal file
72
frontend/src/common/prettier/plugins/toml/index.ts
Normal file
@@ -0,0 +1,72 @@
|
||||
/**
|
||||
* Prettier Plugin for TOML file formatting
|
||||
*
|
||||
* This plugin provides support for formatting TOML (Tom's Obvious, Minimal Language) files
|
||||
* using the @toml-tools/parser and custom beautifier.
|
||||
*/
|
||||
|
||||
import type { Plugin, Parser, Printer, SupportLanguage, SupportOption } from 'prettier';
|
||||
import { parse } from '@toml-tools/parser';
|
||||
import { locStart, locEnd } from './loc';
|
||||
import { print } from './printer';
|
||||
import type { TomlDocument, TomlCstNode } from './types';
|
||||
|
||||
const parserName = 'toml';
|
||||
|
||||
// https://prettier.io/docs/en/plugins.html#languages
|
||||
const languages: SupportLanguage[] = [
|
||||
{
|
||||
extensions: ['.toml'],
|
||||
name: 'Toml',
|
||||
parsers: [parserName],
|
||||
filenames: ['Cargo.lock', 'Gopkg.lock'],
|
||||
tmScope: 'source.toml',
|
||||
aceMode: 'toml',
|
||||
codemirrorMode: 'toml',
|
||||
codemirrorMimeType: 'text/x-toml',
|
||||
linguistLanguageId: 365,
|
||||
vscodeLanguageIds: ['toml'],
|
||||
},
|
||||
];
|
||||
|
||||
// https://prettier.io/docs/en/plugins.html#parsers
|
||||
const tomlParser: Parser<TomlDocument> = {
|
||||
astFormat: 'toml-cst',
|
||||
parse: (text: string): TomlDocument => {
|
||||
try {
|
||||
return parse(text) as TomlDocument;
|
||||
} catch (error) {
|
||||
console.error('TOML parsing error:', error);
|
||||
throw error;
|
||||
}
|
||||
},
|
||||
locStart,
|
||||
locEnd,
|
||||
};
|
||||
|
||||
// https://prettier.io/docs/en/plugins.html#printers
|
||||
const tomlPrinter: Printer<TomlCstNode> = {
|
||||
print,
|
||||
};
|
||||
|
||||
// Plugin options
|
||||
const options: Record<string, SupportOption> = {
|
||||
|
||||
};
|
||||
|
||||
// Plugin definition
|
||||
const tomlPlugin: Plugin = {
|
||||
languages,
|
||||
parsers: {
|
||||
[parserName]: tomlParser,
|
||||
},
|
||||
printers: {
|
||||
'toml-cst': tomlPrinter,
|
||||
},
|
||||
options,
|
||||
};
|
||||
|
||||
export default tomlPlugin;
|
||||
export { languages };
|
||||
export const parsers = tomlPlugin.parsers;
|
||||
export const printers = tomlPlugin.printers;
|
||||
82
frontend/src/common/prettier/plugins/toml/loc.ts
Normal file
82
frontend/src/common/prettier/plugins/toml/loc.ts
Normal file
@@ -0,0 +1,82 @@
|
||||
/**
|
||||
* Location utilities for TOML CST nodes
|
||||
* These functions help Prettier determine the location of nodes for formatting
|
||||
*/
|
||||
|
||||
import type { TomlCstNode } from './types';
|
||||
|
||||
/**
|
||||
* Get the start location of a CST node
|
||||
* @param cstNode - The TOML CST node
|
||||
* @returns The start offset of the node
|
||||
*/
|
||||
export function locStart(cstNode: TomlCstNode): number {
|
||||
if (!cstNode) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
// If the node has a direct startOffset, use it
|
||||
if (typeof cstNode.startOffset === 'number') {
|
||||
return cstNode.startOffset;
|
||||
}
|
||||
|
||||
// If the node has children, find the earliest start offset
|
||||
if (cstNode.children) {
|
||||
let minOffset = Infinity;
|
||||
for (const key in cstNode.children) {
|
||||
const childrenArray = cstNode.children[key];
|
||||
if (Array.isArray(childrenArray)) {
|
||||
for (const child of childrenArray) {
|
||||
const childStart = locStart(child);
|
||||
if (childStart < minOffset) {
|
||||
minOffset = childStart;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return minOffset === Infinity ? 0 : minOffset;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the end location of a CST node
|
||||
* @param cstNode - The TOML CST node
|
||||
* @returns The end offset of the node
|
||||
*/
|
||||
export function locEnd(cstNode: TomlCstNode): number {
|
||||
if (!cstNode) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
// If the node has a direct endOffset, use it
|
||||
if (typeof cstNode.endOffset === 'number') {
|
||||
return cstNode.endOffset;
|
||||
}
|
||||
|
||||
// If the node has children, find the latest end offset
|
||||
if (cstNode.children) {
|
||||
let maxOffset = -1;
|
||||
for (const key in cstNode.children) {
|
||||
const childrenArray = cstNode.children[key];
|
||||
if (Array.isArray(childrenArray)) {
|
||||
for (const child of childrenArray) {
|
||||
const childEnd = locEnd(child);
|
||||
if (childEnd > maxOffset) {
|
||||
maxOffset = childEnd;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return maxOffset === -1 ? 0 : maxOffset;
|
||||
}
|
||||
|
||||
// If the node has an image (token), return the length
|
||||
if (cstNode.image) {
|
||||
const startOffset = locStart(cstNode);
|
||||
return startOffset + cstNode.image.length;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
284
frontend/src/common/prettier/plugins/toml/printer-utils.ts
Normal file
284
frontend/src/common/prettier/plugins/toml/printer-utils.ts
Normal file
@@ -0,0 +1,284 @@
|
||||
/**
|
||||
* Utility functions for TOML printer
|
||||
*/
|
||||
|
||||
import type { TomlCstNode, TomlComment, TomlContext } from './types';
|
||||
|
||||
/**
|
||||
* Trim trailing whitespace from comment text
|
||||
* @param commentText - The comment text to trim
|
||||
* @returns Trimmed comment text
|
||||
*/
|
||||
export function trimComment(commentText: string): string {
|
||||
return commentText.replace(/[ \t]+$/, '');
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a quoted string can be unquoted
|
||||
* @param quotedText - The quoted text to check
|
||||
* @returns Whether the text can be unquoted
|
||||
*/
|
||||
export function canUnquote(quotedText: string): boolean {
|
||||
// Remove quotes if present
|
||||
let text = quotedText;
|
||||
if (text.startsWith('"') && text.endsWith('"')) {
|
||||
text = text.slice(1, -1);
|
||||
} else if (text.startsWith("'") && text.endsWith("'")) {
|
||||
text = text.slice(1, -1);
|
||||
}
|
||||
|
||||
// Empty string needs quotes
|
||||
if (text.length === 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Check if the string is a valid unquoted key
|
||||
// TOML unquoted keys can contain:
|
||||
// - A-Z, a-z, 0-9, _, -
|
||||
const unquotedKeyRegex = /^[A-Za-z0-9_-]+$/;
|
||||
|
||||
// Additional checks for values that might be confused with other TOML types
|
||||
if (unquotedKeyRegex.test(text)) {
|
||||
// Don't unquote strings that look like booleans
|
||||
if (text === 'true' || text === 'false') {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Don't unquote strings that look like numbers
|
||||
if (/^[+-]?(\d+\.?\d*|\d*\.\d+)([eE][+-]?\d+)?$/.test(text)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Don't unquote strings that look like dates/times
|
||||
if (/^\d{4}-\d{2}-\d{2}/.test(text)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a key needs quotes
|
||||
* @param keyText - The key text to check
|
||||
* @returns Whether the key needs quotes
|
||||
*/
|
||||
export function keyNeedsQuotes(keyText: string): boolean {
|
||||
return !canUnquote(`"${keyText}"`);
|
||||
}
|
||||
|
||||
/**
|
||||
* Format a key, adding or removing quotes as needed
|
||||
* @param keyText - The key text to format
|
||||
* @returns Formatted key
|
||||
*/
|
||||
export function formatKey(keyText: string): string {
|
||||
// If already quoted, check if we can unquote
|
||||
if ((keyText.startsWith('"') && keyText.endsWith('"')) ||
|
||||
(keyText.startsWith("'") && keyText.endsWith("'"))) {
|
||||
if (canUnquote(keyText)) {
|
||||
return keyText.slice(1, -1);
|
||||
}
|
||||
return keyText;
|
||||
}
|
||||
|
||||
// If not quoted, check if we need to add quotes
|
||||
if (keyNeedsQuotes(keyText)) {
|
||||
return `"${keyText}"`;
|
||||
}
|
||||
|
||||
return keyText;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a string contains escape sequences that need to be preserved
|
||||
* @param str - The string to check
|
||||
* @returns Whether the string contains escape sequences
|
||||
*/
|
||||
export function containsEscapeSequences(str: string): boolean {
|
||||
// Check for common escape sequences
|
||||
return /\\[btnfr"\\\/]|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}/.test(str);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a string can use literal string syntax (single quotes)
|
||||
* @param str - The string to check (without quotes)
|
||||
* @returns Whether literal string syntax can be used
|
||||
*/
|
||||
export function canUseLiteralString(str: string): boolean {
|
||||
// Literal strings cannot contain single quotes or control characters
|
||||
// and don't need escape sequences
|
||||
return !str.includes("'") &&
|
||||
!/[\x00-\x08\x0A-\x1F\x7F]/.test(str) &&
|
||||
!containsEscapeSequences(str);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a string should use multiline syntax
|
||||
* @param str - The string to check (without quotes)
|
||||
* @returns Whether multiline syntax should be used
|
||||
*/
|
||||
export function shouldUseMultiline(str: string): boolean {
|
||||
// Use multiline for strings that contain newlines
|
||||
return str.includes('\n') || str.includes('\r');
|
||||
}
|
||||
|
||||
/**
|
||||
* Format a string value optimally
|
||||
* @param value - The string value (potentially with quotes)
|
||||
* @returns Optimally formatted string
|
||||
*/
|
||||
export function formatStringValue(value: string): string {
|
||||
// If it's already a properly formatted string, keep it
|
||||
if (!value.startsWith('"') && !value.startsWith("'")) {
|
||||
return value;
|
||||
}
|
||||
|
||||
// Extract the actual string content
|
||||
let content: string;
|
||||
let isLiteral = false;
|
||||
|
||||
if (value.startsWith('"""') && value.endsWith('"""')) {
|
||||
// Multiline basic string
|
||||
content = value.slice(3, -3);
|
||||
} else if (value.startsWith("'''") && value.endsWith("'''")) {
|
||||
// Multiline literal string
|
||||
content = value.slice(3, -3);
|
||||
isLiteral = true;
|
||||
} else if (value.startsWith('"') && value.endsWith('"')) {
|
||||
// Basic string
|
||||
content = value.slice(1, -1);
|
||||
} else if (value.startsWith("'") && value.endsWith("'")) {
|
||||
// Literal string
|
||||
content = value.slice(1, -1);
|
||||
isLiteral = true;
|
||||
} else {
|
||||
return value; // Fallback
|
||||
}
|
||||
|
||||
// Decide on the best format
|
||||
if (shouldUseMultiline(content)) {
|
||||
if (isLiteral || !containsEscapeSequences(content)) {
|
||||
// Use multiline literal string if no escapes needed
|
||||
return `'''${content}'''`;
|
||||
} else {
|
||||
// Use multiline basic string
|
||||
return `"""${content}"""`;
|
||||
}
|
||||
} else {
|
||||
if (canUseLiteralString(content) && !containsEscapeSequences(content)) {
|
||||
// Use literal string for simple cases
|
||||
return `'${content}'`;
|
||||
} else {
|
||||
// Use basic string
|
||||
return `"${content}"`;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Optimize value representation (for strings, numbers, etc.)
|
||||
* @param value - The value to optimize
|
||||
* @returns Optimized value representation
|
||||
*/
|
||||
export function optimizeValue(value: string): string {
|
||||
// Handle string values
|
||||
if (value.startsWith('"') || value.startsWith("'")) {
|
||||
return formatStringValue(value);
|
||||
}
|
||||
|
||||
// For non-strings, return as-is
|
||||
return value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Collect all comments from comment newline nodes
|
||||
* @param commentsNL - Array of comment newline nodes
|
||||
* @returns Array of comment tokens
|
||||
*/
|
||||
export function collectComments(commentsNL: TomlCstNode[] = []): TomlComment[] {
|
||||
const comments: TomlComment[] = [];
|
||||
|
||||
commentsNL.forEach((commentNLNode) => {
|
||||
if (commentNLNode.children?.Comment) {
|
||||
const commentsTok = commentNLNode.children.Comment;
|
||||
for (const comment of commentsTok) {
|
||||
if (comment.image) {
|
||||
comments.push(comment as TomlComment);
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
return comments;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a single element from a context that should contain exactly one key-value pair
|
||||
* @param ctx - The context to extract from
|
||||
* @returns The single element
|
||||
* @throws Error if the context doesn't contain exactly one element
|
||||
*/
|
||||
export function getSingle(ctx: TomlContext): TomlCstNode {
|
||||
const ctxKeys = Object.keys(ctx);
|
||||
if (ctxKeys.length !== 1) {
|
||||
throw new Error(
|
||||
`Expecting single key CST ctx but found: <${ctxKeys.length}> keys`
|
||||
);
|
||||
}
|
||||
|
||||
const singleElementKey = ctxKeys[0];
|
||||
const singleElementValues = ctx[singleElementKey];
|
||||
|
||||
if (!Array.isArray(singleElementValues) || singleElementValues.length !== 1) {
|
||||
throw new Error(
|
||||
`Expecting single item in CST ctx key but found: <${singleElementValues?.length || 0}> items`
|
||||
);
|
||||
}
|
||||
|
||||
return singleElementValues[0];
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the start offset of an array item (deprecated - use arrItemProp instead)
|
||||
* @param item - The array item node
|
||||
* @returns The start offset
|
||||
*/
|
||||
export function arrItemOffset(item: TomlCstNode): number {
|
||||
return arrItemProp(item, 'startOffset') as number;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a specific property from an array item, handling wrapped values
|
||||
* @param item - The array item node
|
||||
* @param propName - The property name to retrieve
|
||||
* @returns The property value
|
||||
* @throws Error for non-exhaustive matches
|
||||
*/
|
||||
export function arrItemProp(item: TomlCstNode, propName: keyof TomlCstNode): any {
|
||||
let currentItem = item;
|
||||
|
||||
// Unwrap 'val' nodes
|
||||
if (currentItem.name === 'val' && currentItem.children) {
|
||||
currentItem = getSingle(currentItem.children);
|
||||
}
|
||||
|
||||
// Direct property access
|
||||
if (currentItem[propName] !== undefined) {
|
||||
return currentItem[propName];
|
||||
}
|
||||
|
||||
// Check for LSquare (array start)
|
||||
if (currentItem.children?.LSquare?.[0]?.[propName] !== undefined) {
|
||||
return currentItem.children.LSquare[0][propName];
|
||||
}
|
||||
|
||||
// Check for LCurly (inline table start)
|
||||
if (currentItem.children?.LCurly?.[0]?.[propName] !== undefined) {
|
||||
return currentItem.children.LCurly[0][propName];
|
||||
}
|
||||
|
||||
throw new Error(`Non-exhaustive match for property ${propName}`);
|
||||
}
|
||||
413
frontend/src/common/prettier/plugins/toml/printer.ts
Normal file
413
frontend/src/common/prettier/plugins/toml/printer.ts
Normal file
@@ -0,0 +1,413 @@
|
||||
/**
|
||||
* TOML Printer for Prettier
|
||||
*
|
||||
* This module provides a visitor-based printer for TOML CST nodes,
|
||||
* converting them to Prettier's document format.
|
||||
*/
|
||||
|
||||
import { BaseTomlCstVisitor } from '@toml-tools/parser';
|
||||
import { tokensDictionary as t } from '@toml-tools/lexer';
|
||||
import { doc } from 'prettier';
|
||||
import type { AstPath, Doc } from 'prettier';
|
||||
import {
|
||||
trimComment,
|
||||
collectComments,
|
||||
arrItemOffset,
|
||||
arrItemProp,
|
||||
getSingle,
|
||||
formatKey,
|
||||
optimizeValue,
|
||||
} from './printer-utils';
|
||||
import type {
|
||||
TomlCstNode,
|
||||
TomlDocument,
|
||||
TomlExpression,
|
||||
TomlKeyVal,
|
||||
TomlComment,
|
||||
TomlContext
|
||||
} from './types';
|
||||
|
||||
const { join, line, hardline, softline, ifBreak, indent, group } = doc.builders;
|
||||
|
||||
/**
|
||||
* TOML Beautifier Visitor class that extends the base CST visitor
|
||||
*/
|
||||
class TomlBeautifierVisitor extends BaseTomlCstVisitor {
|
||||
// Helper methods
|
||||
public mapVisit: (elements: TomlCstNode[] | undefined) => (Doc | string)[];
|
||||
public visitSingle: (ctx: TomlContext) => Doc | string;
|
||||
public visit: (ctx: TomlCstNode, inParam?: any) => Doc | string;
|
||||
|
||||
constructor() {
|
||||
super();
|
||||
|
||||
// Try to call validateVisitor if it exists
|
||||
if (typeof (this as any).validateVisitor === 'function') {
|
||||
(this as any).validateVisitor();
|
||||
}
|
||||
|
||||
// Initialize helper methods
|
||||
this.mapVisit = (elements: TomlCstNode[] | undefined): (Doc | string)[] => {
|
||||
if (!elements) {
|
||||
return [];
|
||||
}
|
||||
return elements.map((element) => this.visit(element));
|
||||
};
|
||||
|
||||
this.visitSingle = (ctx: TomlContext): Doc | string => {
|
||||
const singleElement = getSingle(ctx);
|
||||
return this.visit(singleElement);
|
||||
};
|
||||
|
||||
// Store reference to inherited visit method and override it
|
||||
const originalVisit = Object.getPrototypeOf(this).visit?.bind(this);
|
||||
this.visit = (ctx: TomlCstNode, inParam?: any): Doc | string => {
|
||||
if (!ctx) {
|
||||
return '';
|
||||
}
|
||||
|
||||
// Try to use the inherited visit method first
|
||||
if (originalVisit) {
|
||||
try {
|
||||
return originalVisit(ctx, inParam);
|
||||
} catch (error) {
|
||||
console.warn('Original visit method failed:', error);
|
||||
}
|
||||
}
|
||||
|
||||
// Fallback: manually dispatch based on node name/type
|
||||
const methodName = ctx.name;
|
||||
if (methodName && typeof (this as any)[methodName] === 'function') {
|
||||
const visitMethod = (this as any)[methodName];
|
||||
try {
|
||||
if (ctx.children) {
|
||||
return visitMethod.call(this, ctx.children);
|
||||
} else {
|
||||
return visitMethod.call(this, ctx);
|
||||
}
|
||||
} catch (error) {
|
||||
console.warn(`Visit method ${methodName} failed:`, error);
|
||||
}
|
||||
}
|
||||
|
||||
// Final fallback: return image if available
|
||||
return ctx.image || '';
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Visit the root TOML document
|
||||
*/
|
||||
toml(ctx: TomlDocument): Doc {
|
||||
// Handle empty toml document
|
||||
if (!ctx.expression) {
|
||||
return [line];
|
||||
}
|
||||
|
||||
const isTable = (node: TomlExpression): boolean => {
|
||||
return !!node.table;
|
||||
};
|
||||
|
||||
const isOnlyComment = (node: TomlExpression): boolean => {
|
||||
return !!node.Comment && Object.keys(node).length === 1;
|
||||
};
|
||||
|
||||
const expsCsts = ctx.expression;
|
||||
const cstGroups: TomlExpression[][] = [];
|
||||
let currCstGroup: TomlExpression[] = [];
|
||||
|
||||
// Split expressions into groups defined by tables
|
||||
for (let i = expsCsts.length - 1; i >= 0; i--) {
|
||||
const currCstNode = expsCsts[i];
|
||||
currCstGroup.push(currCstNode);
|
||||
|
||||
if (isTable(currCstNode)) {
|
||||
let j = i - 1;
|
||||
let stillInComments = true;
|
||||
|
||||
// Add leading comments to current group
|
||||
while (j >= 0 && stillInComments) {
|
||||
const priorCstNode = expsCsts[j];
|
||||
if (isOnlyComment(priorCstNode)) {
|
||||
currCstGroup.push(priorCstNode);
|
||||
j--;
|
||||
i--;
|
||||
} else {
|
||||
stillInComments = false;
|
||||
}
|
||||
}
|
||||
|
||||
// Reverse since we scanned backwards
|
||||
currCstGroup.reverse();
|
||||
cstGroups.push(currCstGroup);
|
||||
currCstGroup = [];
|
||||
}
|
||||
}
|
||||
|
||||
if (currCstGroup.length > 0) {
|
||||
currCstGroup.reverse();
|
||||
cstGroups.push(currCstGroup);
|
||||
}
|
||||
|
||||
// Adjust for reverse scanning
|
||||
cstGroups.reverse();
|
||||
const docGroups = cstGroups.map((currGroup) => this.mapVisit(currGroup));
|
||||
|
||||
// Add newlines between group elements
|
||||
const docGroupsInnerNewlines = docGroups.map((currGroup) =>
|
||||
join(line, currGroup)
|
||||
);
|
||||
const docGroupsOuterNewlines = join([line, line], docGroupsInnerNewlines);
|
||||
|
||||
return [docGroupsOuterNewlines, line];
|
||||
}
|
||||
|
||||
/**
|
||||
* Visit an expression (keyval, table, or comment)
|
||||
*/
|
||||
expression(ctx: TomlExpression): Doc | string {
|
||||
if (ctx.keyval) {
|
||||
let keyValDoc = this.visit(ctx.keyval[0]);
|
||||
if (ctx.Comment) {
|
||||
const commentText = trimComment(ctx.Comment[0].image);
|
||||
keyValDoc = [keyValDoc, ' ' + commentText];
|
||||
}
|
||||
return keyValDoc;
|
||||
} else if (ctx.table) {
|
||||
let tableDoc = this.visit(ctx.table[0]);
|
||||
if (ctx.Comment) {
|
||||
const commentText = trimComment(ctx.Comment[0].image);
|
||||
tableDoc = [tableDoc, ' ' + commentText];
|
||||
}
|
||||
return tableDoc;
|
||||
} else if (ctx.Comment) {
|
||||
return trimComment(ctx.Comment[0].image);
|
||||
}
|
||||
|
||||
return '';
|
||||
}
|
||||
|
||||
/**
|
||||
* Visit a key-value pair
|
||||
*/
|
||||
keyval(ctx: TomlKeyVal): Doc {
|
||||
const keyDoc = this.visit(ctx.key[0]);
|
||||
const valueDoc = this.visit(ctx.val[0]);
|
||||
return [keyDoc, ' = ', valueDoc];
|
||||
}
|
||||
|
||||
/**
|
||||
* Visit a key
|
||||
*/
|
||||
key(ctx: any): Doc {
|
||||
const keyTexts = ctx.IKey?.map((tok: any) => {
|
||||
const keyText = tok.image;
|
||||
// Apply key formatting (add/remove quotes as needed)
|
||||
return formatKey(keyText);
|
||||
}) || [];
|
||||
|
||||
return join('.', keyTexts);
|
||||
}
|
||||
|
||||
/**
|
||||
* Visit a value
|
||||
*/
|
||||
val(ctx: any): Doc | string {
|
||||
try {
|
||||
const actualValueNode = getSingle(ctx);
|
||||
if (actualValueNode.image !== undefined) {
|
||||
// Terminal token - 优化值的表示
|
||||
return optimizeValue(actualValueNode.image);
|
||||
} else {
|
||||
return this.visit(actualValueNode);
|
||||
}
|
||||
} catch (error) {
|
||||
// 如果getSingle失败，尝试直接处理children
|
||||
if (ctx.children) {
|
||||
// 处理不同类型的值
|
||||
for (const [childKey, childNodes] of Object.entries(ctx.children)) {
|
||||
if (Array.isArray(childNodes) && childNodes.length > 0) {
|
||||
const firstChild = childNodes[0];
|
||||
|
||||
// 处理基本类型
|
||||
if (firstChild.image !== undefined) {
|
||||
// 优化值的表示（特别是字符串）
|
||||
return optimizeValue(firstChild.image);
|
||||
}
|
||||
|
||||
// 处理复杂类型（如数组、内联表等）
|
||||
if (firstChild.name) {
|
||||
return this.visit(firstChild);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return '';
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Visit an array
|
||||
*/
|
||||
array(ctx: any): Doc {
|
||||
const arrayValuesDocs = ctx.arrayValues ? this.visit(ctx.arrayValues) : '';
|
||||
const postComments = collectComments(ctx.commentNewline);
|
||||
const commentsDocs = postComments.map((commentTok) => {
|
||||
const trimmedCommentText = trimComment(commentTok.image);
|
||||
return [hardline, trimmedCommentText];
|
||||
});
|
||||
|
||||
return group(['[', indent([arrayValuesDocs, commentsDocs]), softline, ']']);
|
||||
}
|
||||
|
||||
/**
|
||||
* Visit array values
|
||||
*/
|
||||
arrayValues(ctx: any): Doc {
|
||||
const values = ctx.val || [];
|
||||
const commas = ctx.Comma || [];
|
||||
const comments = collectComments(ctx.commentNewline);
|
||||
|
||||
const itemsCst = [...values, ...commas, ...comments];
|
||||
itemsCst.sort((a, b) => {
|
||||
const aOffset = arrItemOffset(a);
|
||||
const bOffset = arrItemOffset(b);
|
||||
return aOffset - bOffset;
|
||||
});
|
||||
|
||||
const itemsDoc: Doc[] = [];
|
||||
|
||||
for (let i = 0; i < itemsCst.length; i++) {
|
||||
const cstItem = itemsCst[i];
|
||||
|
||||
if (cstItem.name === 'val') {
|
||||
const valDoc = this.visit(cstItem);
|
||||
const valEndLine = arrItemProp(cstItem, 'endLine');
|
||||
let potentialComma = '';
|
||||
|
||||
// Handle next item (comma or comment)
|
||||
if (itemsCst[i + 1]) {
|
||||
let nextPossibleComment = itemsCst[i + 1];
|
||||
|
||||
// Skip commas
|
||||
if (nextPossibleComment.tokenType === t.Comma) {
|
||||
potentialComma = ',';
|
||||
i++;
|
||||
nextPossibleComment = itemsCst[i + 1];
|
||||
}
|
||||
|
||||
// Handle same-line comments
|
||||
if (
|
||||
nextPossibleComment &&
|
||||
nextPossibleComment.tokenType === t.Comment &&
|
||||
nextPossibleComment.startLine === valEndLine
|
||||
) {
|
||||
i++;
|
||||
const trimmedComment = trimComment(nextPossibleComment.image);
|
||||
const comment = ' ' + trimmedComment;
|
||||
itemsDoc.push([valDoc, potentialComma, comment, hardline]);
|
||||
} else {
|
||||
// No comment on same line
|
||||
const isTrailingComma = i === itemsCst.length - 1;
|
||||
const optionalCommaLineBreak = isTrailingComma
|
||||
? ifBreak(',', '') // Only print trailing comma if multiline array
|
||||
: [potentialComma, line];
|
||||
itemsDoc.push([valDoc, optionalCommaLineBreak]);
|
||||
}
|
||||
} else {
|
||||
// Last item without followup
|
||||
itemsDoc.push([valDoc]);
|
||||
}
|
||||
} else if (cstItem.tokenType === t.Comment) {
|
||||
// Separate line comment
|
||||
const trimmedComment = trimComment(cstItem.image);
|
||||
itemsDoc.push([trimmedComment, hardline]);
|
||||
} else {
|
||||
throw new Error('Non-exhaustive match in arrayValues');
|
||||
}
|
||||
}
|
||||
|
||||
return [softline, itemsDoc];
|
||||
}
|
||||
|
||||
/**
|
||||
* Visit an inline table
|
||||
*/
|
||||
inlineTable(ctx: any): Doc {
|
||||
const inlineTableKeyValsDocs = ctx.inlineTableKeyVals
|
||||
? this.visit(ctx.inlineTableKeyVals)
|
||||
: '';
|
||||
return group(['{ ', inlineTableKeyValsDocs, ' }']);
|
||||
}
|
||||
|
||||
/**
|
||||
* Visit inline table key-value pairs
|
||||
*/
|
||||
inlineTableKeyVals(ctx: any): Doc {
|
||||
const keyValDocs = this.mapVisit(ctx.keyval);
|
||||
return join(', ', keyValDocs);
|
||||
}
|
||||
|
||||
/**
|
||||
* Visit a table
|
||||
*/
|
||||
table(ctx: any): Doc | string {
|
||||
return this.visitSingle(ctx);
|
||||
}
|
||||
|
||||
/**
|
||||
* Visit a standard table
|
||||
*/
|
||||
stdTable(ctx: any): Doc {
|
||||
if (ctx.key && ctx.key[0] && ctx.key[0].children && ctx.key[0].children.IKey) {
|
||||
const keyTexts = ctx.key[0].children.IKey.map((tok: any) => {
|
||||
return formatKey(tok.image);
|
||||
});
|
||||
return ['[', join('.', keyTexts), ']'];
|
||||
}
|
||||
return '[]';
|
||||
}
|
||||
|
||||
/**
|
||||
* Visit an array table
|
||||
*/
|
||||
arrayTable(ctx: any): Doc {
|
||||
if (ctx.key && ctx.key[0] && ctx.key[0].children && ctx.key[0].children.IKey) {
|
||||
const keyTexts = ctx.key[0].children.IKey.map((tok: any) => {
|
||||
return formatKey(tok.image);
|
||||
});
|
||||
return ['[[', join('.', keyTexts), ']]'];
|
||||
}
|
||||
return '[[]]';
|
||||
}
|
||||
|
||||
/**
|
||||
* Visit newline (should not be called)
|
||||
*/
|
||||
nl(ctx: any): never {
|
||||
throw new Error('Should not get here!');
|
||||
}
|
||||
|
||||
/**
|
||||
* Visit comment newline (no-op)
|
||||
*/
|
||||
commentNewline(ctx: any): void {
|
||||
// No operation needed
|
||||
}
|
||||
}
|
||||
|
||||
// Create singleton visitor instance
|
||||
const beautifierVisitor = new TomlBeautifierVisitor();
|
||||
|
||||
/**
|
||||
* Main print function for Prettier
|
||||
* @param path - AST path from Prettier
|
||||
* @param options - Print options
|
||||
* @param print - Print function (unused in this implementation)
|
||||
* @returns Formatted document
|
||||
*/
|
||||
export function print(path: AstPath<TomlCstNode>, options?: any, print?: any): Doc {
|
||||
const cst = path.node as TomlDocument;
|
||||
return beautifierVisitor.visit(cst);
|
||||
}
|
||||
62
frontend/src/common/prettier/plugins/toml/types.ts
Normal file
62
frontend/src/common/prettier/plugins/toml/types.ts
Normal file
@@ -0,0 +1,62 @@
|
||||
/**
|
||||
* TypeScript type definitions for TOML Prettier plugin
|
||||
*/
|
||||
|
||||
// TOML CST Node types based on @toml-tools/parser
|
||||
export interface TomlCstNode {
|
||||
name?: string;
|
||||
image?: string;
|
||||
children?: Record<string, TomlCstNode[]>;
|
||||
startOffset?: number;
|
||||
endOffset?: number;
|
||||
startLine?: number;
|
||||
endLine?: number;
|
||||
tokenType?: any;
|
||||
}
|
||||
|
||||
export interface TomlComment extends TomlCstNode {
|
||||
image: string;
|
||||
}
|
||||
|
||||
export interface TomlContext {
|
||||
[key: string]: TomlCstNode[];
|
||||
}
|
||||
|
||||
export interface TomlValue extends TomlCstNode {
|
||||
children: TomlContext;
|
||||
}
|
||||
|
||||
export interface TomlKeyVal extends TomlCstNode {
|
||||
key: TomlCstNode[];
|
||||
val: TomlCstNode[];
|
||||
}
|
||||
|
||||
export interface TomlArray extends TomlCstNode {
|
||||
arrayValues?: TomlCstNode;
|
||||
commentNewline?: TomlCstNode[];
|
||||
}
|
||||
|
||||
export interface TomlInlineTable extends TomlCstNode {
|
||||
inlineTableKeyVals?: TomlCstNode;
|
||||
}
|
||||
|
||||
export interface TomlTable extends TomlCstNode {
|
||||
table: TomlCstNode[];
|
||||
}
|
||||
|
||||
export interface TomlExpression extends TomlCstNode {
|
||||
keyval?: TomlKeyVal[];
|
||||
table?: TomlTable[];
|
||||
Comment?: TomlComment[];
|
||||
}
|
||||
|
||||
export interface TomlDocument extends TomlCstNode {
|
||||
expression?: TomlExpression[];
|
||||
}
|
||||
|
||||
// Print options for TOML formatting
|
||||
export interface TomlPrintOptions {
|
||||
printWidth?: number;
|
||||
tabWidth?: number;
|
||||
useTabs?: boolean;
|
||||
}
|
||||
Reference in New Issue
Block a user