fix formatting

Author: vchuravy

src/auxiliary/containers.jl

@@ -339,11 +339,11 @@ end
 # However, since zero length arrays are not used in calculations,
 # it should be okay if the underlying storage vectors and wrapped arrays
 # are not the same as long as they are properly wrapped when `resize!`d etc.
-function unsafe_wrap_or_alloc(to, vec, size)
-    if length(vec) == 0
-        return similar(vec, size)
+function unsafe_wrap_or_alloc(to, vector, size)
+    if length(vector) == 0
+        return similar(vector, size)
     else
-        return unsafe_wrap(to, pointer(vec), size)
+        return unsafe_wrap(to, pointer(vector), size)
     end
 end
 
@@ -355,25 +355,32 @@ end
 
 # Custom rules
 # 1. handling of StaticArrays
-function Adapt.adapt_storage(::TrixiAdaptor{<:Any, Real}, x::StaticArrays.StaticArray{S, T, N}) where {Real,S,T,N}
+function Adapt.adapt_storage(::TrixiAdaptor{<:Any, Real},
+                             x::StaticArrays.StaticArray{S, T, N}) where {Real, S, T, N}
     StaticArrays.similar_type(x, Real)(x)
 end
 
 # 2. Handling of Arrays
-function Adapt.adapt_storage(::TrixiAdaptor{Storage, Real}, x::AbstractArray{T}) where{Storage, Real, T<:AbstractFloat}
+function Adapt.adapt_storage(::TrixiAdaptor{Storage, Real},
+                             x::AbstractArray{T}) where {Storage, Real,
+                                                         T <: AbstractFloat}
     adapt(Storage{Real}, x)
 end
 
-function Adapt.adapt_storage(::TrixiAdaptor{Storage, Real}, x::AbstractArray{T}) where {Storage, Real,T<:StaticArrays.StaticArray}
-    adapt(Storage{StaticArrays.similar_type(T, Real)},x)
+function Adapt.adapt_storage(::TrixiAdaptor{Storage, Real},
+                             x::AbstractArray{T}) where {Storage, Real,
+                                                         T <: StaticArrays.StaticArray}
+    adapt(Storage{StaticArrays.similar_type(T, Real)}, x)
 end
 
-function Adapt.adapt_storage(::TrixiAdaptor{Storage, Real}, x::AbstractArray) where{Storage, Real}
+function Adapt.adapt_storage(::TrixiAdaptor{Storage, Real},
+                             x::AbstractArray) where {Storage, Real}
     adapt(Storage, x)
 end
 
 # 3. TODO: Should we have a fallback? But that would imply implementing things for NamedTuple again
 
-unsafe_wrap_or_alloc(::TrixiAdaptor{Storage}, vec, size) where {Storage} = unsafe_wrap_or_alloc(Storage, vec, size)
-
+function unsafe_wrap_or_alloc(::TrixiAdaptor{Storage}, vec, size) where {Storage}
+    return unsafe_wrap_or_alloc(Storage, vec, size)
+end
 end # @muladd

src/solvers/dgsem/basis_lobatto_legendre.jl

@@ -44,7 +44,7 @@ function Adapt.adapt_structure(to, basis::LobattoLegendreBasis)
     boundary_interpolation = adapt(to, basis.boundary_interpolation)
     derivative_matrix = adapt(to, basis.derivative_matrix)
     derivative_split = adapt(to, basis.derivative_split)
-    derivative_split_transpose = adapt(to,basis.derivative_split_transpose)
+    derivative_split_transpose = adapt(to, basis.derivative_split_transpose)
     derivative_dhat = adapt(to, basis.derivative_dhat)
     return LobattoLegendreBasis{RealT, nnodes(basis), typeof(nodes),
                                 typeof(inverse_vandermonde_legendre),
@@ -186,7 +186,8 @@ function Adapt.adapt_structure(to, mortar::LobattoLegendreMortarL2)
     forward_lower = adapt(to, mortar.forward_lower)
     reverse_upper = adapt(to, mortar.reverse_upper)
     reverse_lower = adapt(to, mortar.reverse_lower)
-    return LobattoLegendreMortarL2{eltype(forward_upper), nnodes(mortar), typeof(forward_upper),
+    return LobattoLegendreMortarL2{eltype(forward_upper), nnodes(mortar),
+                                   typeof(forward_upper),
                                    typeof(reverse_upper)}(forward_upper, forward_lower,
                                                           reverse_upper, reverse_lower)
 end

src/solvers/dgsem_p4est/containers.jl

@@ -446,7 +446,7 @@ function Adapt.adapt_structure(to, boundaries::P4estBoundaryContainer)
     return P4estBoundaryContainer{NDIMS, eltype(_u), NDIMS + 1, typeof(u),
                                   typeof(neighbor_ids), typeof(node_indices),
                                   typeof(_u), to}(u, neighbor_ids, node_indices,
-                                                        name, _u)
+                                                  name, _u)
 end
 
 # Container data structure (structure-of-arrays style) for DG L2 mortars