[clang-format] Add space in placement new expression

[omarahmed]

Summary

Add AfterPlacementNew option to SpaceBeforeParensOptions to have more control on placement new expressions.

Fixes https://github.com/llvm/llvm-project/issues/41501
Relates to https://github.com/llvm/llvm-project/issues/54703

[curdeius]

Apart from some missing tests, looks promising!

clang/unittests/Format/FormatTest.cpp

16415–16425

Are there any tests with AfterPlacementNew = false;? Could you add those please?

[HazardyKnusperkeks]

clang/include/clang/Format/Format.h

4128

Please sort after AfterOver... here and all other occasions.

clang/lib/Format/Format.cpp

1568

This isn't needed, because the default CTor initializes it with true.
Or you change that, I don't know right now why all other attributes are initialized with false.

clang/unittests/Format/FormatTest.cpp

16417

Assert on that.

[MyDeveloperDay]

Thank you for the patch, was there a github issue for this? Can we just validate that those requirements are covered here too while we are at it?

https://github.com/llvm/llvm-project/issues/54703
https://github.com/llvm/llvm-project/issues/41501 ( I know this is yours, but ensure you mention it in the summary!) so the commit gets tied to the review

I'll agree with @curdeius I think this looks on the right lines (thank you for doing the rst, so many of us forget to do that normally!) .. I don't have a problem with adding something like this I think it will help give people fine control

clang/lib/Format/TokenAnnotator.cpp

4239

what case is covered here by spaceRequiredBeforeParens(Right)?

clang/unittests/Format/FormatTest.cpp

16415

you should probably give yourself your own test, for SpacePlacementNew

[MyDeveloperDay]

clang/include/clang/Format/Format.h

4128

For new options they tend to go through a live cycle bool->Enum->Structure...

can I as we start with an enum not a bool and do something like Always,None,Leave so Leave will just leave the code completely as it is today..

We get a lot of criticism for changing the defaults, often we are not changing them we are fixing things or now we format where we never did before.

I think it helps (as a concession to those who want us to NEVER change anything), if new options can have a Leave option so people don't get one or the other it just leaves the code neither formatted with a space or without a space, but doing what clang-format did before.

i.e. in the past we've been asked to be able to turn off/on individual styles. by ensuring we always have a "Leave" option we can guard the changes and in theory not introduce a change in people current formatting when using a later binary.

4185–4187

swap

4196

move down one P comes after O AfterO -> AfterP

clang/lib/Format/Format.cpp

1144

move down one line

[omarahmed]

clang/lib/Format/Format.cpp

1568

I think they are initialized with false so that when we come to this case, it breaks while all of them are false. (I am not sure so) I will try to add a test to cover 'SBPO_Never' but after converting it to enum.

clang/lib/Format/TokenAnnotator.cpp

4239

I intended to cover this case: new (buf) T so basically placement new expressions, excluding the overloaded new operator function declarations/definitions like T *operator new(size_t size) {} and excluding function declarations/definitions named new like T *new();

clang/unittests/Format/FormatTest.cpp

16415

I was thinking of covering placement delete too and adding the tests for this patch to this test as it should add more cases to new/delete operators.

[HazardyKnusperkeks]

clang/lib/Format/Format.cpp

1568

Then you need to set it to false in the CTor.

[curdeius]

Does this patch really fix https://github.com/llvm/llvm-project/issues/54703?
If so, please add test for it. Otherwise remove the link from the summary (and if possible handle it in another review).

[omarahmed]

Add coverage for placement delete expressions and transform bool option to enum

[omarahmed]

In D127270#3584200, @curdeius wrote:

Does this patch really fix https://github.com/llvm/llvm-project/issues/54703?
If so, please add test for it. Otherwise remove the link from the summary (and if possible handle it in another review).

It should cover this case too, I have added a test to verify that it covers it.

[MyDeveloperDay]

I think you are missing a PARSE unit test

clang/docs/ClangFormatStyleOptions.rst

5227

Are you making this by hand or by running tools/docs/dump_format_style.py?

[MyDeveloperDay]

clang/include/clang/Format/Format.h

4125

should this be Always/Never

clang/lib/Format/Format.cpp

1144

when you've fixed the code please mark the comment "done.."

clang/lib/Format/TokenAnnotator.cpp

4236

shouldn't the very first part of this be?

if (Style.SpaceBeforeParensOptions.AfterPlacementOperator != FormatStyle::SpaceBeforeParensCustom::APO_Leave)
{

....

}

