Use @verbosity_specifier macro for NonlinearVerbosity

ChrisRackauckas · claude · ChrisRackauckas · commit 98926c12ef22 · 2025-12-18T08:07:14.000-05:00
Replace the manual NonlinearVerbosity struct definition with the @verbosity_specifier macro from SciMLLogging.jl. This simplifies the code by letting the macro auto-generate: - The struct definition with toggles as fields - Preset constructors (None, Minimal, Standard, Detailed, All) - Group-level keyword constructors (error_control, numerical) - Individual field keyword constructors - Mixed group and individual settings support Changes: - lib/NonlinearSolveBase/src/verbosity.jl: Use @verbosity_specifier macro - lib/NonlinearSolveBase/src/NonlinearSolveBase.jl: Import @verbosity_specifier - Project.toml, lib/NonlinearSolveBase/Project.toml: Bump SciMLLogging to 1.7 - test/verbosity_tests.jl: Use regex matching for log messages 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
diff --git a/Project.toml b/Project.toml
@@ -118,7 +118,7 @@ Reexport = "1.2.2"
 ReverseDiff = "1.15"
 SIAMFANLEquations = "1.0.1"
 SciMLBase = "2.127"
-SciMLLogging = "1.3"
+SciMLLogging = "1.7"
 SimpleNonlinearSolve = "2.11"
 SparseArrays = "1.10"
 SparseConnectivityTracer = "1"
diff --git a/lib/NonlinearSolveBase/Project.toml b/lib/NonlinearSolveBase/Project.toml
@@ -84,7 +84,7 @@ RecursiveArrayTools = "3"
 ReverseDiff = "1.15"
 SciMLBase = "2.127"
 SciMLJacobianOperators = "0.1.1"
-SciMLLogging = "1.3.1"
+SciMLLogging = "1.7"
 SciMLOperators = "1.7"
 SciMLStructures = "1.5"
 Setfield = "1.1.2"
diff --git a/lib/NonlinearSolveBase/src/NonlinearSolveBase.jl b/lib/NonlinearSolveBase/src/NonlinearSolveBase.jl
@@ -28,8 +28,9 @@ import SciMLBase: solve, init, __init, __solve, wrap_sol, get_root_indp, isinpla
 
 using SciMLJacobianOperators: JacobianOperator, StatefulJacobianOperator
 using SciMLOperators: AbstractSciMLOperator, IdentityOperator
-using SciMLLogging: @SciMLMessage, AbstractVerbositySpecifier, AbstractVerbosityPreset, AbstractMessageLevel, 
-                None, Minimal, Standard, Detailed, All, Silent, InfoLevel, WarnLevel
+using SciMLLogging: @SciMLMessage, @verbosity_specifier, AbstractVerbositySpecifier,
+                    AbstractVerbosityPreset, AbstractMessageLevel,
+                    None, Minimal, Standard, Detailed, All, Silent, InfoLevel, WarnLevel
 
 using SymbolicIndexingInterface: SymbolicIndexingInterface
 import SciMLStructures
diff --git a/lib/NonlinearSolveBase/src/verbosity.jl b/lib/NonlinearSolveBase/src/verbosity.jl
@@ -29,7 +29,7 @@ Create a `NonlinearVerbosity` using a preset configuration:
 - `SciMLLogging.Detailed()`: Comprehensive debugging information
 - `SciMLLogging.All()`: Maximum verbosity
 
-    NonlinearVerbosity(; error_control=nothing, performance=nothing, numerical=nothing, linear_verbosity=nothing, kwargs...)
+    NonlinearVerbosity(; error_control=nothing, numerical=nothing, linear_verbosity=nothing, kwargs...)
 
 Create a `NonlinearVerbosity` with group-level or individual field control.
 
