Initial work on document formatting support for PICO-8 Lua files

README.md

@@ -40,6 +40,12 @@ such as NeoVim, Atom, etc.
 
 - Snippets for common idioms (functions, loops, #include, etc.)
 - Hover support/signature help for user-defined functions/variables
+- code formatting
+
+# Development
+
+Please follow the official [Language Server Extension Guide](https://code.visualstudio.com/api/language-extensions/language-server-extension-guide)
+to understand how to develop VS Code language server extension.
 
 # Changelog
 

client/src/luafmt.d.ts

@@ -0,0 +1,3 @@
+declare module '@appguru/luafmt' {
+  export function formatChunk(chunk: string): string;
+}

server/src/parser/ast.ts

@@ -3,7 +3,7 @@ import { BinaryExpression, CallExpression, Comment_, Expression, GeneralTableFie
   IndexExpression, Variable, Literal, LogicalExpression, MemberExpression, StringCallExpression, StringLiteral,
   TableCallExpression, TableConstructorExpression, TableKey, TableKeyString, TableValue, UnaryExpression,
 } from './expressions';
-import { AssignmentStatement, BreakStatement, CallStatement, Chunk, DoStatement, ElseClause, ElseifClause,
+import { AssignmentStatement, Block, BreakStatement, CallStatement, Chunk, DoStatement, ElseClause, ElseifClause,
   ForGenericStatement, ForNumericStatement, FunctionDeclaration, FunctionParameter, GeneralIfClause,
   GotoStatement, IfClause, IfStatement, LabelStatement, LocalStatement, RepeatStatement, ReturnStatement,
   Statement, WhileStatement } from './statements';
@@ -15,6 +15,13 @@ import structuredClone from '@ungap/structured-clone';
 // The default AST structure is inspired by the Mozilla Parser API but can
 // easily be customized by overriding these functions.
 export default class AST {
+  static block(body: Statement[]): Block {
+    return {
+      type: 'Block',
+      body,
+    };
+  }
+
   static labelStatement(label: Identifier): LabelStatement {
     return {
       type: 'LabelStatement',
@@ -42,56 +49,57 @@ export default class AST {
     };
   }
 
-  static ifStatement(clauses: GeneralIfClause[]): IfStatement {
+  static ifStatement(clauses: GeneralIfClause[], oneLine: boolean): IfStatement {
     return {
       type: 'IfStatement',
       clauses: clauses,
+      oneLine,
     };
   }
 
-  static ifClause(condition: Expression, body: Statement[]): IfClause {
+  static ifClause(condition: Expression, block: Block): IfClause {
     return {
       type: 'IfClause',
       condition: condition,
-      body: body,
+      block: block,
     };
   }
 
-  static elseifClause(condition: Expression, body: Statement[]): ElseifClause {
+  static elseifClause(condition: Expression, block: Block): ElseifClause {
     return {
       type: 'ElseifClause',
       condition: condition,
-      body: body,
+      block: block,
     };
   }
 
-  static elseClause(body: Statement[]): ElseClause {
+  static elseClause(block: Block): ElseClause {
     return {
       type: 'ElseClause',
-      body: body,
+      block: block,
     };
   }
 
-  static whileStatement(condition: Expression, body: Statement[]): WhileStatement {
+  static whileStatement(condition: Expression, block: Block): WhileStatement {
     return {
       type: 'WhileStatement',
       condition: condition,
-      body: body,
+      block: block,
     };
   }
 
-  static doStatement(body: Statement[]): DoStatement {
+  static doStatement(block: Block): DoStatement {
     return {
       type: 'DoStatement',
-      body: body,
+      block: block,
     };
   }
 
-  static repeatStatement(condition: Expression, body: Statement[]): RepeatStatement {
+  static repeatStatement(condition: Expression, block: Block): RepeatStatement {
     return {
       type: 'RepeatStatement',
       condition: condition,
-      body: body,
+      block: block,
     };
   }
 
@@ -124,14 +132,14 @@ export default class AST {
     identifier: Identifier | MemberExpression | null,
     parameters: FunctionParameter[],
     isLocal: boolean,
-    body: Statement[],
+    block: Block,
   ): FunctionDeclaration {
     return {
       type: 'FunctionDeclaration',
       identifier: identifier,
       isLocal: isLocal,
       parameters: parameters,
-      body: body,
+      block: block,
     };
   }
 
@@ -140,31 +148,31 @@ export default class AST {
     start: Expression,
     end: Expression,
     step: Expression | null,
-    body: Statement[],
+    block: Block,
   ): ForNumericStatement {
     return {
       type: 'ForNumericStatement',
       variable: variable,
       start: start,
       end: end,
       step: step,
-      body: body,
+      block: block,
     };
   }
 
-  static forGenericStatement(variables: Identifier[], iterators: Expression[], body: Statement[]): ForGenericStatement {
+  static forGenericStatement(variables: Identifier[], iterators: Expression[], block: Block): ForGenericStatement {
     return {
       type: 'ForGenericStatement',
       variables: variables,
       iterators: iterators,
-      body: body,
+      block: block,
     };
   }
 
-  static chunk(body: Statement[], errors: ParseError[]): Chunk {
+  static chunk(block: Block, errors: ParseError[]): Chunk {
     return {
       type: 'Chunk',
-      body,
+      block,
       errors,
 
       // This stuff is added later

server/src/parser/expressions.ts

@@ -194,3 +194,13 @@ export type Comment_ = ASTNode & {
   value: string,
   raw: string,
 };
+
+export type Whitespace = ASTNode & {
+  type: 'Whitespace',
+  // The number of newlines to insert
+  count: number,
+};
+
+export function isComment(node: any): node is Comment_ {
+  return node.type === 'Comment';
+}