i.e. don't we want a zero change if someone says "Leave"

[HazardyKnusperkeks]

clang/include/clang/Format/Format.h

4125

Nope, this should be removed. :)

4185–4187

As said in the other comment, there is code that depends on setting to never in the default constructor, so please do.

clang/unittests/Format/FormatTest.cpp

11198

Can this be valid code?

[omarahmed]

clang/docs/ClangFormatStyleOptions.rst

5227

I was doing it manually, as I didn't know there is a script that does that. I tried using the script but seems like it has a parsing error with this logic as it is the first time to use enum inside a struct in format.h file. So it seems that the parsing logic for this case needs to be added. I will try adding this parsing case to dump_format_style.py and add it to my next update for this patch.

[omarahmed]

Refactor the tests and add new parsing logic for nested enums in dump_format_style.py

[omarahmed]

As I understand, the default behavior for when the user didn't use SBPO_Custom is to add a space in placement operators based on this issue. And, at the same time, the default behavior should be APO_Never when we have SBPO_Custom so that we handle other code that depends on that. the existing tests confirm this understanding. So, the current logic was added based on this understanding.

clang/lib/Format/TokenAnnotator.cpp

4236

The current code logic, when we do not enter this suggested condition, will switch to this condition. And will not leave the code as it is, but will change it.

I have thought of getting rid of this condition entirely, but it handles the default situation suggested here, not only for cpp but for other languages like js:

As I understand, the default behavior for when the user didn't use SBPO_Custom is to add a space in placement operators based on this issue. And, at the same time, the default behavior should be APO_Never when we have SBPO_Custom so that we handle other code that depends on that. the existing tests confirm this understanding. So, the current logic was added based on this understanding.

I tried to add an extra condition to this condition to support the main logic that we are pursuing. so that it would be like that:

if (Style.SpaceBeforeParensOptions.AfterPlacementOperator != FormatStyle::SpaceBeforeParensCustom::APO_Leave && Left.isOneOf(tok::kw_new, tok::kw_delete))

But that wouldn't fix the leave situation, as it will be also at the end, reach this part which will

return false

and force no space.

I think all of that was raised because all current "SpaceBeforeParanthesesOptions" are either true or false and this is the only enum

However, I completely agree with this logic which is to begin our checking for leave. But I think we should refactor all the "spaceBeforeParenthesesOptions" conditions to handle this and do that after all the options have been transformed to enums.

[omarahmed]

Add Parse check

[HazardyKnusperkeks]

Nice work adding the capability to the dump script.

clang/docs/ClangFormatStyleOptions.rst

5230

This seems to be not entirely correct yet. :)

clang/include/clang/Format/Format.h

4134

clang/lib/Format/TokenAnnotator.cpp

4236

SpaceBeforeParensOptions should always be expanded, regardless of SpaceBeforeParens, as far as I remember. SpaceBeforeParens is only for the one configuring clang-format, the code that formats should always and only check SpaceBeforeParensOptions.

clang/unittests/Format/FormatTest.cpp

11201

Can this be valid code? If not we don't need to assert on how it is formatted, only that it doesn't crash.

[MyDeveloperDay]

clang/docs/tools/dump_format_style.py

234

Can you show us a screenshot of how these changes will look in HTML?

[omarahmed]

• Add version for nestedEnums and nestedFields
• Make tests valid

clang/docs/tools/dump_format_style.py

234

[omarahmed]

clang/lib/Format/TokenAnnotator.cpp

4236

But in general, doesn't that could create some kind of conflict like if someone used a specific option in SpaceBeforeParens and then defined inside SpaceBeforeParensOptions some rules that could conflict with SpaceBeforeParens , what should be the priority between them?

4236

In this specific case, for AfterPlacementOperator if someone doesn't define it, it should keep the default behavior in the past which is to add a space, and we defined the default to be APO_Never, so that's why I have conditioned it with Custom so that if someone doesn't want to define it, then we keep the old behavior.

[MyDeveloperDay]

Thanks for the Screenshot, please remember to mark your comments as "Done" once you've addressed them. From what I can tell this looks good.

clang/include/clang/Format/Format.h

4185–4187

Why Never and not Leave? basically introducing one or the other as a default won't that causes changes for people who don't want to use this?

[omarahmed]

Change the default to APO_Leave

[omarahmed]

clang/include/clang/Format/Format.h

4185–4187

I think that's a good point. I changed that to APO_Leave and added APO_Never to the code that depends on it.

