Skip to content

Commit d6215f2

Browse files
CppCXYCppCXY
committed
FIX #157 
1 parent 5cc4845 commit d6215f2

File tree

9 files changed

+108
-92
lines changed

9 files changed

+108
-92
lines changed

‎CodeFormatCore/include/CodeFormatCore/Config/LuaStyle.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -62,7 +62,7 @@ class LuaStyle {
6262

6363
bool space_before_closure_open_parenthesis = false;
6464

65-
FunctionSingleArgSpace space_before_function_call_single_arg = FunctionSingleArgSpace::Always;
65+
SpaceBeforeSingleArg space_before_function_call_single_arg;
6666

6767
bool space_before_open_square_bracket = false;
6868

‎CodeFormatCore/include/CodeFormatCore/Config/LuaStyleEnum.h‎

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -69,8 +69,7 @@ struct LineSpace {
6969
enum class FunctionSingleArgSpace {
7070
None,
7171
Always,// true
72-
OnlyTable,
73-
OnlyString
72+
Keep
7473
};
7574

7675
enum class AlignArrayTable {

‎CodeFormatCore/include/CodeFormatCore/Config/LuaStyleStruct.h‎

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -11,3 +11,13 @@ struct ContinuationIndent {
1111
in_table = value;
1212
}
1313
};
14+
15+
struct SpaceBeforeSingleArg {
16+
FunctionSingleArgSpace table = FunctionSingleArgSpace::Always;
17+
FunctionSingleArgSpace string = FunctionSingleArgSpace::Always;
18+
19+
void SetAll(FunctionSingleArgSpace value) {
20+
table = value;
21+
string = value;
22+
}
23+
};

‎CodeFormatCore/include/CodeFormatCore/Format/Analyzer/SpaceAnalyzer.h‎

Lines changed: 2 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -29,17 +29,8 @@ class SpaceAnalyzer : public FormatAnalyzer {
2929

3030
void SpaceIgnore(LuaSyntaxNode n);
3131

32+
void FunctionCallSingleArgSpace(FormatState &f, LuaSyntaxNode n, const LuaSyntaxTree &t);
3233
private:
33-
// workaround for mac 10.13
34-
struct OptionalInt {
35-
OptionalInt() : HasValue(false), Value(0) {}
36-
37-
explicit OptionalInt(std::size_t value) : HasValue(true), Value(value) {}
38-
39-
bool HasValue;
40-
std::size_t Value;
41-
};
42-
4334
// This is to ensure that the settings on the right take priority.
4435
struct SpaceData {
4536
SpaceData() : SpaceData(0) {}
@@ -50,7 +41,7 @@ class SpaceAnalyzer : public FormatAnalyzer {
5041
SpacePriority Priority;
5142
};
5243

53-
OptionalInt GetRightSpace(LuaSyntaxNode n) const;
44+
std::size_t GetRightSpace(LuaSyntaxNode n, bool& hasValue) const;
5445

5546
std::size_t ProcessSpace(LuaSyntaxNode left, LuaSyntaxNode right, const LuaSyntaxTree &t);
5647

‎CodeFormatCore/src/Config/LuaStyle.cpp‎

Lines changed: 28 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -155,13 +155,37 @@ void LuaStyle::Parse(std::map<std::string, std::string, std::less<>> &configMap)
155155
if (configMap.count("space_before_function_call_single_arg")) {
156156
auto &value = configMap.at("space_before_function_call_single_arg");
157157
if (value == "true" || value == "always") {
158-
space_before_function_call_single_arg = FunctionSingleArgSpace::Always;
158+
space_before_function_call_single_arg.SetAll(FunctionSingleArgSpace::Always);
159159
} else if (value == "only_string") {
160-
space_before_function_call_single_arg = FunctionSingleArgSpace::OnlyString;
160+
space_before_function_call_single_arg.string = FunctionSingleArgSpace::Always;
161+
space_before_function_call_single_arg.table = FunctionSingleArgSpace::None;
161162
} else if (value == "only_table") {
162-
space_before_function_call_single_arg = FunctionSingleArgSpace::OnlyTable;
163+
space_before_function_call_single_arg.string = FunctionSingleArgSpace::None;
164+
space_before_function_call_single_arg.table = FunctionSingleArgSpace::Always;
163165
} else if (value == "false" || value == "none") {
164-
space_before_function_call_single_arg = FunctionSingleArgSpace::None;
166+
space_before_function_call_single_arg.SetAll(FunctionSingleArgSpace::None);
167+
}
168+
}
169+
170+
if (configMap.count("space_before_function_call_single_arg.string")) {
171+
auto &value = configMap.at("space_before_function_call_single_arg.string");
172+
if (value == "true" || value == "always") {
173+
space_before_function_call_single_arg.string = FunctionSingleArgSpace::Always;
174+
} else if (value == "false" || value == "none") {
175+
space_before_function_call_single_arg.string = FunctionSingleArgSpace::None;
176+
} else if (value == "keep") {
177+
space_before_function_call_single_arg.string = FunctionSingleArgSpace::Keep;
178+
}
179+
}
180+
181+
if (configMap.count("space_before_function_call_single_arg.table")) {
182+
auto &value = configMap.at("space_before_function_call_single_arg.table");
183+
if (value == "true" || value == "always") {
184+
space_before_function_call_single_arg.table = FunctionSingleArgSpace::Always;
185+
} else if (value == "false" || value == "none") {
186+
space_before_function_call_single_arg.table = FunctionSingleArgSpace::None;
187+
} else if (value == "keep") {
188+
space_before_function_call_single_arg.table = FunctionSingleArgSpace::Keep;
165189
}
166190
}
167191

‎CodeFormatCore/src/Format/Analyzer/SpaceAnalyzer.cpp‎

Lines changed: 54 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -236,38 +236,7 @@ void SpaceAnalyzer::ComplexAnalyze(FormatState &f, const LuaSyntaxTree &t) {
236236
SpaceLeft(leftBrace, t, 1);
237237
}
238238
} else {
239-
switch (f.GetStyle().space_before_function_call_single_arg) {
240-
case FunctionSingleArgSpace::None: {
241-
SpaceLeft(syntaxNode, t, 0);
242-
break;
243-
}
244-
case FunctionSingleArgSpace::Always: {
245-
SpaceLeft(syntaxNode, t, 1);
246-
break;
247-
}
248-
case FunctionSingleArgSpace::OnlyString: {
249-
auto firstToken = syntaxNode.GetFirstToken(t);
250-
if (firstToken.GetTokenKind(t) == TK_STRING ||
251-
firstToken.GetTokenKind(t) == TK_LONG_STRING) {
252-
SpaceLeft(syntaxNode, t, 1);
253-
} else {
254-
SpaceLeft(syntaxNode, t, 0);
255-
}
256-
break;
257-
}
258-
case FunctionSingleArgSpace::OnlyTable: {
259-
auto firstChild = syntaxNode.GetFirstChild(t);
260-
if (firstChild.GetSyntaxKind(t) == LuaSyntaxNodeKind::TableExpression) {
261-
SpaceLeft(syntaxNode, t, 1);
262-
} else {
263-
SpaceLeft(syntaxNode, t, 0);
264-
}
265-
break;
266-
}
267-
default: {
268-
break;
269-
}
270-
}
239+
FunctionCallSingleArgSpace(f, syntaxNode, t);
271240
}
272241
break;
273242
}
@@ -443,23 +412,69 @@ void SpaceAnalyzer::SpaceIgnore(LuaSyntaxNode n) {
443412
_ignoreSpace.insert(n.GetIndex());
444413
}
445414

446-
SpaceAnalyzer::OptionalInt SpaceAnalyzer::GetRightSpace(LuaSyntaxNode n) const {
415+
void SpaceAnalyzer::FunctionCallSingleArgSpace(FormatState &f, LuaSyntaxNode n, const LuaSyntaxTree &t) {
416+
auto firstToken = n.GetFirstToken(t);
417+
if (firstToken.GetTokenKind(t) == TK_STRING ||
418+
firstToken.GetTokenKind(t) == TK_LONG_STRING) {
419+
switch (f.GetStyle().space_before_function_call_single_arg.string) {
420+
case FunctionSingleArgSpace::None: {
421+
SpaceLeft(n, t, 0);
422+
break;
423+
}
424+
case FunctionSingleArgSpace::Always: {
425+
SpaceLeft(n, t, 1);
426+
break;
427+
}
428+
case FunctionSingleArgSpace::Keep: {
429+
SpaceIgnore(n);
430+
break;
431+
}
432+
default: {
433+
break;
434+
}
435+
}
436+
} else {
437+
switch (f.GetStyle().space_before_function_call_single_arg.table) {
438+
case FunctionSingleArgSpace::None: {
439+
SpaceLeft(n, t, 0);
440+
break;
441+
}
442+
case FunctionSingleArgSpace::Always: {
443+
SpaceLeft(n, t, 1);
444+
break;
445+
}
446+
case FunctionSingleArgSpace::Keep: {
447+
SpaceIgnore(n);
448+
break;
449+
}
450+
default: {
451+
break;
452+
}
453+
}
454+
}
455+
}
456+
457+
std::size_t SpaceAnalyzer::GetRightSpace(LuaSyntaxNode n, bool &hasValue) const {
447458
if (_ignoreSpace.count(n.GetIndex())) {
448-
return OptionalInt();
459+
hasValue = false;
460+
return 0;
449461
}
450462

451463
auto it = _rightSpaces.find(n.GetIndex());
452464
if (it == _rightSpaces.end()) {
453-
return OptionalInt();
465+
hasValue = false;
466+
return 0;
454467
}
455-
return OptionalInt(it->second.Value);
468+
hasValue = true;
469+
return it->second.Value;
456470
}
457471

458472
std::size_t
459473
SpaceAnalyzer::ProcessSpace(LuaSyntaxNode left, LuaSyntaxNode right, const LuaSyntaxTree &t) {
460-
auto rightSpaceOfLeftToken = GetRightSpace(left);
461-
if (rightSpaceOfLeftToken.HasValue) {
462-
return rightSpaceOfLeftToken.Value;
474+
bool hasValue = true;
475+
auto rightSpaceOfLeftToken = GetRightSpace(left, hasValue);
476+
if (hasValue) {
477+
return rightSpaceOfLeftToken;
463478
}
464479
if (!right.IsNull(t)) {
465480
return t.GetStartOffset(right.GetIndex()) - t.GetEndOffset(left.GetIndex()) - 1;

‎CodeFormatCore/src/Format/Analyzer/TokenAnalyzer.cpp‎

Lines changed: 1 addition & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -264,37 +264,7 @@ void TokenAnalyzer::AnalyzeCallExpression(FormatState &f, LuaSyntaxNode &syntaxN
264264

265265
auto spaceAnalyzer = f.GetAnalyzer<SpaceAnalyzer>();
266266
if (spaceAnalyzer) {
267-
switch (f.GetStyle().space_before_function_call_single_arg) {
268-
case FunctionSingleArgSpace::None: {
269-
spaceAnalyzer->SpaceLeft(syntaxNode, t, 0);
270-
break;
271-
}
272-
case FunctionSingleArgSpace::Always: {
273-
spaceAnalyzer->SpaceLeft(syntaxNode, t, 1);
274-
break;
275-
}
276-
case FunctionSingleArgSpace::OnlyString: {
277-
auto firstToken = syntaxNode.GetFirstToken(t);
278-
if (firstToken.GetTokenKind(t) == TK_STRING || firstToken.GetTokenKind(t) == TK_LONG_STRING) {
279-
spaceAnalyzer->SpaceLeft(syntaxNode, t, 1);
280-
} else {
281-
spaceAnalyzer->SpaceLeft(syntaxNode, t, 0);
282-
}
283-
break;
284-
}
285-
case FunctionSingleArgSpace::OnlyTable: {
286-
auto firstChild = syntaxNode.GetFirstChild(t);
287-
if (firstChild.GetSyntaxKind(t) == LuaSyntaxNodeKind::TableExpression) {
288-
spaceAnalyzer->SpaceLeft(syntaxNode, t, 1);
289-
} else {
290-
spaceAnalyzer->SpaceLeft(syntaxNode, t, 0);
291-
}
292-
break;
293-
}
294-
default: {
295-
break;
296-
}
297-
}
267+
spaceAnalyzer->FunctionCallSingleArgSpace(f, syntaxNode, t);
298268
}
299269
}
300270
}

‎Test/src/FormatStyle_unitest.cpp‎

Lines changed: 6 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -559,7 +559,7 @@ end
559559
TEST(FormatByStyleOption, space_before_function_call_single_arg) {
560560
LuaStyle style;
561561

562-
style.space_before_function_call_single_arg = FunctionSingleArgSpace::Always;
562+
style.space_before_function_call_single_arg.SetAll(FunctionSingleArgSpace::Always);
563563
EXPECT_TRUE(TestHelper::TestFormatted(
564564
R"(
565565
local f = p { a = 123 }
@@ -570,7 +570,8 @@ local f = p { a = 123 }
570570
p "aaa"
571571
)",
572572
style));
573-
style.space_before_function_call_single_arg = FunctionSingleArgSpace::OnlyString;
573+
style.space_before_function_call_single_arg.string = FunctionSingleArgSpace::Always;
574+
style.space_before_function_call_single_arg.table = FunctionSingleArgSpace::None;
574575
EXPECT_TRUE(TestHelper::TestFormatted(
575576
R"(
576577
local f = p { a = 123 }
@@ -581,7 +582,8 @@ local f = p{ a = 123 }
581582
p "aaa"
582583
)",
583584
style));
584-
style.space_before_function_call_single_arg = FunctionSingleArgSpace::OnlyTable;
585+
style.space_before_function_call_single_arg.string = FunctionSingleArgSpace::None;
586+
style.space_before_function_call_single_arg.table = FunctionSingleArgSpace::Always;
585587
EXPECT_TRUE(TestHelper::TestFormatted(
586588
R"(
587589
local f = p { a = 123 }
@@ -592,7 +594,7 @@ local f = p { a = 123 }
592594
p"aaa"
593595
)",
594596
style));
595-
style.space_before_function_call_single_arg = FunctionSingleArgSpace::None;
597+
style.space_before_function_call_single_arg.SetAll(FunctionSingleArgSpace::None);
596598
EXPECT_TRUE(TestHelper::TestFormatted(
597599
R"(
598600
local f = p { a = 123 }

‎lua.template.editorconfig‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -54,6 +54,11 @@ space_before_closure_open_parenthesis = true
5454
# optional always/only_string/only_table/none
5555
# or true/false
5656
space_before_function_call_single_arg = always
57+
## extend option
58+
## always/keep/none
59+
# space_before_function_call_single_arg.table = always
60+
## always/keep/none
61+
# space_before_function_call_single_arg.string = always
5762

5863
space_before_open_square_bracket = false
5964

0 commit comments

Comments
 (0)