Fix error location for binary operations to point at operator instead of first operand (dlang#21253)

abulgit · web-flow · commit bc3c423fd780 · 2025-04-18T07:24:30.000+08:00
diff --git a/compiler/src/dmd/parse.d b/compiler/src/dmd/parse.d
@@ -9068,11 +9068,11 @@ class Parser(AST, Lexer = dmd.lexer.Lexer) : Lexer
 
     private AST.Expression parseMulExp()
     {
-        const loc = token.loc;
         auto e = parseUnaryExp();
 
         while (1)
         {
+            const loc = token.loc;
             switch (token.value)
             {
             case TOK.mul:
@@ -9103,11 +9103,11 @@ class Parser(AST, Lexer = dmd.lexer.Lexer) : Lexer
 
     private AST.Expression parseAddExp()
     {
-        const loc = token.loc;
         auto e = parseMulExp();
 
         while (1)
         {
+            const loc = token.loc;
             switch (token.value)
             {
             case TOK.add:
@@ -9138,11 +9138,11 @@ class Parser(AST, Lexer = dmd.lexer.Lexer) : Lexer
 
     private AST.Expression parseShiftExp()
     {
-        const loc = token.loc;
         auto e = parseAddExp();
 
         while (1)
         {
+            const loc = token.loc;
             switch (token.value)
             {
             case TOK.leftShift:
@@ -9173,10 +9173,9 @@ class Parser(AST, Lexer = dmd.lexer.Lexer) : Lexer
 
     private AST.Expression parseCmpExp()
     {
-        const loc = token.loc;
-
         auto e = parseShiftExp();
         EXP op = EXP.reserved;
+        const loc = token.loc;
 
         switch (token.value)
         {
@@ -9238,28 +9237,26 @@ class Parser(AST, Lexer = dmd.lexer.Lexer) : Lexer
 
     private AST.Expression parseAndExp()
     {
-        Loc loc = token.loc;
         auto e = parseCmpExp();
         while (token.value == TOK.and)
         {
             checkParens(TOK.and, e);
+            const loc = token.loc;
             nextToken();
             auto e2 = parseCmpExp();
             checkParens(TOK.and, e2);
             e = new AST.AndExp(loc, e, e2);
-            loc = token.loc;
         }
         return e;
     }
 
     private AST.Expression parseXorExp()
     {
-        const loc = token.loc;
-
         auto e = parseAndExp();
         while (token.value == TOK.xor)
         {
             checkParens(TOK.xor, e);
+            const loc = token.loc;
             nextToken();
             auto e2 = parseAndExp();
             checkParens(TOK.xor, e2);
@@ -9270,12 +9267,11 @@ class Parser(AST, Lexer = dmd.lexer.Lexer) : Lexer
 
     private AST.Expression parseOrExp()
     {
-        const loc = token.loc;
-
         auto e = parseXorExp();
         while (token.value == TOK.or)
         {
             checkParens(TOK.or, e);
+            const loc = token.loc;
             nextToken();
             auto e2 = parseXorExp();
             checkParens(TOK.or, e2);
@@ -9286,11 +9282,10 @@ class Parser(AST, Lexer = dmd.lexer.Lexer) : Lexer
 
     private AST.Expression parseAndAndExp()
     {
-        const loc = token.loc;
-
         auto e = parseOrExp();
         while (token.value == TOK.andAnd)
         {
+            const loc = token.loc;
             nextToken();
             auto e2 = parseOrExp();
             e = new AST.LogicalExp(loc, EXP.andAnd, e, e2);
@@ -9300,11 +9295,10 @@ class Parser(AST, Lexer = dmd.lexer.Lexer) : Lexer
 
     private AST.Expression parseOrOrExp()
     {
-        const loc = token.loc;
-
         auto e = parseAndAndExp();
         while (token.value == TOK.orOr)
         {
+            const loc = token.loc;
             nextToken();
             auto e2 = parseAndAndExp();
             e = new AST.LogicalExp(loc, EXP.orOr, e, e2);
@@ -9314,11 +9308,10 @@ class Parser(AST, Lexer = dmd.lexer.Lexer) : Lexer
 
     private AST.Expression parseCondExp()
     {
-        const loc = token.loc;
-
         auto e = parseOrOrExp();
         if (token.value == TOK.question)
         {
+            const loc = token.loc;
             nextToken();
             auto e1 = parseExpression();
             check(TOK.colon);
diff --git a/compiler/test/fail_compilation/fail196.d b/compiler/test/fail_compilation/fail196.d
@@ -21,7 +21,7 @@ fail_compilation/fail196.d(44):        expression: `";\n    assert(s == "`
 fail_compilation/fail196.d(45): Error: found `}` when expecting `;` following expression
 fail_compilation/fail196.d(45):        expression: `xxx`
 fail_compilation/fail196.d(47): Error: found `<` when expecting `;` following expression
-fail_compilation/fail196.d(45):        expression: `");\n\n    s = q" < foo`
+fail_compilation/fail196.d(47):        expression: `");\n\n    s = q" < foo`
 fail_compilation/fail196.d(48): Error: found `foo` when expecting `;` following expression
 fail_compilation/fail196.d(47):        expression: `xxx >> ";\n    assert(s == "`
 fail_compilation/fail196.d(48): Error: found `<` instead of statement
diff --git a/compiler/test/fail_compilation/fail_pretty_errors.d b/compiler/test/fail_compilation/fail_pretty_errors.d
@@ -16,7 +16,7 @@ fail_compilation/fail_pretty_errors.d(44): Error: mixin `fail_pretty_errors.test
     ^
 fail_compilation/fail_pretty_errors.d(50): Error: invalid array operation `"" + ""` (possible missing [])
     auto x = ""+"";
-             ^
+               ^
 fail_compilation/fail_pretty_errors.d(50):        did you mean to concatenate (`"" ~ ""`) instead ?
 fail_compilation/fail_pretty_errors.d(53): Error: cannot implicitly convert expression `1111` of type `int` to `byte`
         byte ɑ =    1111;
diff --git a/compiler/test/fail_compilation/fix21166.d b/compiler/test/fail_compilation/fix21166.d
@@ -0,0 +1,13 @@
+/*
+TEST_OUTPUT:
+---
+fail_compilation/fix21166.d(12): Error: invalid array operation `"foo" + "bar"` (possible missing [])
+fail_compilation/fix21166.d(12):        did you mean to concatenate (`"foo" ~ "bar"`) instead ?
+---
+*/
+
+// Test case for https://github.com/dlang/dmd/issues/21166
+auto r =
+	"foo"
+	+
+	"bar";

Original file line number	Diff line number	Diff line change
`@@ -9068,11 +9068,11 @@ class Parser(AST, Lexer = dmd.lexer.Lexer) : Lexer`
`9068`	`9068`
`9069`	`9069`	`private AST.Expression parseMulExp()`
`9070`	`9070`	`{`
`9071`		`- const loc = token.loc;`
`9072`	`9071`	`auto e = parseUnaryExp();`
`9073`	`9072`
`9074`	`9073`	`while (1)`
`9075`	`9074`	`{`
	`9075`	`+ const loc = token.loc;`
`9076`	`9076`	`switch (token.value)`
`9077`	`9077`	`{`
`9078`	`9078`	`case TOK.mul:`
`@@ -9103,11 +9103,11 @@ class Parser(AST, Lexer = dmd.lexer.Lexer) : Lexer`
`9103`	`9103`
`9104`	`9104`	`private AST.Expression parseAddExp()`
`9105`	`9105`	`{`
`9106`		`- const loc = token.loc;`
`9107`	`9106`	`auto e = parseMulExp();`
`9108`	`9107`
`9109`	`9108`	`while (1)`
`9110`	`9109`	`{`
	`9110`	`+ const loc = token.loc;`
`9111`	`9111`	`switch (token.value)`
`9112`	`9112`	`{`
`9113`	`9113`	`case TOK.add:`
`@@ -9138,11 +9138,11 @@ class Parser(AST, Lexer = dmd.lexer.Lexer) : Lexer`
`9138`	`9138`
`9139`	`9139`	`private AST.Expression parseShiftExp()`
`9140`	`9140`	`{`
`9141`		`- const loc = token.loc;`
`9142`	`9141`	`auto e = parseAddExp();`
`9143`	`9142`
`9144`	`9143`	`while (1)`
`9145`	`9144`	`{`
	`9145`	`+ const loc = token.loc;`
`9146`	`9146`	`switch (token.value)`
`9147`	`9147`	`{`
`9148`	`9148`	`case TOK.leftShift:`
`@@ -9173,10 +9173,9 @@ class Parser(AST, Lexer = dmd.lexer.Lexer) : Lexer`
`9173`	`9173`
`9174`	`9174`	`private AST.Expression parseCmpExp()`
`9175`	`9175`	`{`
`9176`		`- const loc = token.loc;`
`9177`		`-`
`9178`	`9176`	`auto e = parseShiftExp();`
`9179`	`9177`	`EXP op = EXP.reserved;`
	`9178`	`+ const loc = token.loc;`
`9180`	`9179`
`9181`	`9180`	`switch (token.value)`
`9182`	`9181`	`{`
`@@ -9238,28 +9237,26 @@ class Parser(AST, Lexer = dmd.lexer.Lexer) : Lexer`
`9238`	`9237`
`9239`	`9238`	`private AST.Expression parseAndExp()`
`9240`	`9239`	`{`
`9241`		`- Loc loc = token.loc;`
`9242`	`9240`	`auto e = parseCmpExp();`
`9243`	`9241`	`while (token.value == TOK.and)`
`9244`	`9242`	`{`
`9245`	`9243`	`checkParens(TOK.and, e);`
	`9244`	`+ const loc = token.loc;`
`9246`	`9245`	`nextToken();`
`9247`	`9246`	`auto e2 = parseCmpExp();`
`9248`	`9247`	`checkParens(TOK.and, e2);`
`9249`	`9248`	`e = new AST.AndExp(loc, e, e2);`
`9250`		`- loc = token.loc;`
`9251`	`9249`	`}`
`9252`	`9250`	`return e;`
`9253`	`9251`	`}`
`9254`	`9252`
`9255`	`9253`	`private AST.Expression parseXorExp()`
`9256`	`9254`	`{`
`9257`		`- const loc = token.loc;`
`9258`		`-`
`9259`	`9255`	`auto e = parseAndExp();`
`9260`	`9256`	`while (token.value == TOK.xor)`
`9261`	`9257`	`{`
`9262`	`9258`	`checkParens(TOK.xor, e);`
	`9259`	`+ const loc = token.loc;`
`9263`	`9260`	`nextToken();`
`9264`	`9261`	`auto e2 = parseAndExp();`
`9265`	`9262`	`checkParens(TOK.xor, e2);`
`@@ -9270,12 +9267,11 @@ class Parser(AST, Lexer = dmd.lexer.Lexer) : Lexer`
`9270`	`9267`
`9271`	`9268`	`private AST.Expression parseOrExp()`
`9272`	`9269`	`{`
`9273`		`- const loc = token.loc;`
`9274`		`-`
`9275`	`9270`	`auto e = parseXorExp();`
`9276`	`9271`	`while (token.value == TOK.or)`
`9277`	`9272`	`{`
`9278`	`9273`	`checkParens(TOK.or, e);`
	`9274`	`+ const loc = token.loc;`
`9279`	`9275`	`nextToken();`
`9280`	`9276`	`auto e2 = parseXorExp();`
`9281`	`9277`	`checkParens(TOK.or, e2);`
`@@ -9286,11 +9282,10 @@ class Parser(AST, Lexer = dmd.lexer.Lexer) : Lexer`
`9286`	`9282`
`9287`	`9283`	`private AST.Expression parseAndAndExp()`
`9288`	`9284`	`{`
`9289`		`- const loc = token.loc;`
`9290`		`-`
`9291`	`9285`	`auto e = parseOrExp();`
`9292`	`9286`	`while (token.value == TOK.andAnd)`
`9293`	`9287`	`{`
	`9288`	`+ const loc = token.loc;`
`9294`	`9289`	`nextToken();`
`9295`	`9290`	`auto e2 = parseOrExp();`
`9296`	`9291`	`e = new AST.LogicalExp(loc, EXP.andAnd, e, e2);`
`@@ -9300,11 +9295,10 @@ class Parser(AST, Lexer = dmd.lexer.Lexer) : Lexer`
`9300`	`9295`
`9301`	`9296`	`private AST.Expression parseOrOrExp()`
`9302`	`9297`	`{`
`9303`		`- const loc = token.loc;`
`9304`		`-`
`9305`	`9298`	`auto e = parseAndAndExp();`
`9306`	`9299`	`while (token.value == TOK.orOr)`
`9307`	`9300`	`{`
	`9301`	`+ const loc = token.loc;`
`9308`	`9302`	`nextToken();`
`9309`	`9303`	`auto e2 = parseAndAndExp();`
`9310`	`9304`	`e = new AST.LogicalExp(loc, EXP.orOr, e, e2);`
`@@ -9314,11 +9308,10 @@ class Parser(AST, Lexer = dmd.lexer.Lexer) : Lexer`
`9314`	`9308`
`9315`	`9309`	`private AST.Expression parseCondExp()`
`9316`	`9310`	`{`
`9317`		`- const loc = token.loc;`
`9318`		`-`
`9319`	`9311`	`auto e = parseOrOrExp();`
`9320`	`9312`	`if (token.value == TOK.question)`
`9321`	`9313`	`{`
	`9314`	`+ const loc = token.loc;`
`9322`	`9315`	`nextToken();`
`9323`	`9316`	`auto e1 = parseExpression();`
`9324`	`9317`	`check(TOK.colon);`
Original file line number	Diff line number	Diff line change
@@ -16,7 +16,7 @@ fail_compilation/fail_pretty_errors.d(44): Error: mixin `fail_pretty_errors.test
`16`	`16`	`^`
`17`	`17`	fail_compilation/fail_pretty_errors.d(50): Error: invalid array operation `"" + ""` (possible missing [])
`18`	`18`	`auto x = ""+"";`
`19`		`- ^`
	`19`	`+ ^`
`20`	`20`	fail_compilation/fail_pretty_errors.d(50): did you mean to concatenate (`"" ~ ""`) instead ?
`21`	`21`	fail_compilation/fail_pretty_errors.d(53): Error: cannot implicitly convert expression `1111` of type `int` to `byte`
`22`	`22`	`byte ɑ = 1111;`