Skip to content

Commit 81f1dd3

Browse files
PerryvwPerryvw
authored
Feature/restore max line width (#333)
Fix/restore max line width
1 parent 63c2e93 commit 81f1dd3

File tree

10 files changed

+608
-165
lines changed

10 files changed

+608
-165
lines changed

‎.clang-format‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -19,7 +19,7 @@ BreakBeforeBraces: Attach
1919
BreakBeforeInheritanceComma: false
2020
BreakBeforeTernaryOperators: true
2121
BreakConstructorInitializersBeforeComma: true
22-
ColumnLimit: 140
22+
ColumnLimit: 120
2323
ConstructorInitializerAllOnOneLineOrOnePerLine: false
2424
ConstructorInitializerIndentWidth: 4
2525
ContinuationIndentWidth: 4

‎src/CommandLineParser.ts‎

Lines changed: 12 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -92,7 +92,12 @@ export function parseCommandLine(args: string[]): ParsedCommandLine {
9292
const configPath = commandLine.options.project;
9393
const configContents = fs.readFileSync(configPath).toString();
9494
const configJson = ts.parseConfigFileTextToJson(configPath, configContents);
95-
commandLine = ts.parseJsonConfigFileContent(configJson.config, ts.sys, path.dirname(configPath), commandLine.options);
95+
commandLine = ts.parseJsonConfigFileContent(
96+
configJson.config,
97+
ts.sys,
98+
path.dirname(configPath),
99+
commandLine.options
100+
);
96101
}
97102

98103
// Add TSTL options from tsconfig
@@ -119,7 +124,12 @@ export function parseCommandLine(args: string[]): ParsedCommandLine {
119124
return commandLine as ParsedCommandLine;
120125
}
121126

122-
function addTSTLOptions(commandLine: ts.ParsedCommandLine, additionalArgs?: yargs.Arguments, forceOverride?: boolean): void {
127+
function addTSTLOptions(
128+
commandLine: ts.ParsedCommandLine,
129+
additionalArgs?: yargs.Arguments,
130+
forceOverride?: boolean
131+
): void
132+
{
123133
additionalArgs = additionalArgs ? additionalArgs : commandLine.raw;
124134
// Add compiler options that are ignored by TS parsers
125135
if (additionalArgs) {

‎src/Compiler.ts‎

Lines changed: 6 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -48,9 +48,13 @@ export function watchWithOptions(fileNames: string[], options: CompilerOptions):
4848
};
4949

5050
if (config) {
51-
ts.createWatchProgram(host as ts.WatchCompilerHostOfConfigFile<ts.SemanticDiagnosticsBuilderProgram>);
51+
ts.createWatchProgram(
52+
host as ts.WatchCompilerHostOfConfigFile<ts.SemanticDiagnosticsBuilderProgram>
53+
);
5254
} else {
53-
ts.createWatchProgram(host as ts.WatchCompilerHostOfFilesAndCompilerOptions<ts.SemanticDiagnosticsBuilderProgram>);
55+
ts.createWatchProgram(
56+
host as ts.WatchCompilerHostOfFilesAndCompilerOptions<ts.SemanticDiagnosticsBuilderProgram>
57+
);
5458
}
5559
}
5660

‎src/LuaAST.ts‎

Lines changed: 108 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -79,18 +79,22 @@ export enum SyntaxKind {
7979
// TODO maybe name this PrefixUnary? not sure it makes sense to do so, because all unary ops in Lua are prefix
8080
export type UnaryBitwiseOperator = SyntaxKind.BitwiseNotOperator;
8181

82-
export type UnaryOperator = SyntaxKind.NegationOperator | SyntaxKind.LengthOperator | SyntaxKind.NotOperator | UnaryBitwiseOperator;
82+
export type UnaryOperator = SyntaxKind.NegationOperator
83+
| SyntaxKind.LengthOperator
84+
| SyntaxKind.NotOperator
85+
| UnaryBitwiseOperator;
8386

84-
export type BinaryBitwiseOperator =
85-
SyntaxKind.BitwiseAndOperator | SyntaxKind.BitwiseOrOperator | SyntaxKind.BitwiseExclusiveOrOperator |
86-
SyntaxKind.BitwiseRightShiftOperator | SyntaxKind.BitwiseArithmeticRightShift | SyntaxKind.BitwiseLeftShiftOperator;
87+
export type BinaryBitwiseOperator = SyntaxKind.BitwiseAndOperator | SyntaxKind.BitwiseOrOperator
88+
| SyntaxKind.BitwiseExclusiveOrOperator | SyntaxKind.BitwiseRightShiftOperator
89+
| SyntaxKind.BitwiseArithmeticRightShift | SyntaxKind.BitwiseLeftShiftOperator;
8790

8891
export type BinaryOperator =
89-
SyntaxKind.AdditionOperator | SyntaxKind.SubractionOperator | SyntaxKind.MultiplicationOperator | SyntaxKind.DivisionOperator |
90-
SyntaxKind.FloorDivisionOperator | SyntaxKind.ModuloOperator | SyntaxKind.PowerOperator | SyntaxKind.ConcatOperator |
91-
SyntaxKind.EqualityOperator | SyntaxKind.InequalityOperator | SyntaxKind.LessThanOperator | SyntaxKind.LessEqualOperator |
92-
SyntaxKind.GreaterThanOperator | SyntaxKind.GreaterEqualOperator | SyntaxKind.AndOperator | SyntaxKind.OrOperator |
93-
BinaryBitwiseOperator;
92+
SyntaxKind.AdditionOperator | SyntaxKind.SubractionOperator | SyntaxKind.MultiplicationOperator
93+
| SyntaxKind.DivisionOperator | SyntaxKind.FloorDivisionOperator | SyntaxKind.ModuloOperator
94+
| SyntaxKind.PowerOperator | SyntaxKind.ConcatOperator | SyntaxKind.EqualityOperator
95+
| SyntaxKind.InequalityOperator | SyntaxKind.LessThanOperator | SyntaxKind.LessEqualOperator
96+
| SyntaxKind.GreaterThanOperator | SyntaxKind.GreaterEqualOperator | SyntaxKind.AndOperator
97+
| SyntaxKind.OrOperator | BinaryBitwiseOperator;
9498

9599
export type Operator = UnaryOperator | BinaryOperator;
96100

@@ -198,7 +202,11 @@ export function createVariableDeclarationStatement(
198202
right?: Expression | Expression[],
199203
parent?: Node,
200204
tsOriginal?: ts.Node): VariableDeclarationStatement {
201-
const statement = createNode(SyntaxKind.VariableDeclarationStatement, parent, tsOriginal) as VariableDeclarationStatement;
205+
const statement = createNode(
206+
SyntaxKind.VariableDeclarationStatement,
207+
parent,
208+
tsOriginal
209+
) as VariableDeclarationStatement;
202210
setParent(left, statement);
203211
if (Array.isArray(left)) {
204212
statement.left = left;
@@ -258,7 +266,13 @@ export function isIfStatement(node: Node): node is IfStatement {
258266
}
259267

260268
export function createIfStatement(
261-
condtion: Expression, ifBlock: Block, elseBlock?: Block | IfStatement, parent?: Node, tsOriginal?: ts.Node): IfStatement {
269+
condtion: Expression,
270+
ifBlock: Block,
271+
elseBlock?: Block | IfStatement,
272+
parent?: Node,
273+
tsOriginal?: ts.Node
274+
): IfStatement
275+
{
262276
const statement = createNode(SyntaxKind.IfStatement, parent, tsOriginal) as IfStatement;
263277
setParent(condtion, statement);
264278
statement.condtion = condtion;
@@ -274,8 +288,8 @@ export interface IterationStatement extends Statement {
274288
}
275289

276290
export function isIterationStatement(node: Node): node is WhileStatement {
277-
return node.kind === SyntaxKind.WhileStatement || node.kind === SyntaxKind.RepeatStatement || node.kind === SyntaxKind.ForStatement ||
278-
node.kind === SyntaxKind.ForInStatement;
291+
return node.kind === SyntaxKind.WhileStatement || node.kind === SyntaxKind.RepeatStatement
292+
|| node.kind === SyntaxKind.ForStatement || node.kind === SyntaxKind.ForInStatement;
279293
}
280294

281295
export interface WhileStatement extends IterationStatement {
@@ -287,7 +301,13 @@ export function isWhileStatement(node: Node): node is WhileStatement {
287301
return node.kind === SyntaxKind.WhileStatement;
288302
}
289303

290-
export function createWhileStatement(body: Block, condtion: Expression, parent?: Node, tsOriginal?: ts.Node): WhileStatement {
304+
export function createWhileStatement(
305+
body: Block,
306+
condtion: Expression,
307+
parent?: Node,
308+
tsOriginal?: ts.Node
309+
): WhileStatement
310+
{
291311
const statement = createNode(SyntaxKind.WhileStatement, parent, tsOriginal) as WhileStatement;
292312
setParent(body, statement);
293313
statement.body = body;
@@ -305,7 +325,13 @@ export function isRepeatStatement(node: Node): node is RepeatStatement {
305325
return node.kind === SyntaxKind.RepeatStatement;
306326
}
307327

308-
export function createRepeatStatement(body: Block, condtion: Expression, parent?: Node, tsOriginal?: ts.Node): RepeatStatement {
328+
export function createRepeatStatement(
329+
body: Block,
330+
condtion: Expression,
331+
parent?: Node,
332+
tsOriginal?: ts.Node
333+
): RepeatStatement
334+
{
309335
const statement = createNode(SyntaxKind.RepeatStatement, parent, tsOriginal) as RepeatStatement;
310336
setParent(body, statement);
311337
statement.body = body;
@@ -410,7 +436,12 @@ export function isReturnStatement(node: Node): node is ReturnStatement {
410436
return node.kind === SyntaxKind.ReturnStatement;
411437
}
412438

413-
export function createReturnStatement(expressions?: Expression[], parent?: Node, tsOriginal?: ts.Node): ReturnStatement {
439+
export function createReturnStatement(
440+
expressions?: Expression[],
441+
parent?: Node,
442+
tsOriginal?: ts.Node
443+
): ReturnStatement
444+
{
414445
const statement = createNode(SyntaxKind.ReturnStatement, parent, tsOriginal) as ReturnStatement;
415446
setParent(expressions, statement);
416447
statement.expressions = expressions;
@@ -438,7 +469,12 @@ export function isExpressionStatement(node: Node): node is ExpressionStatement {
438469
return node.kind === SyntaxKind.ExpressionStatement;
439470
}
440471

441-
export function createExpressionStatement(expressions: Expression, parent?: Node, tsOriginal?: ts.Node): ExpressionStatement {
472+
export function createExpressionStatement(
473+
expressions: Expression,
474+
parent?: Node,
475+
tsOriginal?: ts.Node
476+
): ExpressionStatement
477+
{
442478
const statement = createNode(SyntaxKind.ExpressionStatement, parent, tsOriginal) as ExpressionStatement;
443479
setParent(expressions, statement);
444480
statement.expression = expressions;
@@ -548,8 +584,14 @@ export function isFunctionExpression(node: Node): node is FunctionExpression {
548584
}
549585

550586
export function createFunctionExpression(
551-
body: Block, params?: Identifier[], dots?: DotsLiteral, restParamName?: Identifier, parent?: Node, tsOriginal?: ts.Node):
552-
FunctionExpression {
587+
body: Block,
588+
params?: Identifier[],
589+
dots?: DotsLiteral,
590+
restParamName?: Identifier,
591+
parent?: Node,
592+
tsOriginal?: ts.Node
593+
): FunctionExpression
594+
{
553595
const expression = createNode(SyntaxKind.FunctionExpression, parent, tsOriginal) as FunctionExpression;
554596
setParent(body, expression);
555597
expression.body = body;
@@ -572,7 +614,13 @@ export function isTableFieldExpression(node: Node): node is TableFieldExpression
572614
return node.kind === SyntaxKind.TableFieldExpression;
573615
}
574616

575-
export function createTableFieldExpression(value: Expression, key?: Expression, parent?: Node, tsOriginal?: ts.Node): TableFieldExpression {
617+
export function createTableFieldExpression(
618+
value: Expression,
619+
key?: Expression,
620+
parent?: Node,
621+
tsOriginal?: ts.Node
622+
): TableFieldExpression
623+
{
576624
const expression = createNode(SyntaxKind.TableExpression, parent, tsOriginal) as TableFieldExpression;
577625
setParent(value, expression);
578626
expression.value = value;
@@ -590,7 +638,12 @@ export function isTableExpression(node: Node): node is TableExpression {
590638
return node.kind === SyntaxKind.TableExpression;
591639
}
592640

593-
export function createTableExpression(fields?: TableFieldExpression[], parent?: Node, tsOriginal?: ts.Node): TableExpression {
641+
export function createTableExpression(
642+
fields?: TableFieldExpression[],
643+
parent?: Node,
644+
tsOriginal?: ts.Node
645+
): TableExpression
646+
{
594647
const expression = createNode(SyntaxKind.TableExpression, parent, tsOriginal) as TableExpression;
595648
setParent(fields, expression);
596649
expression.fields = fields;
@@ -607,7 +660,13 @@ export function isUnaryExpression(node: Node): node is UnaryExpression {
607660
return node.kind === SyntaxKind.UnaryExpression;
608661
}
609662

610-
export function createUnaryExpression(operand: Expression, operator: UnaryOperator, parent?: Node, tsOriginal?: ts.Node): UnaryExpression {
663+
export function createUnaryExpression(
664+
operand: Expression,
665+
operator: UnaryOperator,
666+
parent?: Node,
667+
tsOriginal?: ts.Node
668+
): UnaryExpression
669+
{
611670
const expression = createNode(SyntaxKind.UnaryExpression, parent, tsOriginal) as UnaryExpression;
612671
setParent(operand, expression);
613672
expression.operand = operand;
@@ -627,7 +686,13 @@ export function isBinaryExpression(node: Node): node is BinaryExpression {
627686
}
628687

629688
export function createBinaryExpression(
630-
left: Expression, right: Expression, operator: BinaryOperator, parent?: Node, tsOriginal?: ts.Node): BinaryExpression {
689+
left: Expression,
690+
right: Expression,
691+
operator: BinaryOperator,
692+
parent?: Node,
693+
tsOriginal?: ts.Node
694+
): BinaryExpression
695+
{
631696
const expression = createNode(SyntaxKind.BinaryExpression, parent, tsOriginal) as BinaryExpression;
632697
setParent(left, expression);
633698
expression.left = left;
@@ -646,7 +711,12 @@ export function isParenthesizedExpression(node: Node): node is ParenthesizedExpr
646711
return node.kind === SyntaxKind.ParenthesizedExpression;
647712
}
648713

649-
export function createParenthesizedExpression(innerExpression: Expression, parent?: Node, tsOriginal?: ts.Node): ParenthesizedExpression {
714+
export function createParenthesizedExpression(
715+
innerExpression: Expression,
716+
parent?: Node,
717+
tsOriginal?: ts.Node
718+
): ParenthesizedExpression
719+
{
650720
const expression = createNode(SyntaxKind.ParenthesizedExpression, parent, tsOriginal) as ParenthesizedExpression;
651721
setParent(innerExpression, expression);
652722
expression.innerEpxression = innerExpression;
@@ -663,7 +733,13 @@ export function isCallExpression(node: Node): node is CallExpression {
663733
return node.kind === SyntaxKind.CallExpression;
664734
}
665735

666-
export function createCallExpression(expression: Expression, params?: Expression[], parent?: Node, tsOriginal?: ts.Node): CallExpression {
736+
export function createCallExpression(
737+
expression: Expression,
738+
params?: Expression[],
739+
parent?: Node,
740+
tsOriginal?: ts.Node
741+
): CallExpression
742+
{
667743
const callExpression = createNode(SyntaxKind.CallExpression, parent, tsOriginal) as CallExpression;
668744
setParent(expression, callExpression);
669745
callExpression.expression = expression;
@@ -684,7 +760,13 @@ export function isMethodCallExpression(node: Node): node is MethodCallExpression
684760
}
685761

686762
export function createMethodCallExpression(
687-
prefixExpression: Expression, name: Identifier, params?: Expression[], parent?: Node, tsOriginal?: ts.Node): MethodCallExpression {
763+
prefixExpression: Expression,
764+
name: Identifier,
765+
params?: Expression[],
766+
parent?: Node,
767+
tsOriginal?: ts.Node
768+
): MethodCallExpression
769+
{
688770
const callExpression = createNode(SyntaxKind.MethodCallExpression, parent, tsOriginal) as MethodCallExpression;
689771
setParent(prefixExpression, callExpression);
690772
callExpression.prefixExpression = prefixExpression;

0 commit comments

Comments
 (0)