Fix format

Author: blegat

src/Nonlinear/parse.jl

@@ -40,26 +40,26 @@ function _extract_subexpression!(expr::Expression, root::Int)
     n = length(expr.nodes)
     # The whole subexpression is continuous in the tape
     first_out = findfirst((root+1):n) do i
-        expr.nodes[i].parent < root
+        return expr.nodes[i].parent < root
     end
     if isnothing(first_out)
         I = root:n
     else
-        I = root .+ (0:(first_out - 1))
+        I = root .+ (0:(first_out-1))
     end
     first_value = findfirst(I) do i
-        expr.nodes[i].type == NODE_VALUE
+        return expr.nodes[i].type == NODE_VALUE
     end
     if isnothing(first_value)
         V = nothing
     else
         last_value = findlast(I) do i
-            expr.nodes[i].type == NODE_VALUE
+            return expr.nodes[i].type == NODE_VALUE
         end
         V = expr.nodes[I[first_value]].index:expr.nodes[I[last_value]].index
     end
     if !isnothing(first_out)
-        for i in last(I)+1:n
+        for i in (last(I)+1):n
             node = expr.nodes[i]
             index = node.index
             if node.type == NODE_VALUE && !isnothing(V)
@@ -80,7 +80,8 @@ end
 function _extract_subexpression!(data::Model, expr::Expression, root::Int)
     parent = expr.nodes[root].parent
     I, V = _extract_subexpression!(expr, root)
-    subexpr = Expression(expr.nodes[I], isnothing(V) ? Float64[] : expr.values[V])
+    subexpr =
+        Expression(expr.nodes[I], isnothing(V) ? Float64[] : expr.values[V])
     push!(data.expressions, subexpr)
     index = ExpressionIndex(length(data.expressions))
     expr.nodes[root] = Node(NODE_SUBEXPRESSION, index.value, parent)
@@ -119,7 +120,8 @@ function parse_expression(
                             _parent_node = stack[i][1]
                             if _parent_node > first(I)
                                 @assert _parent_node > last(I)
-                                stack[i] = (_parent_node - length(I) + 1, stack[i][2])
+                                stack[i] =
+                                    (_parent_node - length(I) + 1, stack[i][2])
                             end
                         end
                     end
@@ -128,15 +130,27 @@ function parse_expression(
                             __expr, __node = val
                             if _expr === __expr && __node > first(I)
                                 @assert __node > last(I)
-                                data.cache[key] = (__expr, __node - length(I) + 1)
+                                data.cache[key] =
+                                    (__expr, __node - length(I) + 1)
                             end
                         end
                     end
                     data.cache[arg] = subexpr
                 end
-                parse_expression(data, expr, subexpr::ExpressionIndex, parent_node)
+                parse_expression(
+                    data,
+                    expr,
+                    subexpr::ExpressionIndex,
+                    parent_node,
+                )
             else
-                _parse_without_recursion_inner(stack, data, expr, arg, parent_node)
+                _parse_without_recursion_inner(
+                    stack,
+                    data,
+                    expr,
+                    arg,
+                    parent_node,
+                )
                 data.cache[arg] = (expr, length(expr.nodes))
             end
         else

src/Nonlinear/types.jl

@@ -167,7 +167,10 @@ mutable struct Model
     # This is a private field, used only to increment the ConstraintIndex.
     last_constraint_index::Int64
     # This is a private field, used to detect common subexpressions.
-    cache::Dict{MOI.ScalarNonlinearFunction,Union{ExpressionIndex,Tuple{Expression,Int}}}
+    cache::Dict{
+        MOI.ScalarNonlinearFunction,
+        Union{ExpressionIndex,Tuple{Expression,Int}},
+    }
     function Model()
         return new(
             nothing,
@@ -176,7 +179,10 @@ mutable struct Model
             Float64[],
             OperatorRegistry(),
             0,
-            Dict{MOI.ScalarNonlinearFunction,Union{ExpressionIndex,Tuple{Expression,Int}}}(),
+            Dict{
+                MOI.ScalarNonlinearFunction,
+                Union{ExpressionIndex,Tuple{Expression,Int}},
+            }(),
         )
     end
 end

test/Nonlinear/Nonlinear.jl

@@ -1498,27 +1498,27 @@ function test_extract_subexpression()
     # Test that the objective function gets rewritten as we reuse `h`
     # Also test that we don't change the parents in the stack of `h`
     # by creating a long stack
-    prod = MOI.ScalarNonlinearFunction(
-        :*,
-        [h, x],
-    )
-    sum = MOI.ScalarNonlinearFunction(
-        :*,
-        [x, x, x, x, prod],
-    )
+    prod = MOI.ScalarNonlinearFunction(:*, [h, x])
+    sum = MOI.ScalarNonlinearFunction(:*, [x, x, x, x, prod])
     expr = Nonlinear.parse_expression(model, sum)
     @test isempty(model.objective.values)
     @test model.objective.nodes == [
         Nonlinear.Node(Nonlinear.NODE_CALL_MULTIVARIATE, 1, -1),
         Nonlinear.Node(Nonlinear.NODE_SUBEXPRESSION, 1, 1),
         Nonlinear.Node(Nonlinear.NODE_SUBEXPRESSION, 2, 1),
     ]
-    @test model.expressions == [expected_sub, Nonlinear.Expression([
-        Nonlinear.Node(Nonlinear.NODE_CALL_MULTIVARIATE, 3, 1),
-        Nonlinear.Node(Nonlinear.NODE_VALUE, 1, 3),
-        Nonlinear.Node(Nonlinear.NODE_SUBEXPRESSION, 1, 3),
-        Nonlinear.Node(Nonlinear.NODE_VALUE, 2, 3),
-    ], [2.0, 1.0])]
+    @test model.expressions == [
+        expected_sub,
+        Nonlinear.Expression(
+            [
+                Nonlinear.Node(Nonlinear.NODE_CALL_MULTIVARIATE, 3, 1),
+                Nonlinear.Node(Nonlinear.NODE_VALUE, 1, 3),
+                Nonlinear.Node(Nonlinear.NODE_SUBEXPRESSION, 1, 3),
+                Nonlinear.Node(Nonlinear.NODE_VALUE, 2, 3),
+            ],
+            [2.0, 1.0],
+        ),
+    ]
     @test isempty(expr.values)
     @test expr.nodes == [
         Nonlinear.Node(Nonlinear.NODE_CALL_MULTIVARIATE, 3, -1),