I was guarding the default behavior with SpaceBeforeParentheses: Custom condition but I think still if someone defined it to be custom and didn't specify this option, it should still be leave.

clang/lib/Format/Format.cpp

1389

The part that depends on it to be APO_Never to align with SBPO_Never option.

[omarahmed]

Format files

[HazardyKnusperkeks]

clang/include/clang/Format/Format.h

4185–4187

We change the behavior here, I'm still not convinced we should do that. Although I'm a big supporter of the Leave option.

[omarahmed]

Format files

[omarahmed]

I don't have push credentials so If everything is okay with the patch, can you push it for me. My email is [e-mail]

clang/include/clang/Format/Format.h

4185–4187

I am neutral to both cases, so I leave the choice to you as I am not experienced with clang-format users. Let me know which choice you think would be better.

[curdeius]

clang/include/clang/Format/Format.h

4134

We have verbs: removes, add, leave. Si I think it should be "remove" here.

[omarahmed]

Change removes to remove

[owenpan]

clang/include/clang/Format/Format.h

4185–4187

We change the behavior here, I'm still not convinced we should do that. Although I'm a big supporter of the Leave option.

@HazardyKnusperkeks should we merge this patch as is?

clang/docs/ClangFormatStyleOptions.rst

* ``bool AfterOverloadedOperator`` If ``true``, put a space between operator overloading and opening
     parentheses.
 
     .. code-block:: c++
 
        true:                                  false:
        void operator++ (int a);        vs.    void operator++(int a);
        object.operator++ (10);                object.operator++(10);
 
+  * ``AfterPlacementOperatorStyle AfterPlacementOperator`` :versionbadge:`clang-format 18`
+
+    Defines in which cases to put a space between ``new/delete`` operators
+    and opening parentheses.
+
+    Possible values:
+
+    * ``APO_Never`` (in configuration: ``Never``)
+      Remove space after ``new/delete`` operators and before ``(``.
+
+      .. code-block:: c++
+
+         new(buf) T;
+         delete(buf) T;
+
+    * ``APO_Always`` (in configuration: ``Always``)
+      Always add space after ``new/delete`` operators and before ``(``.
+
+      .. code-block:: c++
+
+         new (buf) T;
+         delete (buf) T;
+
+    * ``APO_Leave`` (in configuration: ``Leave``)
+      Leave placement ``new/delete`` expressions as they are.
+
+
   * ``bool AfterRequiresInClause`` If ``true``, put space between requires keyword in a requires clause and
     opening parentheses, if there is one.
 
     .. code-block:: c++
 
        true:                                  false:
        template<typename T>            vs.    template<typename T>
        requires (A<T> && B<T>)                requires(A<T> && B<T>)

clang/docs/tools/dump_format_style.py

def __init__(self, name, comment):
         self.comment = comment.strip()
         self.values = []
 
     def __str__(self):
         return self.comment + "\n" + "\n".join(map(str, self.values))
 
 
 class NestedField(object):
-    def __init__(self, name, comment):
+    def __init__(self, name, comment, version):
         self.name = name
         self.comment = comment.strip()
+        self.version = version
 
     def __str__(self):
+        if self.version:
+            return "\n* ``%s`` :versionbadge:`clang-format %s`\n%s" % (
+                self.name,
+                self.version,
+                doxygen2rst(indent(self.comment, 2, indent_first_line=False)),
+            )
         return "\n* ``%s`` %s" % (
             self.name,
             doxygen2rst(indent(self.comment, 2, indent_first_line=False)),
         )
 
 
 class Enum(object):
     def __init__(self, name, comment):
         self.name = name
         self.comment = comment.strip()
         self.values = []
 
     def __str__(self):
         return "\n".join(map(str, self.values))
 
 
 class NestedEnum(object):
-    def __init__(self, name, enumtype, comment, values):
+    def __init__(self, name, enumtype, comment, version, values):
         self.name = name
         self.comment = comment
         self.values = values
         self.type = enumtype
+        self.version = version
 
     def __str__(self):
+        s = ""
+        if self.version:
+            s = "\n* ``%s %s`` :versionbadge:`clang-format %s`\n\n%s" % (
+                to_yaml_type(self.type),
+                self.name,
+                self.version,
+                doxygen2rst(indent(self.comment, 2)),
+            )
+        else:
             s = "\n* ``%s %s``\n%s" % (
                 to_yaml_type(self.type),
                 self.name,
                 doxygen2rst(indent(self.comment, 2)),
             )
         s += indent("\nPossible values:\n\n", 2)
         s += indent("\n".join(map(str, self.values)), 2)
         return s
 
 
 class EnumValue(object):
     def __init__(self, name, comment, config):
         self.name = name
class OptionsReader:
 
     def __print_line(self, line: str):
         print(f"{self.lineno:>6} | {line}", file=sys.stderr)
 
     def __warning(self, msg: str, line: str):
         print(f"{self.__file_path()}:{self.lineno}: warning: {msg}:", file=sys.stderr)
         self.__print_line(line)
 
     def __clean_comment_line(self, line: str):
         match = re.match(r"^/// (?P<indent> +)?\\code(\{.(?P<lang>\w+)\})?$", line)
         if match:
             if self.in_code_block:
                 self.__warning("`\\code` in another `\\code`", line)
             self.in_code_block = True
             indent_str = match.group("indent")
             if not indent_str:
                 indent_str = ""
def read_options(self):
                 BeforeStruct,
                 Finished,
                 InStruct,
                 InNestedStruct,
                 InNestedFieldComment,
                 InFieldComment,
                 InEnum,
                 InEnumMemberComment,
-            ) = range(8)
+                InNestedEnum,
+                InNestedEnumMemberComment,
+            ) = range(10)
 
         state = State.BeforeStruct
 
         options = []
         enums = {}
         nested_structs = {}
         comment = ""
         enum = None
