clang-format updates

MikePopoloski · Sep 9, 2022 · fc5c4a0 · fc5c4a0
1 parent 9bb9f84
commit fc5c4a0
Show file tree

Hide file tree

Showing 102 changed files with 1,513 additions and 1,407 deletions.
diff --git a/.clang-format b/.clang-format
@@ -1,97 +1,122 @@
 ---
-Language:        Cpp
+Language: Cpp
 AccessModifierOffset: -4
 AlignAfterOpenBracket: Align
 AlignConsecutiveAssignments: false
+AlignConsecutiveBitFields: false
 AlignConsecutiveDeclarations: false
+AlignConsecutiveMacros: false
 AlignEscapedNewlines: Left
-AlignOperands:   true
+AlignOperands: true
 AlignTrailingComments: true
+AllowAllArgumentsOnNextLine: true
 AllowAllParametersOfDeclarationOnNextLine: true
-AllowShortBlocksOnASingleLine: false
+AllowShortBlocksOnASingleLine: Never
 AllowShortCaseLabelsOnASingleLine: false
+AllowShortEnumsOnASingleLine: true
 AllowShortFunctionsOnASingleLine: InlineOnly
-AllowShortIfStatementsOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortLambdasOnASingleLine: All
 AllowShortLoopsOnASingleLine: false
-AlwaysBreakAfterDefinitionReturnType: None
 AlwaysBreakAfterReturnType: None
 AlwaysBreakBeforeMultilineStrings: false
-AlwaysBreakTemplateDeclarations: true
+AlwaysBreakTemplateDeclarations: Yes
 BinPackArguments: true
 BinPackParameters: true
+BitFieldColonSpacing: Both
 BraceWrapping:
-  AfterClass:      false
+  AfterCaseLabel:        false
+  AfterClass:            false
   AfterControlStatement: false
-  AfterEnum:       false
-  AfterFunction:   false
-  AfterNamespace:  false
-  AfterObjCDeclaration: false
-  AfterStruct:     false
-  AfterUnion:      false
-  AfterExternBlock: false
-  BeforeCatch:     true
-  BeforeElse:      true
-  IndentBraces:    false
-  SplitEmptyFunction: true
-  SplitEmptyRecord: true
-  SplitEmptyNamespace: true
+  AfterEnum:             false
+  AfterFunction:         false
+  AfterNamespace:        false
+  AfterObjCDeclaration:  false
+  AfterStruct:           false
+  AfterUnion:            false
+  AfterExternBlock:      false
+  BeforeCatch:           true
+  BeforeElse:            true
+  BeforeLambdaBody:      false
+  BeforeWhile:           false
+  IndentBraces:          false
+  SplitEmptyFunction:    true
+  SplitEmptyRecord:      true
+  SplitEmptyNamespace:   true
+BreakAfterJavaFieldAnnotations: false
 BreakBeforeBinaryOperators: None
 BreakBeforeBraces: Custom
-BreakBeforeInheritanceComma: false
+#BreakBeforeConceptDeclarations: Always
 BreakBeforeTernaryOperators: true
-BreakConstructorInitializersBeforeComma: false
 BreakConstructorInitializers: AfterColon
-BreakAfterJavaFieldAnnotations: false
 BreakStringLiterals: true
-ColumnLimit:     100
+ColumnLimit: 100
 CompactNamespaces: false
-ConstructorInitializerAllOnOneLineOrOnePerLine: false
 ConstructorInitializerIndentWidth: 4
 ContinuationIndentWidth: 4
-Cpp11BracedListStyle: false
+Cpp11BracedListStyle: true
+DeriveLineEnding: false
 DerivePointerAlignment: false
-DisableFormat:   false
-ExperimentalAutoDetectBinPacking: false
+DisableFormat: false
+EmptyLineAfterAccessModifier: Never
+EmptyLineBeforeAccessModifier: LogicalBlock
 FixNamespaceComments: true
