chore: update pre-commit hooks (#913)

* chore: update pre-commit hooks

updates:
- [github.com/pre-commit/mirrors-clang-format: v17.0.6 → v18.1.1](pre-commit/mirrors-clang-format@v17.0.6...v18.1.1)

* style: pre-commit fixes

---------

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

.pre-commit-config.yaml

@@ -65,7 +65,7 @@ repos:
 
 # clang-format
 - repo: https://github.com/pre-commit/mirrors-clang-format
-  rev: v17.0.6
+  rev: v18.1.1
   hooks:
   - id: clang-format
     exclude: ^external/.*

bindings/python/NumericBindings.cpp

@@ -330,10 +330,8 @@ void registerNumeric(py::module_& m) {
 
     py::class_<ConstantRange>(m, "ConstantRange")
         .def(py::init<>())
-        .def(py::init([](int left, int right) {
-                 return ConstantRange{left, right};
-             }),
-             "left"_a, "right"_a)
+        .def(py::init([](int left, int right) { return ConstantRange{left, right}; }), "left"_a,
+             "right"_a)
         .def_readwrite("left", &ConstantRange::left)
         .def_readwrite("right", &ConstantRange::right)
         .def_property_readonly("width", &ConstantRange::width)

include/slang/ast/ASTContext.h

@@ -350,8 +350,7 @@ class SLANG_EXPORT ASTContext {
     /// @param flags Flags that control AST creation
     ASTContext(const Scope& scope, LookupLocation lookupLocation,
                bitmask<ASTFlags> flags = ASTFlags::None) :
-        scope(&scope),
-        lookupIndex(lookupLocation.getIndex()), flags(flags) {
+        scope(&scope), lookupIndex(lookupLocation.getIndex()), flags(flags) {
         SLANG_ASSERT(!lookupLocation.getScope() || lookupLocation.getScope() == &scope);
     }
 

include/slang/ast/Compilation.h

@@ -370,8 +370,7 @@ class SLANG_EXPORT Compilation : public BumpAllocator {
 
         DefinitionLookupResult(const Symbol* definition, const ConfigBlockSymbol* configRoot,
                                const ConfigRule* configRule) :
-            definition(definition),
-            configRoot(configRoot), configRule(configRule) {}
+            definition(definition), configRoot(configRoot), configRule(configRule) {}
     };
 
     /// Gets the definition with the given name, or nullptr if there is no such definition.

include/slang/ast/Constraints.h

@@ -169,8 +169,8 @@ class SLANG_EXPORT ConditionalConstraint : public Constraint {
 
     ConditionalConstraint(const Expression& predicate, const Constraint& ifBody,
                           const Constraint* elseBody) :
-        Constraint(ConstraintKind::Conditional),
-        predicate(predicate), ifBody(ifBody), elseBody(elseBody) {}
+        Constraint(ConstraintKind::Conditional), predicate(predicate), ifBody(ifBody),
+        elseBody(elseBody) {}
 
     static Constraint& fromSyntax(const syntax::ConditionalConstraintSyntax& syntax,
                                   const ASTContext& context);
@@ -239,8 +239,7 @@ class SLANG_EXPORT SolveBeforeConstraint : public Constraint {
 
     SolveBeforeConstraint(std::span<const Expression* const> solve,
                           std::span<const Expression* const> before) :
-        Constraint(ConstraintKind::SolveBefore),
-        solve(solve), before(before) {}
+        Constraint(ConstraintKind::SolveBefore), solve(solve), before(before) {}
 
     static Constraint& fromSyntax(const syntax::SolveBeforeConstraintSyntax& syntax,
                                   const ASTContext& context);
@@ -268,8 +267,7 @@ class SLANG_EXPORT ForeachConstraint : public Constraint {
     ForeachConstraint(const Expression& arrayRef,
                       std::span<const ForeachLoopStatement::LoopDim> loopDims,
                       const Constraint& body) :
-        Constraint(ConstraintKind::Foreach),
-        arrayRef(arrayRef), loopDims(loopDims), body(body) {}
+        Constraint(ConstraintKind::Foreach), arrayRef(arrayRef), loopDims(loopDims), body(body) {}
 
     static Constraint& fromSyntax(const syntax::LoopConstraintSyntax& syntax,
                                   const ASTContext& context);

include/slang/ast/Statements.h

@@ -434,8 +434,8 @@ class SLANG_EXPORT ConditionalStatement : public Statement {
     ConditionalStatement(std::span<const Condition> conditions, UniquePriorityCheck check,
                          const Statement& ifTrue, const Statement* ifFalse,
                          SourceRange sourceRange) :
-        Statement(StatementKind::Conditional, sourceRange),
-        conditions(conditions), ifTrue(ifTrue), ifFalse(ifFalse), check(check) {}
+        Statement(StatementKind::Conditional, sourceRange), conditions(conditions), ifTrue(ifTrue),
+        ifFalse(ifFalse), check(check) {}
 
     EvalResult evalImpl(EvalContext& context) const;
 
@@ -480,8 +480,8 @@ class SLANG_EXPORT CaseStatement : public Statement {
     CaseStatement(CaseStatementCondition condition, UniquePriorityCheck check,
                   const Expression& expr, std::span<ItemGroup const> items,
                   const Statement* defaultCase, SourceRange sourceRange) :
-        Statement(StatementKind::Case, sourceRange),
-        expr(expr), items(items), defaultCase(defaultCase), condition(condition), check(check) {}
+        Statement(StatementKind::Case, sourceRange), expr(expr), items(items),
+        defaultCase(defaultCase), condition(condition), check(check) {}
 
     EvalResult evalImpl(EvalContext& context) const;
 
@@ -528,8 +528,8 @@ class SLANG_EXPORT PatternCaseStatement : public Statement {
     PatternCaseStatement(CaseStatementCondition condition, UniquePriorityCheck check,
                          const Expression& expr, std::span<ItemGroup const> items,
                          const Statement* defaultCase, SourceRange sourceRange) :
-        Statement(StatementKind::PatternCase, sourceRange),
-        expr(expr), items(items), defaultCase(defaultCase), condition(condition), check(check) {}
+        Statement(StatementKind::PatternCase, sourceRange), expr(expr), items(items),
+        defaultCase(defaultCase), condition(condition), check(check) {}
 
     EvalResult evalImpl(EvalContext& context) const;
 
@@ -571,8 +571,8 @@ class SLANG_EXPORT ForLoopStatement : public Statement {
     ForLoopStatement(std::span<const Expression* const> initializers, const Expression* stopExpr,
                      std::span<const Expression* const> steps, const Statement& body,
                      SourceRange sourceRange) :
-        Statement(StatementKind::ForLoop, sourceRange),
-        initializers(initializers), stopExpr(stopExpr), steps(steps), body(body) {}
+        Statement(StatementKind::ForLoop, sourceRange), initializers(initializers),
+        stopExpr(stopExpr), steps(steps), body(body) {}
 
     EvalResult evalImpl(EvalContext& context) const;
 
@@ -648,8 +648,8 @@ class SLANG_EXPORT ForeachLoopStatement : public Statement {
 
     ForeachLoopStatement(const Expression& arrayRef, std::span<const LoopDim> loopDims,
                          const Statement& body, SourceRange sourceRange) :
-        Statement(StatementKind::ForeachLoop, sourceRange),
-        arrayRef(arrayRef), loopDims(loopDims), body(body) {}
+        Statement(StatementKind::ForeachLoop, sourceRange), arrayRef(arrayRef), loopDims(loopDims),
+        body(body) {}
 
     EvalResult evalImpl(EvalContext& context) const;
 
@@ -828,9 +828,8 @@ class SLANG_EXPORT ImmediateAssertionStatement : public Statement {
     ImmediateAssertionStatement(AssertionKind assertionKind, const Expression& cond,
                                 const Statement* ifTrue, const Statement* ifFalse, bool isDeferred,
                                 bool isFinal, SourceRange sourceRange) :
-        Statement(StatementKind::ImmediateAssertion, sourceRange),
-        cond(cond), ifTrue(ifTrue), ifFalse(ifFalse), assertionKind(assertionKind),
-        isDeferred(isDeferred), isFinal(isFinal) {}
+        Statement(StatementKind::ImmediateAssertion, sourceRange), cond(cond), ifTrue(ifTrue),
+        ifFalse(ifFalse), assertionKind(assertionKind), isDeferred(isDeferred), isFinal(isFinal) {}
 
     EvalResult evalImpl(EvalContext& context) const;
 
@@ -866,9 +865,8 @@ class SLANG_EXPORT ConcurrentAssertionStatement : public Statement {
     ConcurrentAssertionStatement(AssertionKind assertionKind, const AssertionExpr& propertySpec,
                                  const Statement* ifTrue, const Statement* ifFalse,
                                  SourceRange sourceRange) :
-        Statement(StatementKind::ConcurrentAssertion, sourceRange),
-        propertySpec(propertySpec), ifTrue(ifTrue), ifFalse(ifFalse), assertionKind(assertionKind) {
-    }
+        Statement(StatementKind::ConcurrentAssertion, sourceRange), propertySpec(propertySpec),
+        ifTrue(ifTrue), ifFalse(ifFalse), assertionKind(assertionKind) {}
 
     EvalResult evalImpl(EvalContext& context) const;
 
@@ -961,8 +959,8 @@ class SLANG_EXPORT WaitOrderStatement : public Statement {
 
     WaitOrderStatement(std::span<const Expression* const> events, const Statement* ifTrue,
                        const Statement* ifFalse, SourceRange sourceRange) :
-        Statement(StatementKind::WaitOrder, sourceRange),
-        events(events), ifTrue(ifTrue), ifFalse(ifFalse) {}
+        Statement(StatementKind::WaitOrder, sourceRange), events(events), ifTrue(ifTrue),
+        ifFalse(ifFalse) {}
 
     EvalResult evalImpl(EvalContext& context) const;
 
@@ -997,8 +995,8 @@ class SLANG_EXPORT EventTriggerStatement : public Statement {
 
     EventTriggerStatement(const Expression& target, const TimingControl* timing, bool isNonBlocking,
                           SourceRange sourceRange) :
-        Statement(StatementKind::EventTrigger, sourceRange),
-        target(target), timing(timing), isNonBlocking(isNonBlocking) {}
+        Statement(StatementKind::EventTrigger, sourceRange), target(target), timing(timing),
+        isNonBlocking(isNonBlocking) {}
 
     EvalResult evalImpl(EvalContext& context) const;
 

include/slang/ast/SystemSubroutine.h

@@ -72,9 +72,8 @@ class SLANG_EXPORT SimpleSystemSubroutine : public SystemSubroutine {
     SimpleSystemSubroutine(const std::string& name, SubroutineKind kind, size_t requiredArgs,
                            const std::vector<const Type*>& argTypes, const Type& returnType,
                            bool isMethod, bool isFirstArgLValue = false) :
-        SystemSubroutine(name, kind),
-        argTypes(argTypes), returnType(&returnType), requiredArgs(requiredArgs), isMethod(isMethod),
-        isFirstArgLValue(isFirstArgLValue) {
+        SystemSubroutine(name, kind), argTypes(argTypes), returnType(&returnType),
+        requiredArgs(requiredArgs), isMethod(isMethod), isFirstArgLValue(isFirstArgLValue) {
         SLANG_ASSERT(requiredArgs <= argTypes.size());
     }
 

include/slang/ast/TimingControl.h

@@ -131,8 +131,8 @@ class SLANG_EXPORT Delay3Control : public TimingControl {
 
     Delay3Control(const Expression& expr1, const Expression* expr2, const Expression* expr3,
                   SourceRange sourceRange) :
-        TimingControl(TimingControlKind::Delay3, sourceRange),
-        expr1(expr1), expr2(expr2), expr3(expr3) {}
+        TimingControl(TimingControlKind::Delay3, sourceRange), expr1(expr1), expr2(expr2),
+        expr3(expr3) {}
 
     static TimingControl& fromSyntax(Compilation& compilation, const syntax::Delay3Syntax& syntax,
                                      const ASTContext& context);
@@ -163,8 +163,8 @@ class SLANG_EXPORT SignalEventControl : public TimingControl {
 
     SignalEventControl(EdgeKind edge, const Expression& expr, const Expression* iffCondition,
                        SourceRange sourceRange) :
-        TimingControl(TimingControlKind::SignalEvent, sourceRange),
-        expr(expr), iffCondition(iffCondition), edge(edge) {}
+        TimingControl(TimingControlKind::SignalEvent, sourceRange), expr(expr),
+        iffCondition(iffCondition), edge(edge) {}
 
     static TimingControl& fromSyntax(Compilation& compilation,
                                      const syntax::SignalEventExpressionSyntax& syntax,
@@ -241,8 +241,7 @@ class SLANG_EXPORT RepeatedEventControl : public TimingControl {
 
     RepeatedEventControl(const Expression& expr, const TimingControl& event,
                          SourceRange sourceRange) :
-        TimingControl(TimingControlKind::RepeatedEvent, sourceRange),
-        expr(expr), event(event) {}
+        TimingControl(TimingControlKind::RepeatedEvent, sourceRange), expr(expr), event(event) {}
 
     static TimingControl& fromSyntax(Compilation& compilation,
                                      const syntax::RepeatedEventControlSyntax& syntax,

include/slang/ast/expressions/AssertionExpr.h

@@ -255,8 +255,8 @@ class SLANG_EXPORT SequenceWithMatchExpr : public AssertionExpr {
 
     SequenceWithMatchExpr(const AssertionExpr& expr, std::optional<SequenceRepetition> repetition,
                           std::span<const Expression* const> matchItems) :
-        AssertionExpr(AssertionExprKind::SequenceWithMatch),
-        expr(expr), repetition(repetition), matchItems(matchItems) {}
+        AssertionExpr(AssertionExprKind::SequenceWithMatch), expr(expr), repetition(repetition),
+        matchItems(matchItems) {}
 
     bool admitsEmptyImpl() const;
 
@@ -286,8 +286,7 @@ class SLANG_EXPORT UnaryAssertionExpr : public AssertionExpr {
 
     UnaryAssertionExpr(UnaryAssertionOperator op, const AssertionExpr& expr,
                        std::optional<SequenceRange> range) :
-        AssertionExpr(AssertionExprKind::Unary),
-        op(op), expr(expr), range(range) {}
+        AssertionExpr(AssertionExprKind::Unary), op(op), expr(expr), range(range) {}
 
     bool admitsEmptyImpl() const { return false; }
 
@@ -316,8 +315,7 @@ class SLANG_EXPORT BinaryAssertionExpr : public AssertionExpr {
 
     BinaryAssertionExpr(BinaryAssertionOperator op, const AssertionExpr& left,
                         const AssertionExpr& right) :
-        AssertionExpr(AssertionExprKind::Binary),
-        op(op), left(left), right(right) {}
+        AssertionExpr(AssertionExprKind::Binary), op(op), left(left), right(right) {}
 
     void requireSequence(const ASTContext& context, DiagCode code) const;
     bool admitsEmptyImpl() const;
@@ -347,8 +345,7 @@ class SLANG_EXPORT FirstMatchAssertionExpr : public AssertionExpr {
 
     FirstMatchAssertionExpr(const AssertionExpr& seq,
                             std::span<const Expression* const> matchItems) :
-        AssertionExpr(AssertionExprKind::FirstMatch),
-        seq(seq), matchItems(matchItems) {}
+        AssertionExpr(AssertionExprKind::FirstMatch), seq(seq), matchItems(matchItems) {}
 
     bool admitsEmptyImpl() const;
 
@@ -435,8 +432,8 @@ class SLANG_EXPORT AbortAssertionExpr : public AssertionExpr {
 
     AbortAssertionExpr(const Expression& condition, const AssertionExpr& expr, Action action,
                        bool isSync) :
-        AssertionExpr(AssertionExprKind::Abort),
-        condition(condition), expr(expr), action(action), isSync(isSync) {}
+        AssertionExpr(AssertionExprKind::Abort), condition(condition), expr(expr), action(action),
+        isSync(isSync) {}
 
     bool admitsEmptyImpl() const { return false; }
 
@@ -463,8 +460,8 @@ class SLANG_EXPORT ConditionalAssertionExpr : public AssertionExpr {
 
     ConditionalAssertionExpr(const Expression& condition, const AssertionExpr& ifExpr,
                              const AssertionExpr* elseExpr) :
-        AssertionExpr(AssertionExprKind::Conditional),
-        condition(condition), ifExpr(ifExpr), elseExpr(elseExpr) {}
+        AssertionExpr(AssertionExprKind::Conditional), condition(condition), ifExpr(ifExpr),
+        elseExpr(elseExpr) {}
 
     bool admitsEmptyImpl() const { return false; }
 
@@ -498,8 +495,8 @@ class SLANG_EXPORT CaseAssertionExpr : public AssertionExpr {
 
     CaseAssertionExpr(const Expression& expr, std::span<const ItemGroup> items,
                       const AssertionExpr* defaultCase) :
-        AssertionExpr(AssertionExprKind::Case),
-        expr(expr), items(items), defaultCase(defaultCase) {}
+        AssertionExpr(AssertionExprKind::Case), expr(expr), items(items), defaultCase(defaultCase) {
+    }
 
     bool admitsEmptyImpl() const { return false; }
 

include/slang/ast/expressions/AssignmentExpressions.h

@@ -24,9 +24,8 @@ class SLANG_EXPORT AssignmentExpression : public Expression {
     AssignmentExpression(std::optional<BinaryOperator> op, bool nonBlocking, const Type& type,
                          Expression& left, Expression& right, const TimingControl* timingControl,
                          SourceRange sourceRange) :
-        Expression(ExpressionKind::Assignment, type, sourceRange),
-        op(op), timingControl(timingControl), left_(&left), right_(&right),
-        nonBlocking(nonBlocking) {}
+        Expression(ExpressionKind::Assignment, type, sourceRange), op(op),
+        timingControl(timingControl), left_(&left), right_(&right), nonBlocking(nonBlocking) {}
 
     bool isCompound() const { return op.has_value(); }
     bool isNonBlocking() const { return nonBlocking; }
@@ -86,8 +85,8 @@ class SLANG_EXPORT ConversionExpression : public Expression {
 
     ConversionExpression(const Type& type, ConversionKind conversionKind, Expression& operand,
                          SourceRange sourceRange) :
-        Expression(ExpressionKind::Conversion, type, sourceRange),
-        conversionKind(conversionKind), operand_(&operand) {}
+        Expression(ExpressionKind::Conversion, type, sourceRange), conversionKind(conversionKind),
+        operand_(&operand) {}
 
     bool isImplicit() const { return conversionKind < ConversionKind::Explicit; }
 
@@ -131,8 +130,8 @@ class SLANG_EXPORT NewArrayExpression : public Expression {
 public:
     NewArrayExpression(const Type& type, const Expression& sizeExpr, const Expression* initializer,
                        SourceRange sourceRange) :
-        Expression(ExpressionKind::NewArray, type, sourceRange),
-        sizeExpr_(&sizeExpr), initializer_(initializer) {}
+        Expression(ExpressionKind::NewArray, type, sourceRange), sizeExpr_(&sizeExpr),
+        initializer_(initializer) {}
 
     const Expression& sizeExpr() const { return *sizeExpr_; }
     const Expression* initExpr() const { return initializer_; }
@@ -167,8 +166,8 @@ class SLANG_EXPORT NewClassExpression : public Expression {
 
     NewClassExpression(const Type& type, const Expression* constructorCall, bool isSuperClass,
                        SourceRange sourceRange) :
-        Expression(ExpressionKind::NewClass, type, sourceRange),
-        isSuperClass(isSuperClass), constructorCall_(constructorCall) {}
+        Expression(ExpressionKind::NewClass, type, sourceRange), isSuperClass(isSuperClass),
+        constructorCall_(constructorCall) {}
 
     const Expression* constructorCall() const { return constructorCall_; }
 
@@ -199,8 +198,7 @@ class SLANG_EXPORT NewCovergroupExpression : public Expression {
 
     NewCovergroupExpression(const Type& type, std::span<const Expression* const> arguments,
                             SourceRange sourceRange) :
-        Expression(ExpressionKind::NewCovergroup, type, sourceRange),
-        arguments(arguments) {}
+        Expression(ExpressionKind::NewCovergroup, type, sourceRange), arguments(arguments) {}
 
     ConstantValue evalImpl(EvalContext& context) const;
 
@@ -238,8 +236,7 @@ class SLANG_EXPORT AssignmentPatternExpressionBase : public Expression {
     AssignmentPatternExpressionBase(ExpressionKind kind, const Type& type,
                                     std::span<const Expression* const> elements,
                                     SourceRange sourceRange) :
-        Expression(kind, type, sourceRange),
-        elements_(elements) {}
+        Expression(kind, type, sourceRange), elements_(elements) {}
 
 private:
     std::span<const Expression* const> elements_;

include/slang/ast/expressions/CallExpression.h

@@ -42,9 +42,8 @@ class SLANG_EXPORT CallExpression : public Expression {
     CallExpression(const Subroutine& subroutine, const Type& returnType,
                    const Expression* thisClass, std::span<const Expression*> arguments,
                    LookupLocation lookupLocation, SourceRange sourceRange) :
-        Expression(ExpressionKind::Call, returnType, sourceRange),
-        subroutine(subroutine), thisClass_(thisClass), arguments_(arguments),
-        lookupLocation(lookupLocation) {}
+        Expression(ExpressionKind::Call, returnType, sourceRange), subroutine(subroutine),
+        thisClass_(thisClass), arguments_(arguments), lookupLocation(lookupLocation) {}
 
     /// If this call is for a class method, returns the expression representing the
     /// class handle on which the method is being invoked. Otherwise returns nullptr.