def read_options(self):
             elif state == State.InNestedStruct:
                 if line.startswith("///"):
                     state = State.InNestedFieldComment
                     comment = self.__clean_comment_line(line)
                 elif line == "};":
                     state = State.InStruct
                     nested_structs[nested_struct.name] = nested_struct
             elif state == State.InNestedFieldComment:
-                if line.startswith("///"):
+                if line.startswith(r"/// \version"):
+                    match = re.match(r"/// \\version\s*(?P<version>[0-9.]+)*", line)
+                    if match:
+                        version = match.group("version")
+                elif line.startswith("///"):
                     comment += self.__clean_comment_line(line)
+                elif line.startswith("enum"):
+                    state = State.InNestedEnum
+                    name = re.sub(r"enum\s+(\w+)\s*(:((\s*\w+)+)\s*)?\{", "\\1", line)
+                    enum = Enum(name, comment)
                 else:
                     state = State.InNestedStruct
                     field_type, field_name = re.match(
                         r"([<>:\w(,\s)]+)\s+(\w+);", line
                     ).groups()
+                    # if not version:
+                    #    self.__warning(f"missing version for {field_name}", line)
                     if field_type in enums:
                         nested_struct.values.append(
                             NestedEnum(
                                 field_name,
                                 field_type,
                                 comment,
+                                version,
                                 enums[field_type].values,
                             )
                         )
                     else:
                         nested_struct.values.append(
-                            NestedField(field_type + " " + field_name, comment)
+                            NestedField(field_type + " " + field_name, comment, version)
                         )
-
+                    version = None
             elif state == State.InEnum:
                 if line.startswith("///"):
                     state = State.InEnumMemberComment
                     comment = self.__clean_comment_line(line)
                 elif line == "};":
                     state = State.InStruct
                     enums[enum.name] = enum
                 else:
                     # Enum member without documentation. Must be documented where the enum
                     # is used.
                     pass
+            elif state == State.InNestedEnum:
+                if line.startswith("///"):
+                    state = State.InNestedEnumMemberComment
+                    comment = self.__clean_comment_line(line)
+                elif line == "};":
+                    state = State.InNestedStruct
+                    enums[enum.name] = enum
+                else:
+                    # Enum member without documentation. Must be
+                    # documented where the enum is used.
+                    pass
             elif state == State.InEnumMemberComment:
                 if line.startswith("///"):
                     comment += self.__clean_comment_line(line)
                 else:
                     state = State.InEnum
                     val = line.replace(",", "")
                     pos = val.find(" // ")
                     if pos != -1:
                         config = val[pos + 4 :]
                         val = val[:pos]
                     else:
                         config = val
                     enum.values.append(EnumValue(val, comment, config))
