Always use return in formatter

.JuliaFormatter.toml

@@ -6,3 +6,5 @@ yas_style_nesting = true
 
 # Align struct fields for better readability of large struct definitions
 align_struct_field = true
+
+always_use_return = true

benchmark/benchmarks.jl

@@ -23,6 +23,7 @@ for elixir in elixirs
     println("Running $benchname...")
     redirect_stdout(devnull) do
         trixi_include(@__MODULE__, elixir, tspan = (0.0, 1e-11))
+        return nothing
     end
     SUITE[benchname] = @benchmarkable DispersiveShallowWater.rhs!($(similar(sol.u[end])),
                                                                   $(copy(sol.u[end])),

src/boundary_conditions.jl

@@ -18,4 +18,5 @@ const boundary_condition_reflecting = BoundaryConditionReflecting()
 
 function Base.show(io::IO, ::BoundaryConditionReflecting)
     print(io, "boundary_condition_reflecting")
+    return nothing
 end

src/callbacks_step/analysis.jl

@@ -37,6 +37,7 @@ function Base.show(io::IO, cb::DiscreteCallback{<:Any, <:AnalysisCallback})
     analysis_callback = cb.affect!
     @unpack interval = analysis_callback
     print(io, "AnalysisCallback(interval=", interval, ")")
+    return nothing
 end
 
 function Base.show(io::IO, ::MIME"text/plain",
@@ -62,7 +63,7 @@ end
 
 function AnalysisCallback(semi::Semidiscretization; kwargs...)
     mesh, equations, solver = mesh_equations_solver(semi)
-    AnalysisCallback(mesh, equations, solver; kwargs...)
+    return AnalysisCallback(mesh, equations, solver; kwargs...)
 end
 
 function AnalysisCallback(mesh, equations::AbstractEquations, solver;
@@ -96,9 +97,9 @@ function AnalysisCallback(mesh, equations::AbstractEquations, solver;
                                          Vector{Vector{real(solver)}}(),
                                          io)
 
-    DiscreteCallback(condition, analysis_callback,
-                     save_positions = (false, false),
-                     initialize = initialize!)
+    return DiscreteCallback(condition, analysis_callback,
+                            save_positions = (false, false),
+                            initialize = initialize!)
 end
 
 """
@@ -318,7 +319,7 @@ end
 # terminate the type-stable iteration over tuples
 function analyze_integrals!(io, current_integrals, i, analysis_integrals::Tuple{}, q, t,
                             semi)
-    nothing
+    return nothing
 end
 
 # used for error checks and EOC analysis
@@ -333,7 +334,7 @@ function (cb::DiscreteCallback{Condition, Affect!})(sol) where {Condition,
 end
 
 function analyze!(semi::Semidiscretization, quantity, q, t)
-    integrate_quantity!(semi.cache.tmp1, quantity, q, semi)
+    return integrate_quantity!(semi.cache.tmp1, quantity, q, semi)
 end
 
 pretty_form_utf(::typeof(waterheight)) = "∫h"

src/callbacks_step/relaxation.jl

@@ -21,6 +21,7 @@ function Base.show(io::IO, cb::DiscreteCallback{<:Any, <:RelaxationCallback})
     relaxation_callback = cb.affect!
     @unpack invariant = relaxation_callback
     print(io, "RelaxationCallback(invariant=", string(nameof(invariant)), ")")
+    return nothing
 end
 
 function Base.show(io::IO, ::MIME"text/plain",
@@ -40,9 +41,9 @@ end
 function RelaxationCallback(; invariant)
     relaxation_callback = RelaxationCallback(invariant)
 
-    DiscreteCallback(relaxation_callback, relaxation_callback, # the first one is the condition, the second the affect!
-                     save_positions = (false, false),
-                     initialize = initialize!)
+    return DiscreteCallback(relaxation_callback, relaxation_callback, # the first one is the condition, the second the affect!
+                            save_positions = (false, false),
+                            initialize = initialize!)
 end
 
 function initialize!(cb::DiscreteCallback{Condition, Affect!}, u, t,

src/callbacks_step/summary.jl

@@ -9,26 +9,27 @@ struct SummaryCallback
 
     function SummaryCallback(io::IO = stdout)
         function initialize(cb, u, t, integrator)
-            initialize_summary_callback(cb, u, t, integrator)
+            return initialize_summary_callback(cb, u, t, integrator)
         end
         # At the end of the simulation, the timer is printed
         function finalize(cb, u, t, integrator)
-            finalize_summary_callback(cb, u, t, integrator)
+            return finalize_summary_callback(cb, u, t, integrator)
         end
         summary_callback = new(io)
         # SummaryCallback is never called during the simulation
         condition = (u, t, integrator) -> false
-        DiscreteCallback(condition, summary_callback,
-                         save_positions = (false, false),
-                         initialize = initialize,
-                         finalize = finalize)
+        return DiscreteCallback(condition, summary_callback,
+                                save_positions = (false, false),
+                                initialize = initialize,
+                                finalize = finalize)
     end
 end
 
 function Base.show(io::IO, cb::DiscreteCallback{<:Any, <:SummaryCallback})
     @nospecialize cb # reduce precompilation time
 
     print(io, "SummaryCallback")
+    return nothing
 end
 
 function initialize_summary_callback(cb::DiscreteCallback, u, t, integrator)

src/dispersion_relation.jl

@@ -15,6 +15,7 @@ end
 
 function Base.show(io::IO, disp_rel::LinearDispersionRelation)
     print(io, "LinearDispersionRelation(h0 = ", disp_rel.ref_height, ")")
+    return nothing
 end
 
 Base.broadcastable(disp_rel::LinearDispersionRelation) = (disp_rel,)

src/equations/bbm_1d.jl

@@ -50,7 +50,7 @@ end
 
 function BBMEquation1D(; gravity, D = 1.0, eta0 = 0.0, split_form = true)
     eta0 == 0.0 || @warn "The still-water surface needs to be 0 for the BBM equations"
-    BBMEquation1D(gravity, D, eta0, split_form)
+    return BBMEquation1D(gravity, D, eta0, split_form)
 end
 
 function check_solver(::BBMEquation1D, solver, boundary_conditions)

src/equations/bbm_bbm_1d.jl

@@ -61,7 +61,7 @@ end
 function BBMBBMEquations1D(; bathymetry_type = bathymetry_variable,
                            gravity, eta0 = 0.0)
     eta0 == 0.0 || @warn "The still-water surface needs to be 0 for the BBM-BBM equations"
-    BBMBBMEquations1D(bathymetry_type, gravity, eta0)
+    return BBMBBMEquations1D(bathymetry_type, gravity, eta0)
 end
 
 function check_solver(::BBMBBMEquations1D, solver, boundary_conditions)

src/equations/equations.jl

@@ -569,23 +569,24 @@ function solve_system_matrix!(dv, system_matrix, rhs,
                                                SerreGreenNaghdiEquations1D},
                               D1, cache, ::BoundaryConditionPeriodic)
     scale_by_mass_matrix!(rhs, D1)
-    solve_system_matrix!(dv, system_matrix, rhs, equations, D1, cache)
+    return solve_system_matrix!(dv, system_matrix, rhs, equations, D1, cache)
 end
 
 function solve_system_matrix!(dv, system_matrix, rhs,
                               equations::SvaerdKalischEquations1D,
                               D1, cache, ::BoundaryConditionReflecting)
     scale_by_mass_matrix!(rhs, D1)
-    solve_system_matrix!(dv, system_matrix, (@view rhs[(begin + 1):(end - 1)]), equations,
-                         D1, cache)
+    return solve_system_matrix!(dv, system_matrix, (@view rhs[(begin + 1):(end - 1)]),
+                                equations,
+                                D1, cache)
 end
 
 function solve_system_matrix!(dv, system_matrix, rhs,
                               equations::SerreGreenNaghdiEquations1D,
                               D1, cache, ::BoundaryConditionReflecting)
     scale_by_mass_matrix!(rhs, D1)
     rhs[begin] = rhs[end] = 0
-    solve_system_matrix!(dv, system_matrix, rhs, equations, D1, cache)
+    return solve_system_matrix!(dv, system_matrix, rhs, equations, D1, cache)
 end
 
 function solve_system_matrix!(dv, system_matrix, rhs,
@@ -611,7 +612,7 @@ function solve_system_matrix!(dv, system_matrix, rhs,
 end
 
 function solve_system_matrix!(dv, system_matrix, ::Union{BBMEquation1D, BBMBBMEquations1D})
-    ldiv!(system_matrix, dv)
+    return ldiv!(system_matrix, dv)
 end
 
 # To match the experimental data from Dingemans, the initial condition needs to be shifted

src/equations/hyperbolic_serre_green_naghdi_1d.jl

@@ -98,7 +98,7 @@ function HyperbolicSerreGreenNaghdiEquations1D(; bathymetry_type = bathymetry_mi
                                                gravity,
                                                eta0 = 0.0,
                                                lambda)
-    HyperbolicSerreGreenNaghdiEquations1D(bathymetry_type, gravity, eta0, lambda)
+    return HyperbolicSerreGreenNaghdiEquations1D(bathymetry_type, gravity, eta0, lambda)
 end
 
 function varnames(::typeof(prim2prim), ::HyperbolicSerreGreenNaghdiEquations1D)

src/equations/kdv_1d.jl

@@ -50,7 +50,7 @@ end
 
 function KdVEquation1D(; gravity, D = 1.0, eta0 = 0.0)
     eta0 == 0.0 || @warn "The still-water surface needs to be 0 for the KdV equations"
-    KdVEquation1D(gravity, D, eta0)
+    return KdVEquation1D(gravity, D, eta0)
 end
 
 function check_solver(::KdVEquation1D, solver, boundary_conditions)

src/equations/serre_green_naghdi_1d.jl

@@ -78,7 +78,7 @@ end
 
 function SerreGreenNaghdiEquations1D(; bathymetry_type = bathymetry_variable,
                                      gravity, eta0 = 0.0)
-    SerreGreenNaghdiEquations1D(bathymetry_type, gravity, eta0)
+    return SerreGreenNaghdiEquations1D(bathymetry_type, gravity, eta0)
 end
 
 """

src/equations/svaerd_kalisch_1d.jl

@@ -72,7 +72,7 @@ const SvärdKalischEquations1D = SvaerdKalischEquations1D
 
 function SvaerdKalischEquations1D(; bathymetry_type = bathymetry_variable, gravity,
                                   eta0 = 0.0, alpha = 0.0, beta = 1 / 3, gamma = 0.0)
-    SvaerdKalischEquations1D(bathymetry_type, gravity, eta0, alpha, beta, gamma)
+    return SvaerdKalischEquations1D(bathymetry_type, gravity, eta0, alpha, beta, gamma)
 end
 
 function check_solver(::SvaerdKalischEquations1D, solver, ::BoundaryConditionPeriodic)

src/mesh.jl

@@ -11,7 +11,7 @@ struct Mesh1D{RealT}
     function Mesh1D{RealT}(xmin::RealT, xmax::RealT, N::Int) where {RealT}
         @assert xmin < xmax
         @assert N > 0
-        new(xmin, xmax, N)
+        return new(xmin, xmax, N)
     end
 end
 
@@ -22,11 +22,12 @@ Create a simple homogeneous one-dimensional mesh from `xmin` to `xmax` with `N`
 """
 function Mesh1D(xmin, xmax, N)
     xmin, xmax = promote(xmin, xmax)
-    Mesh1D{typeof(xmin)}(xmin, xmax, N)
+    return Mesh1D{typeof(xmin)}(xmin, xmax, N)
 end
 
 function Base.show(io::IO, mesh::Mesh1D{RealT}) where {RealT}
     print(io, "Mesh1D{", RealT, "} with length ", mesh.N)
+    return nothing
 end
 
 function Base.show(io::IO, ::MIME"text/plain", mesh::Mesh1D{RealT}) where {RealT}

src/semidiscretization.jl

@@ -35,8 +35,8 @@ struct Semidiscretization{Mesh, Equations, InitialCondition, BoundaryConditions,
         @assert xmax(mesh) == xmax(solver.D1)
         @assert nnodes(mesh) == length(grid(solver))
 
-        new(mesh, equations, initial_condition, boundary_conditions, source_terms, solver,
-            cache)
+        return new(mesh, equations, initial_condition, boundary_conditions, source_terms,
+                   solver, cache)
     end
 end
 
@@ -82,20 +82,22 @@ function Semidiscretization(mesh, equations, initial_condition, solver;
                           RealT, uEltype)...,
              initial_cache...)
 
-    Semidiscretization{typeof(mesh), typeof(equations), typeof(initial_condition),
-                       typeof(boundary_conditions), typeof(source_terms),
-                       typeof(solver), typeof(cache)}(mesh, equations, initial_condition,
-                                                      boundary_conditions, source_terms,
-                                                      solver, cache)
+    return Semidiscretization{typeof(mesh), typeof(equations), typeof(initial_condition),
+                              typeof(boundary_conditions), typeof(source_terms),
+                              typeof(solver), typeof(cache)}(mesh, equations,
+                                                             initial_condition,
+                                                             boundary_conditions,
+                                                             source_terms,
+                                                             solver, cache)
 end
 
 """
     check_solver(equations, solver, boundary_conditions)
 
-Check that the `solver` is compatible with the given `equations` and 
+Check that the `solver` is compatible with the given `equations` and
 `boundary_conditions`. The default implementation performs no checks.
-Specific equation types can override this method to validate that 
-required derivative operators are present (e.g., some equations 
+Specific equation types can override this method to validate that
+required derivative operators are present (e.g., some equations
 require `D2` or `D3` to be non-`nothing`).
 
 Throws an `ArgumentError` if the solver is incompatible.
@@ -118,6 +120,7 @@ function Base.show(io::IO, semi::Semidiscretization)
         print(io, key)
     end
     print(io, "))")
+    return nothing
 end
 
 function Base.show(io::IO, ::MIME"text/plain", semi::Semidiscretization)
@@ -158,22 +161,22 @@ function PolynomialBases.integrate(func, q::ArrayPartition, semi::Semidiscretiza
     return integrals
 end
 function PolynomialBases.integrate(func, quantity, semi::Semidiscretization)
-    integrate(func, quantity, semi.solver.D1)
+    return integrate(func, quantity, semi.solver.D1)
 end
 function PolynomialBases.integrate(q, semi::Semidiscretization)
-    integrate(identity, q, semi)
+    return integrate(identity, q, semi)
 end
 
 function integrate_quantity(func, q, semi)
     quantity = zeros(eltype(q), nnodes(semi))
-    integrate_quantity!(quantity, func, q, semi)
+    return integrate_quantity!(quantity, func, q, semi)
 end
 
 function integrate_quantity!(quantity, func, q, semi)
     for i in eachnode(semi)
         quantity[i] = func(get_node_vars(q, semi.equations, i), semi.equations)
     end
-    integrate(quantity, semi)
+    return integrate(quantity, semi)
 end
 
 # Obtain the function, which has an additional `!` appended to the name
@@ -188,7 +191,7 @@ function integrate_quantity!(quantity,
                                          typeof(hamiltonian)}, q,
                              semi)
     inplace_version(func)(quantity, q, semi.equations, semi.cache)
-    integrate(quantity, semi)
+    return integrate(quantity, semi)
 end
 
 @inline function mesh_equations_solver(semi)
@@ -202,7 +205,7 @@ end
 end
 
 function calc_error_norms(q, t, semi)
-    calc_error_norms(q, t, semi.initial_condition, mesh_equations_solver(semi)...)
+    return calc_error_norms(q, t, semi.initial_condition, mesh_equations_solver(semi)...)
 end
 
 function rhs!(dq, q, semi, t)
@@ -224,9 +227,9 @@ end
 function compute_coefficients!(q, func, t, semi)
     # Call `compute_coefficients` defined by the solver
     mesh, equations, solver = mesh_equations_solver(semi)
-    compute_coefficients!(q, func, t, mesh,
-                          is_hyperbolic_appproximation(equations), equations,
-                          solver)
+    return compute_coefficients!(q, func, t, mesh,
+                                 is_hyperbolic_appproximation(equations), equations,
+                                 solver)
 end
 
 check_bathymetry(equations, q0) = nothing
@@ -271,6 +274,7 @@ function jacobian(semi::Semidiscretization;
                   q0 = compute_coefficients(semi.initial_condition, t, semi))
     J = ForwardDiff.jacobian(similar(q0), q0) do dq, q
         DispersiveShallowWater.rhs!(dq, q, semi, t)
+        return nothing
     end
     return J
 end