@@ -58,176 +58,58 @@ verbose = NonlinearVerbosity(
 )
 ```
 """
-@concrete struct NonlinearVerbosity <: AbstractVerbositySpecifier
-    # Linear verbosity
-    linear_verbosity
-    # Error control
-    non_enclosing_interval
-    alias_u0_immutable
-    linsolve_failed_noncurrent
-    termination_condition
-    # Numerical
-    threshold_state
-end
-
-# Group classifications
-const error_control_options = (
-    :non_enclosing_interval, :alias_u0_immutable, :linsolve_failed_noncurrent,
-    :termination_condition
-)
-const performance_options = ()
-const numerical_options = (:threshold_state,)
-
-function option_group(option::Symbol)
-    if option in error_control_options
-        return :error_control
-    elseif option in performance_options
-        return :performance
-    elseif option in numerical_options
-        return :numerical
-    else
-        error("Unknown verbosity option: $option")
-    end
-end
-
-# Get all options in a group
-function group_options(verbosity::NonlinearVerbosity, group::Symbol)
-    if group === :error_control
-        return NamedTuple{error_control_options}(getproperty(verbosity, opt)
-                                                 for opt in error_control_options)
-    elseif group === :performance
-        return NamedTuple{performance_options}(getproperty(verbosity, opt)
-                                               for opt in performance_options)
-    elseif group === :numerical
-        return NamedTuple{numerical_options}(getproperty(verbosity, opt)
-                                             for opt in numerical_options)
-    else
-        error("Unknown group: $group")
-    end
-end
-
-function NonlinearVerbosity(;
-        error_control = nothing, performance = nothing, numerical = nothing,
-        linear_verbosity = nothing, kwargs...)
-    # Validate group arguments
-    if error_control !== nothing && !(error_control isa AbstractMessageLevel)
-        throw(ArgumentError("error_control must be a SciMLLogging.AbstractMessageLevel, got $(typeof(error_control))"))
-    end
-    if performance !== nothing && !(performance isa AbstractMessageLevel)
-        throw(ArgumentError("performance must be a SciMLLogging.AbstractMessageLevel, got $(typeof(performance))"))
-    end
-    if numerical !== nothing && !(numerical isa AbstractMessageLevel)
-        throw(ArgumentError("numerical must be a SciMLLogging.AbstractMessageLevel, got $(typeof(numerical))"))
-    end
-
-    # Validate individual kwargs
-    for (key, value) in kwargs
-        if !(key in error_control_options || key in performance_options ||
-             key in numerical_options)
-            throw(ArgumentError("Unknown verbosity option: $key. Valid options are: $(tuple(error_control_options..., performance_options..., numerical_options...))"))
-        end
-        if !(value isa AbstractMessageLevel)
-            throw(ArgumentError("$key must be a SciMLLogging.AbstractMessageLevel, got $(typeof(value))"))
-        end
-    end
-
-    # Build arguments using NamedTuple for type stability
-    # Use None() for linear_verbosity by default since BLAS errors are not fatal
-    # in the nonlinear solver context (the solver handles singular matrices gracefully)
-    default_args = (
-        linear_verbosity = linear_verbosity === nothing ? None() : linear_verbosity,
-        non_enclosing_interval = WarnLevel(),
-        alias_u0_immutable = WarnLevel(),
-        linsolve_failed_noncurrent = WarnLevel(),
-        termination_condition = WarnLevel(),
-        threshold_state = WarnLevel()
-    )
-
-    # Apply group-level settings
-    final_args = if error_control !== nothing || performance !== nothing ||
-                    numerical !== nothing
-        NamedTuple{keys(default_args)}(
-            _resolve_arg_value(
-                key, default_args[key], error_control, performance, numerical)
-        for key in keys(default_args)
-        )
-    else
-        default_args
-    end
+NonlinearVerbosity
 
-    # Apply individual overrides
-    if !isempty(kwargs)
-        final_args = merge(final_args, NamedTuple(kwargs))
-    end
+@verbosity_specifier NonlinearVerbosity begin
+    toggles = (:linear_verbosity, :non_enclosing_interval, :alias_u0_immutable,
+        :linsolve_failed_noncurrent, :termination_condition, :threshold_state)
 
-    NonlinearVerbosity(values(final_args)...)
-end
-
-# Constructor for verbosity presets following the hierarchical levels:
-# None < Minimal < Standard < Detailed < All
-# Each level includes all messages from levels below it plus additional ones
-function NonlinearVerbosity(verbose::AbstractVerbosityPreset)
-    if verbose isa Minimal
-        # Minimal: Only fatal errors and critical warnings
-        # Use None() for linear_verbosity since BLAS errors are not fatal
-        # in the nonlinear solver context (the solver handles singular matrices gracefully)
-        NonlinearVerbosity(
+    presets = (
+        None = (
+            linear_verbosity = None(),
+            non_enclosing_interval = Silent(),
+            alias_u0_immutable = Silent(),
+            linsolve_failed_noncurrent = Silent(),
+            termination_condition = Silent(),
+            threshold_state = Silent()
+        ),
+        Minimal = (
             linear_verbosity = None(),
             non_enclosing_interval = WarnLevel(),
             alias_u0_immutable = Silent(),
             linsolve_failed_noncurrent = WarnLevel(),
             termination_condition = Silent(),
             threshold_state = Silent()
-        )
-    elseif verbose isa Standard
-        # Standard: Everything from Minimal + non-fatal warnings
-        NonlinearVerbosity()
-    elseif verbose isa Detailed
-        # Detailed: Everything from Standard + debugging/solver behavior
-        NonlinearVerbosity(
+        ),
+        Standard = (
+            linear_verbosity = None(),
+            non_enclosing_interval = WarnLevel(),
+            alias_u0_immutable = WarnLevel(),
+            linsolve_failed_noncurrent = WarnLevel(),
+            termination_condition = WarnLevel(),
+            threshold_state = WarnLevel()
+        ),
+        Detailed = (
             linear_verbosity = Detailed(),
             non_enclosing_interval = WarnLevel(),
             alias_u0_immutable = WarnLevel(),
             linsolve_failed_noncurrent = WarnLevel(),
             termination_condition = WarnLevel(),
             threshold_state = WarnLevel()
-        )
-    elseif verbose isa All
-        # All: Maximum verbosity - every possible logging message at InfoLevel
-        NonlinearVerbosity(
+        ),
+        All = (
             linear_verbosity = Detailed(),
             non_enclosing_interval = WarnLevel(),
             alias_u0_immutable = WarnLevel(),
             linsolve_failed_noncurrent = WarnLevel(),
             termination_condition = WarnLevel(),
             threshold_state = InfoLevel()
         )
-    end
-end
+    )
 
-@inline function NonlinearVerbosity(verbose::None)
-    NonlinearVerbosity(
-        None(),
-        Silent(),
-        Silent(),
-        Silent(),
-        Silent(),
-        Silent()
+    groups = (
+        error_control = (:non_enclosing_interval, :alias_u0_immutable,
+            :linsolve_failed_noncurrent, :termination_condition),
+        numerical = (:threshold_state,)
     )
 end
-
-# Helper function to resolve argument values based on group membership
-@inline function _resolve_arg_value(
-        key::Symbol, default_val, error_control, performance, numerical)
-    if key === :linear_verbosity
-        return default_val
-    elseif key in error_control_options && error_control !== nothing
-        return error_control
-    elseif key in performance_options && performance !== nothing
-        return performance
-    elseif key in numerical_options && numerical !== nothing
-        return numerical
-    else
-        return default_val
-    end
-end
diff --git a/test/verbosity_tests.jl b/test/verbosity_tests.jl
@@ -74,12 +74,12 @@
     int_prob = IntervalNonlinearProblem(g, (3.0, 5.0))
 
     @test_logs (:info,
-        "The interval is not an enclosing interval, opposite signs at the boundaries are required.") solve(
+        r"The interval is not an enclosing interval, opposite signs at the boundaries are required.") solve(
         int_prob,
         ITP(), verbose = NonlinearVerbosity(non_enclosing_interval = SciMLLogging.InfoLevel()))
 
-        @test_logs (:error,
-        "The interval is not an enclosing interval, opposite signs at the boundaries are required.") @test_throws ErrorException solve(
+    @test_logs (:error,
+        r"The interval is not an enclosing interval, opposite signs at the boundaries are required.") @test_throws ErrorException solve(
         int_prob,
         ITP(), verbose = NonlinearVerbosity(non_enclosing_interval = SciMLLogging.ErrorLevel()))
 
@@ -88,12 +88,12 @@
     prob = NonlinearProblem(f, [1.0, 1.0])
 
     @test_logs (:warn,
-        "LU factorization failed, falling back to QR factorization. `A` is potentially rank-deficient.") match_mode=:any solve(
+        r"LU factorization failed, falling back to QR factorization. `A` is potentially rank-deficient.") match_mode=:any solve(
         prob,
         verbose = NonlinearVerbosity(linear_verbosity = SciMLLogging.Detailed()))
 
     @test_logs (:info,
-        "LU factorization failed, falling back to QR factorization. `A` is potentially rank-deficient.") match_mode=:any solve(
+        r"LU factorization failed, falling back to QR factorization. `A` is potentially rank-deficient.") match_mode=:any solve(
         prob,
         verbose = NonlinearVerbosity(linear_verbosity = LinearVerbosity(default_lu_fallback = SciMLLogging.InfoLevel())))
 
@@ -102,7 +102,7 @@
         verbose = NonlinearVerbosity(linear_verbosity = SciMLLogging.Standard()))
 
     @test_logs (:warn,
-        "LU factorization failed, falling back to QR factorization. `A` is potentially rank-deficient.") match_mode=:any solve(
+        r"LU factorization failed, falling back to QR factorization. `A` is potentially rank-deficient.") match_mode=:any solve(
         prob,
         verbose = NonlinearVerbosity(linear_verbosity = SciMLLogging.Detailed())
     )