-IncludeBlocks:   Regroup
+IncludeBlocks: Regroup
 IncludeCategories:
   - Regex:           '^"slang/'
     Priority:        2
   - Regex:           '.*'
     Priority:        1
 IncludeIsMainRegex: '$'
+IndentAccessModifiers: false
+IndentCaseBlocks: false
 IndentCaseLabels: true
+IndentExternBlock: NoIndent
+IndentGotoLabels: true
 IndentPPDirectives: AfterHash
-IndentWidth:     4
+#IndentRequiresClause: true
+IndentWidth: 4
 IndentWrappedFunctionNames: false
 KeepEmptyLinesAtTheStartOfBlocks: true
-MacroBlockBegin: ''
-MacroBlockEnd:   ''
+LambdaBodyIndentation: Signature
 MaxEmptyLinesToKeep: 1
 NamespaceIndentation: None
-PenaltyBreakAssignment: 2
-PenaltyBreakBeforeFirstCallParameter: 19
+PackConstructorInitializers: BinPack
+PenaltyBreakAssignment: 50
+PenaltyBreakBeforeFirstCallParameter: 50
 PenaltyBreakComment: 300
 PenaltyBreakFirstLessLess: 120
 PenaltyBreakString: 1000
 PenaltyExcessCharacter: 1000000
 PenaltyReturnTypeOnItsOwnLine: 600
 PointerAlignment: Left
-ReflowComments:  true
-SortIncludes:    true
+QualifierAlignment: Leave
+ReferenceAlignment: Left
+ReflowComments: true
+#RequiresClausePosition: WithPreceding
+SortIncludes: CaseSensitive
 SortUsingDeclarations: true
 SpaceAfterCStyleCast: false
+SpaceAfterLogicalNot: false
 SpaceAfterTemplateKeyword: false
 SpaceBeforeAssignmentOperators: true
+SpaceBeforeCaseColon: false
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
 SpaceBeforeParens: ControlStatements
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceBeforeSquareBrackets: false
+SpaceInEmptyBlock: false
 SpaceInEmptyParentheses: false
 SpacesBeforeTrailingComments: 1
-SpacesInAngles:  false
-SpacesInContainerLiterals: true
+SpacesInAngles: Never
 SpacesInCStyleCastParentheses: false
+SpacesInConditionalStatement: false
+SpacesInContainerLiterals: false
 SpacesInParentheses: false
 SpacesInSquareBrackets: false
-Standard:        Cpp11
-TabWidth:        4
-UseTab:          Never
+Standard: Latest
+TabWidth: 4
+UseTab: Never
 ...