+            elif state == State.InNestedEnumMemberComment:
+                if line.startswith("///"):
+                    comment += self.__clean_comment_line(line)
+                else:
+                    state = State.InNestedEnum
+                    val = line.replace(",", "")
+                    pos = val.find(" // ")
+                    if pos != -1:
+                        config = val[pos + 4 :]
+                        val = val[:pos]
+                    else:
+                        config = val
+                    enum.values.append(EnumValue(val, comment, config))
         if state != State.Finished:
             raise Exception("Not finished by the end of file")
 
         for option in options:
             if option.type not in [
                 "bool",
                 "unsigned",
                 "int",

clang/include/clang/Format/Format.h

struct SpaceBeforeParensCustom {
     /// \code
     ///    true:                                  false:
     ///    IF (...)                        vs.    IF(...)
     ///      <conditional-body>                     <conditional-body>
     /// \endcode
     bool AfterIfMacros;
     /// If ``true``, put a space between operator overloading and opening
     /// parentheses.
     /// \code
     ///    true:                                  false:
     ///    void operator++ (int a);        vs.    void operator++(int a);
     ///    object.operator++ (10);                object.operator++(10);
     /// \endcode
     bool AfterOverloadedOperator;
+    /// Styles for adding spacing between ``new/delete`` operators and opening
+    /// parentheses.
+    enum AfterPlacementOperatorStyle : int8_t {
+      /// Remove space after ``new/delete`` operators and before ``(``.
+      /// \code
+      ///    new(buf) T;
+      ///    delete(buf) T;
+      /// \endcode
+      APO_Never,
+      /// Always add space after ``new/delete`` operators and before ``(``.
+      /// \code
+      ///    new (buf) T;
+      ///    delete (buf) T;
+      /// \endcode
+      APO_Always,
+      /// Leave placement ``new/delete`` expressions as they are.
+      APO_Leave,
+    };
+    /// Defines in which cases to put a space between ``new/delete`` operators
+    /// and opening parentheses.
+    /// \version 18
+    AfterPlacementOperatorStyle AfterPlacementOperator;
     /// If ``true``, put space between requires keyword in a requires clause and
     /// opening parentheses, if there is one.
     /// \code
     ///    true:                                  false:
     ///    template<typename T>            vs.    template<typename T>
     ///    requires (A<T> && B<T>)                requires(A<T> && B<T>)
     ///    ...                                    ...
     /// \endcode
struct SpaceBeforeParensCustom {
     ///    f (a);                                 f();
     /// \endcode
     bool BeforeNonEmptyParentheses;
 
     SpaceBeforeParensCustom()
         : AfterControlStatements(false), AfterForeachMacros(false),
           AfterFunctionDeclarationName(false),
           AfterFunctionDefinitionName(false), AfterIfMacros(false),
-          AfterOverloadedOperator(false), AfterRequiresInClause(false),
-          AfterRequiresInExpression(false), BeforeNonEmptyParentheses(false) {}
+          AfterOverloadedOperator(false), AfterPlacementOperator(APO_Leave),
+          AfterRequiresInClause(false), AfterRequiresInExpression(false),
+          BeforeNonEmptyParentheses(false) {}
 
     bool operator==(const SpaceBeforeParensCustom &Other) const {
       return AfterControlStatements == Other.AfterControlStatements &&
              AfterForeachMacros == Other.AfterForeachMacros &&
              AfterFunctionDeclarationName ==
                  Other.AfterFunctionDeclarationName &&
              AfterFunctionDefinitionName == Other.AfterFunctionDefinitionName &&
              AfterIfMacros == Other.AfterIfMacros &&
              AfterOverloadedOperator == Other.AfterOverloadedOperator &&
+             AfterPlacementOperator == Other.AfterPlacementOperator &&
              AfterRequiresInClause == Other.AfterRequiresInClause &&
              AfterRequiresInExpression == Other.AfterRequiresInExpression &&
              BeforeNonEmptyParentheses == Other.BeforeNonEmptyParentheses;
     }
   };
 
   /// Control of individual space before parentheses.
   ///

clang/lib/Format/Format.cpp

struct ScalarEnumerationTraits<FormatStyle::QualifierAlignmentStyle> {
   static void enumeration(IO &IO, FormatStyle::QualifierAlignmentStyle &Value) {
     IO.enumCase(Value, "Leave", FormatStyle::QAS_Leave);
     IO.enumCase(Value, "Left", FormatStyle::QAS_Left);
     IO.enumCase(Value, "Right", FormatStyle::QAS_Right);
     IO.enumCase(Value, "Custom", FormatStyle::QAS_Custom);
   }
 };
 
+template <>
+struct MappingTraits<
+    FormatStyle::SpaceBeforeParensCustom::AfterPlacementOperatorStyle> {
+  static void
+  mapping(IO &IO,
+          FormatStyle::SpaceBeforeParensCustom::AfterPlacementOperatorStyle
+              &Value) {
+    IO.enumCase(Value, "Always",
+                FormatStyle::SpaceBeforeParensCustom::APO_Always);
+    IO.enumCase(Value, "Never",
+                FormatStyle::SpaceBeforeParensCustom::APO_Never);
+    IO.enumCase(Value, "Leave",
+                FormatStyle::SpaceBeforeParensCustom::APO_Leave);
+  }
+};
+
 template <> struct MappingTraits<FormatStyle::RawStringFormat> {
   static void mapping(IO &IO, FormatStyle::RawStringFormat &Format) {
     IO.mapOptional("Language", Format.Language);
     IO.mapOptional("Delimiters", Format.Delimiters);
     IO.mapOptional("EnclosingFunctions", Format.EnclosingFunctions);
     IO.mapOptional("CanonicalDelimiter", Format.CanonicalDelimiter);
     IO.mapOptional("BasedOnStyle", Format.BasedOnStyle);
   }
static void mapping(IO &IO, FormatStyle::SpaceBeforeParensCustom &Spacing) {
     IO.mapOptional("AfterControlStatements", Spacing.AfterControlStatements);
     IO.mapOptional("AfterForeachMacros", Spacing.AfterForeachMacros);
     IO.mapOptional("AfterFunctionDefinitionName",
                    Spacing.AfterFunctionDefinitionName);
     IO.mapOptional("AfterFunctionDeclarationName",
                    Spacing.AfterFunctionDeclarationName);
     IO.mapOptional("AfterIfMacros", Spacing.AfterIfMacros);
     IO.mapOptional("AfterOverloadedOperator", Spacing.AfterOverloadedOperator);
+    IO.mapOptional("AfterPlacementOperator", Spacing.AfterPlacementOperator);
     IO.mapOptional("AfterRequiresInClause", Spacing.AfterRequiresInClause);
     IO.mapOptional("AfterRequiresInExpression",
                    Spacing.AfterRequiresInExpression);
     IO.mapOptional("BeforeNonEmptyParentheses",
                    Spacing.BeforeNonEmptyParentheses);
   }
 };
 
if (Style.AlwaysBreakAfterDefinitionReturnType != FormatStyle::DRTBS_None &&
         Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
       } else if (Style.AlwaysBreakAfterDefinitionReturnType ==
                  FormatStyle::DRTBS_TopLevel) {
         Style.AlwaysBreakAfterReturnType =
             FormatStyle::RTBS_TopLevelDefinitions;
       }
     }
 
     // If BreakBeforeInheritanceComma was specified but BreakInheritance was
     // not, initialize the latter from the former for backwards compatibility.
     if (BreakBeforeInheritanceComma &&
         Style.BreakInheritanceList == FormatStyle::BILS_BeforeColon) {
       Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
     }
 
     // If BreakConstructorInitializersBeforeComma was specified but
     // BreakConstructorInitializers was not, initialize the latter from the

 static void expandPresetsSpaceBeforeParens(FormatStyle &Expanded) {
   if (Expanded.SpaceBeforeParens == FormatStyle::SBPO_Custom)
     return;
   // Reset all flags
   Expanded.SpaceBeforeParensOptions = {};
 
   switch (Expanded.SpaceBeforeParens) {
   case FormatStyle::SBPO_Never:
+    Expanded.SpaceBeforeParensOptions.AfterPlacementOperator =
+        FormatStyle::SpaceBeforeParensCustom::APO_Never;
     break;
   case FormatStyle::SBPO_ControlStatements:
     Expanded.SpaceBeforeParensOptions.AfterControlStatements = true;
     Expanded.SpaceBeforeParensOptions.AfterForeachMacros = true;
     Expanded.SpaceBeforeParensOptions.AfterIfMacros = true;
     break;
   case FormatStyle::SBPO_ControlStatementsExceptControlMacros:
     Expanded.SpaceBeforeParensOptions.AfterControlStatements = true;
FormatStyle getLLVMStyle(FormatStyle::LanguageKind Language) {
   LLVMStyle.SpaceBeforeCtorInitializerColon = true;
   LLVMStyle.SpaceBeforeInheritanceColon = true;
   LLVMStyle.SpaceBeforeJsonColon = false;
   LLVMStyle.SpaceBeforeParens = FormatStyle::SBPO_ControlStatements;
   LLVMStyle.SpaceBeforeParensOptions = {};
   LLVMStyle.SpaceBeforeParensOptions.AfterControlStatements = true;
   LLVMStyle.SpaceBeforeParensOptions.AfterForeachMacros = true;
   LLVMStyle.SpaceBeforeParensOptions.AfterIfMacros = true;
   LLVMStyle.SpaceBeforeRangeBasedForLoopColon = true;
   LLVMStyle.SpaceBeforeAssignmentOperators = true;
   LLVMStyle.SpaceBeforeCpp11BracedList = false;
   LLVMStyle.SpaceBeforeSquareBrackets = false;
   LLVMStyle.SpaceInEmptyBlock = false;
   LLVMStyle.SpacesBeforeTrailingComments = 1;
   LLVMStyle.SpacesInAngles = FormatStyle::SIAS_Never;
   LLVMStyle.SpacesInContainerLiterals = true;
   LLVMStyle.SpacesInLineCommentPrefix = {/*Minimum=*/1, /*Maximum=*/-1u};

clang/lib/Format/TokenAnnotator.cpp

if (Right.is(tok::l_paren)) {
     }
     if (Left.is(TT_ForEachMacro)) {
       return Style.SpaceBeforeParensOptions.AfterForeachMacros ||
              spaceRequiredBeforeParens(Right);
     }
     if (Left.is(TT_IfMacro)) {
       return Style.SpaceBeforeParensOptions.AfterIfMacros ||
              spaceRequiredBeforeParens(Right);
     }
+    if (Style.SpaceBeforeParens == FormatStyle::SBPO_Custom &&
+        Left.isOneOf(tok::kw_new, tok::kw_delete) &&
+        Right.isNot(TT_OverloadedOperatorLParen) &&
+        !(Line.MightBeFunctionDecl && Left.is(TT_FunctionDeclarationName))) {
+      if (Style.SpaceBeforeParensOptions.AfterPlacementOperator ==
+              FormatStyle::SpaceBeforeParensCustom::APO_Always ||
+          (Style.SpaceBeforeParensOptions.AfterPlacementOperator ==
+               FormatStyle::SpaceBeforeParensCustom::APO_Leave &&
+           Right.hasWhitespaceBefore())) {
+        return true;
+      }
+      return false;
+    }
     if (Line.Type == LT_ObjCDecl)
       return true;
     if (Left.is(tok::semi))
       return true;
     if (Left.isOneOf(tok::pp_elif, tok::kw_for, tok::kw_while, tok::kw_switch,
                      tok::kw_case, TT_ForEachMacro, TT_ObjCForIn) ||
         Left.isIf(Line.Type != LT_PreprocessorDirective) ||
         Right.is(TT_ConditionLParen)) {

clang/unittests/Format/ConfigParseTest.cpp

#undef CHECK_ALIGN_CONSECUTIVE
   CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens,
               FormatStyle::SBPO_Never);
   CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens,
               FormatStyle::SBPO_ControlStatements);
   CHECK_PARSE("SpaceBeforeParens: ControlStatementsExceptForEachMacros",
               SpaceBeforeParens,
               FormatStyle::SBPO_ControlStatementsExceptControlMacros);
 
+  Style.SpaceBeforeParens = FormatStyle::SBPO_Custom;
+  Style.SpaceBeforeParensOptions.AfterPlacementOperator =
+      FormatStyle::SpaceBeforeParensCustom::APO_Always;
+  CHECK_PARSE("SpaceBeforeParensOptions:\n"
+              "  AfterPlacementOperator: Never",
+              SpaceBeforeParensOptions.AfterPlacementOperator,
+              FormatStyle::SpaceBeforeParensCustom::APO_Never);
+
+  CHECK_PARSE("SpaceBeforeParensOptions:\n"
+              "  AfterPlacementOperator: Always",
+              SpaceBeforeParensOptions.AfterPlacementOperator,
+              FormatStyle::SpaceBeforeParensCustom::APO_Always);
+
+  CHECK_PARSE("SpaceBeforeParensOptions:\n"
+              "  AfterPlacementOperator: Leave",
+              SpaceBeforeParensOptions.AfterPlacementOperator,
+              FormatStyle::SpaceBeforeParensCustom::APO_Leave);
+
   // For backward compatibility:
   Style.SpacesInParens = FormatStyle::SIPO_Never;
   Style.SpacesInParensOptions = {};
   CHECK_PARSE("SpacesInParentheses: true", SpacesInParens,
               FormatStyle::SIPO_Custom);
   Style.SpacesInParens = FormatStyle::SIPO_Never;
   Style.SpacesInParensOptions = {};
   CHECK_PARSE("SpacesInParentheses: true", SpacesInParensOptions,

clang/unittests/Format/FormatTest.cpp

TEST_F(FormatTest, UnderstandsNewAndDelete) {
   verifyFormat("void operator new(void *foo) ATTRIB;");
   verifyFormat("void operator delete[](void *foo) ATTRIB;");
   verifyFormat("void operator delete(void *ptr) noexcept;");
 
   verifyFormat("void new(link p);\n"
                "void delete(link p);",
                "void new (link p);\n"
                "void delete (link p);");
+
+  FormatStyle AfterPlacementOperator = getLLVMStyle();
+  AfterPlacementOperator.SpaceBeforeParens = FormatStyle::SBPO_Custom;
+  EXPECT_EQ(
+      AfterPlacementOperator.SpaceBeforeParensOptions.AfterPlacementOperator,
+      FormatStyle::SpaceBeforeParensCustom::APO_Leave);
+  verifyFormat("new (buf) int;", AfterPlacementOperator);
+  verifyFormat("new(buf) int;", AfterPlacementOperator);
+
+  AfterPlacementOperator.SpaceBeforeParensOptions.AfterPlacementOperator =
+      FormatStyle::SpaceBeforeParensCustom::APO_Never;
+  verifyFormat("struct A {\n"
+               "  int *a;\n"
+               "  A(int *p) : a(new(p) int) {\n"
+               "    new(p) int;\n"
+               "    int *b = new(p) int;\n"
+               "    int *c = new(p) int(3);\n"
+               "    delete(b);\n"
+               "  }\n"
+               "};",
+               AfterPlacementOperator);
+  verifyFormat("void operator new(void *foo) ATTRIB;", AfterPlacementOperator);
+
+  AfterPlacementOperator.SpaceBeforeParensOptions.AfterPlacementOperator =
+      FormatStyle::SpaceBeforeParensCustom::APO_Always;
+  verifyFormat("struct A {\n"
+               "  int *a;\n"
+               "  A(int *p) : a(new (p) int) {\n"
+               "    new (p) int;\n"
+               "    int *b = new (p) int;\n"
+               "    int *c = new (p) int(3);\n"
+               "    delete (b);\n"
+               "  }\n"
+               "};",
+               AfterPlacementOperator);
+  verifyFormat("void operator new(void *foo) ATTRIB;", AfterPlacementOperator);
 }
 
 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) {
   verifyFormat("int *f(int *a) {}");
   verifyFormat("int main(int argc, char **argv) {}");
   verifyFormat("Test::Test(int b) : a(b * b) {}");
   verifyIndependentOfContext("f(a, *a);");
   verifyFormat("void g() { f(*a); }");
TEST_F(FormatTest, ConfigurableSpaceBeforeParens) {
   verifyFormat("T A::operator()();", SpaceFuncDef);
   verifyFormat("X A::operator++(T);", SpaceFuncDef);
   // verifyFormat("T A::operator() () {}", SpaceFuncDef);
   verifyFormat("auto lambda = [] () { return 0; };", SpaceFuncDef);
   verifyFormat("int x = int(y);", SpaceFuncDef);
   verifyFormat("M(std::size_t R, std::size_t C) : C(C), data(R) {}",
                SpaceFuncDef);
 
   FormatStyle SpaceIfMacros = getLLVMStyle();
   SpaceIfMacros.IfMacros.clear();
   SpaceIfMacros.IfMacros.push_back("MYIF");
   SpaceIfMacros.SpaceBeforeParens = FormatStyle::SBPO_Custom;
   SpaceIfMacros.SpaceBeforeParensOptions.AfterIfMacros = true;
   verifyFormat("MYIF (a)\n  return;", SpaceIfMacros);
   verifyFormat("MYIF (a)\n  return;\nelse MYIF (b)\n  return;", SpaceIfMacros);
   verifyFormat("MYIF (a)\n  return;\nelse\n  return;", SpaceIfMacros);
 
   FormatStyle SpaceForeachMacros = getLLVMStyle();
   EXPECT_EQ(SpaceForeachMacros.AllowShortBlocksOnASingleLine,
             FormatStyle::SBS_Never);
   EXPECT_EQ(SpaceForeachMacros.AllowShortLoopsOnASingleLine, false);
   SpaceForeachMacros.SpaceBeforeParens = FormatStyle::SBPO_Custom;
   SpaceForeachMacros.SpaceBeforeParensOptions.AfterForeachMacros = true;
   verifyFormat("for (;;) {\n"
                "}",
                SpaceForeachMacros);
   verifyFormat("foreach (Item *item, itemlist) {\n"