diff --git a/bindings/python/binding.cpp b/bindings/python/binding.cpp
@@ -305,8 +305,9 @@ void registerBinding(py::module_& m) {
     py::class_<EmptyArgumentExpression, Expression>(m, "EmptyArgumentExpression");
 
     py::class_<TypeReferenceExpression, Expression>(m, "TypeReferenceExpression")
-        .def_property_readonly(
-            "targetType", [](const TypeReferenceExpression& self) { return &self.targetType; });
+        .def_property_readonly("targetType", [](const TypeReferenceExpression& self) {
+            return &self.targetType;
+        });
 
     py::class_<HierarchicalReferenceExpression, Expression>(m, "HierarchicalReferenceExpression")
         .def_readonly("symbol", &HierarchicalReferenceExpression::symbol);
@@ -547,9 +548,10 @@ void registerBinding(py::module_& m) {
         .def_readonly("isFinal", &ImmediateAssertionStatement::isFinal);
 
     py::class_<ConcurrentAssertionStatement, Statement>(m, "ConcurrentAssertionStatement")
-        .def_property_readonly(
-            "propertySpec",
-            [](const ConcurrentAssertionStatement& self) { return &self.propertySpec; })
+        .def_property_readonly("propertySpec",
+                               [](const ConcurrentAssertionStatement& self) {
+                                   return &self.propertySpec;
+                               })
         .def_readonly("ifTrue", &ConcurrentAssertionStatement::ifTrue)
         .def_readonly("ifFalse", &ConcurrentAssertionStatement::ifFalse)
         .def_readonly("assertionKind", &ConcurrentAssertionStatement::assertionKind);

diff --git a/bindings/python/numeric.cpp b/bindings/python/numeric.cpp
@@ -327,7 +327,7 @@ void registerNumeric(py::module_& m) {
     py::class_<ConstantRange>(m, "ConstantRange")
         .def(py::init<>())
         .def(py::init([](int left, int right) {
-            return ConstantRange{ left, right };
+            return ConstantRange{left, right};
         }))
         .def_readwrite("left", &ConstantRange::left)
         .def_readwrite("right", &ConstantRange::right)

diff --git a/bindings/python/pyslang.h b/bindings/python/pyslang.h
@@ -49,19 +49,19 @@ std::tuple<bool, span<T>> loadSpanFromBuffer(handle src) {
         auto cleanup = ScopeGuard([&view] { PyBuffer_Release(&view); });
         if (view.ndim == 1 && view.strides[0] == sizeof(T) &&
             view.format[0] == format_descriptor<T>::c) {
-            return { true, span(static_cast<T*>(view.buf), view.shape[0]) };
+            return {true, span(static_cast<T*>(view.buf), view.shape[0])};
         }
     }
     else {
         // Clear the buffer error (failure is reported in the return value).
         PyErr_Clear();
     }
-    return { false, span<T>() };
+    return {false, span<T>()};
 }
 // If T is not a numeric type, the buffer interface cannot be used.
 template<typename T, typename std::enable_if<!std::is_arithmetic<T>::value, bool>::type = true>
 constexpr std::tuple<bool, span<T>> loadSpanFromBuffer(handle src) {
-    return { false, span<T>() };
+    return {false, span<T>()};
 }
 
 template<typename T>

diff --git a/bindings/python/symbols.cpp b/bindings/python/symbols.cpp
@@ -206,8 +206,9 @@ void registerSymbols(py::module_& m) {
     py::class_<TypeParameterSymbol, Symbol, ParameterSymbolBase>(m, "TypeParameterSymbol")
         .def_property_readonly("targetType",
                                [](const TypeParameterSymbol& self) { return &self.targetType; })
-        .def_property_readonly(
-            "typeAlias", [](const TypeParameterSymbol& self) { return &self.getTypeAlias(); });
+        .def_property_readonly("typeAlias", [](const TypeParameterSymbol& self) {
+            return &self.getTypeAlias();
+        });
 
     py::class_<DefParamSymbol, Symbol>(m, "DefParamSymbol")
         .def_property_readonly("target",
@@ -386,9 +387,10 @@ void registerSymbols(py::module_& m) {
         .def_property_readonly("isChecker", &UnknownModuleSymbol::isChecker);
 
     py::class_<PrimitiveInstanceSymbol, InstanceSymbolBase>(m, "PrimitiveInstanceSymbol")
-        .def_property_readonly(
-            "primitiveType",
-            [](const PrimitiveInstanceSymbol& self) { return &self.primitiveType; })
+        .def_property_readonly("primitiveType",
+                               [](const PrimitiveInstanceSymbol& self) {
+                                   return &self.primitiveType;
+                               })
         .def_property_readonly("portConnections", &PrimitiveInstanceSymbol::getPortConnections)
         .def_property_readonly("delay", &PrimitiveInstanceSymbol::getDelay);
 
@@ -471,8 +473,9 @@ void registerSymbols(py::module_& m) {
 
     py::class_<AssertionPortSymbol, Symbol>(m, "AssertionPortSymbol")
         .def_readonly("localVarDirection", &AssertionPortSymbol::localVarDirection)
-        .def_property_readonly(
-            "type", [](const AssertionPortSymbol& self) { return &self.declaredType.getType(); });
+        .def_property_readonly("type", [](const AssertionPortSymbol& self) {
+            return &self.declaredType.getType();
+        });
 
     py::class_<SequenceSymbol, Symbol, Scope>(m, "SequenceSymbol")
         .def_readonly("ports", &SequenceSymbol::ports);

diff --git a/bindings/python/syntax.cpp b/bindings/python/syntax.cpp
@@ -151,10 +151,10 @@ void registerSyntax(py::module_& m) {
     py::class_<SyntaxTree, std::shared_ptr<SyntaxTree>>(m, "SyntaxTree")
         .def_readonly("isLibrary", &SyntaxTree::isLibrary)
         .def_static("fromFile", py::overload_cast<string_view>(&SyntaxTree::fromFile))
-        .def_static(
-            "fromFile",
-            py::overload_cast<string_view, SourceManager&, const Bag&>(&SyntaxTree::fromFile),
-            "path"_a, "sourceManager"_a, "options"_a = Bag())
+        .def_static("fromFile",
+                    py::overload_cast<string_view, SourceManager&, const Bag&>(
+                        &SyntaxTree::fromFile),
+                    "path"_a, "sourceManager"_a, "options"_a = Bag())
         .def_static("fromFiles", py::overload_cast<span<const string_view>>(&SyntaxTree::fromFiles))
         .def_static("fromFiles",
                     py::overload_cast<span<const string_view>, SourceManager&, const Bag&>(

diff --git a/bindings/python/util.cpp b/bindings/python/util.cpp
@@ -123,10 +123,10 @@ void registerUtil(py::module_& m) {
         .def("assignText",
              py::overload_cast<string_view, SourceLocation>(&SourceManager::assignText), "text"_a,
              "includedFrom"_a = SourceLocation())
-        .def(
-            "assignText",
-            py::overload_cast<string_view, string_view, SourceLocation>(&SourceManager::assignText),
-            "path"_a, "text"_a, "includedFrom"_a = SourceLocation())
+        .def("assignText",
+             py::overload_cast<string_view, string_view, SourceLocation>(
+                 &SourceManager::assignText),
+             "path"_a, "text"_a, "includedFrom"_a = SourceLocation())
         .def("readSource", &SourceManager::readSource)
         .def("readHeader", &SourceManager::readHeader)
         .def("isCached", &SourceManager::isCached)
@@ -239,9 +239,10 @@ void registerUtil(py::module_& m) {
         .def_static("reportAll", &DiagnosticEngine::reportAll);
 
     py::class_<ReportedDiagnostic>(m, "ReportedDiagnostic")
-        .def_property_readonly(
-            "originalDiagnostic",
-            [](const ReportedDiagnostic& self) { return self.originalDiagnostic; })
+        .def_property_readonly("originalDiagnostic",
+                               [](const ReportedDiagnostic& self) {
+                                   return self.originalDiagnostic;
+                               })
         .def_readonly("expansionLocs", &ReportedDiagnostic::expansionLocs)
         .def_readonly("ranges", &ReportedDiagnostic::ranges)
         .def_readonly("location", &ReportedDiagnostic::location)

diff --git a/include/slang/binding/EvalContext.h b/include/slang/binding/EvalContext.h
@@ -123,8 +123,8 @@ class EvalContext {
     /// object that when destructed will restore the previous caching mode.
     /// Otherwise does nothing.
     [[nodiscard]] auto disableCaching() {
-        auto guard =
-            ScopeGuard([this, saved = flags.has(EvalFlags::CacheResults), pushed = !inFunction()] {
+        auto guard = ScopeGuard(
+            [this, saved = flags.has(EvalFlags::CacheResults), pushed = !inFunction()] {
                 if (pushed)
                     popFrame();
 

diff --git a/include/slang/binding/LValue.h b/include/slang/binding/LValue.h
@@ -25,7 +25,7 @@ class LValue {
     LValue(LValue&& other) = default;
 
     explicit LValue(Concat&& concat) : value(std::move(concat)) {}
-    explicit LValue(ConstantValue& base) : value(Path{ base }) {}
+    explicit LValue(ConstantValue& base) : value(Path{base}) {}
 
     bool bad() const { return std::holds_alternative<std::monostate>(value); }
     explicit operator bool() const { return !bad(); }

diff --git a/include/slang/compilation/Compilation.h b/include/slang/compilation/Compilation.h
@@ -467,7 +467,7 @@ class Compilation : public BumpAllocator {
 
     // A table to look up scalar types based on combinations of the three flags: signed, fourstate,
     // reg. Two of the entries are not valid and will be nullptr (!fourstate & reg).
-    Type* scalarTypeTable[8]{ nullptr };
+    Type* scalarTypeTable[8]{nullptr};
 
     // Instances of all the built-in types.
     Type* bitType;

diff --git a/include/slang/mir/Instr.h b/include/slang/mir/Instr.h
@@ -87,9 +87,9 @@ class Instr {
     InstrKind kind;
 
     Instr(InstrKind kind, const Type& type, MIRValue op) noexcept :
-        type(type), kind(kind), immOps{ op, MIRValue{} } {}
+        type(type), kind(kind), immOps{op, MIRValue{}} {}
     Instr(InstrKind kind, const Type& type, MIRValue op0, MIRValue op1) noexcept :
-        type(type), kind(kind), immOps{ op0, op1 } {}
+        type(type), kind(kind), immOps{op0, op1} {}
 
     Instr(SysCallKind sysCall, const Type& returnType, span<const MIRValue> args) noexcept :
         type(returnType), kind(InstrKind::syscall), sysCallKind(sysCall), varOps(args) {}

diff --git a/include/slang/numeric/ConstantValue.h b/include/slang/numeric/ConstantValue.h
@@ -302,7 +302,7 @@ struct ConstantRange {
     bool isLittleEndian() const { return left >= right; }
 
     /// Reverses the bit ordering of the range.
-    [[nodiscard]] ConstantRange reverse() const { return { right, left }; }
+    [[nodiscard]] ConstantRange reverse() const { return {right, left}; }
 
     /// Selects a subrange of this range, correctly handling both forms of
     /// bit endianness. This will assert that the given subrange is not wider.

diff --git a/include/slang/numeric/MathUtils.h b/include/slang/numeric/MathUtils.h
@@ -75,8 +75,8 @@ inline uint32_t countPopulation64(uint64_t value) {
 inline std::optional<int32_t> checkedAddS32(int32_t a, int32_t b) {
 #if defined(_MSC_VER)
     int64_t p = int64_t(a) + int64_t(b);
-    bool fits =
-        p >= std::numeric_limits<int32_t>::min() && p <= std::numeric_limits<int32_t>::max();
+    bool fits = p >= std::numeric_limits<int32_t>::min() &&
+                p <= std::numeric_limits<int32_t>::max();
     return fits ? std::make_optional(int32_t(p)) : std::nullopt;
 #else
     int32_t result;
@@ -89,8 +89,8 @@ inline std::optional<int32_t> checkedAddS32(int32_t a, int32_t b) {
 inline std::optional<int32_t> checkedSubS32(int32_t a, int32_t b) {
 #if defined(_MSC_VER)
     int64_t p = int64_t(a) - int64_t(b);
-    bool fits =
-        p >= std::numeric_limits<int32_t>::min() && p <= std::numeric_limits<int32_t>::max();
+    bool fits = p >= std::numeric_limits<int32_t>::min() &&
+                p <= std::numeric_limits<int32_t>::max();
     return fits ? std::make_optional(int32_t(p)) : std::nullopt;
 #else
     int32_t result;

diff --git a/include/slang/parsing/NumberParser.h b/include/slang/parsing/NumberParser.h
@@ -26,10 +26,10 @@ class NumberParser {
         Token value;
         bool isSimple = true;
 
-        static IntResult simple(Token value) { return { Token(), Token(), value, true }; }
+        static IntResult simple(Token value) { return {Token(), Token(), value, true}; }
 
         static IntResult vector(Token size, Token base, Token value) {
-            return { size, base, value, false };
+            return {size, base, value, false};
         }
     };