Make Formatter Happy

Signed-off-by: Will Hawkins <hawkinsw@obs.cr>

Sources/P4Compiler/Common.swift

@@ -263,7 +263,8 @@ func argument_list_compiler(
   // Otherwise, there should be one argument left!
   switch Argument.Compile(node: currentChild!, withContext: context) {
   case .Ok(let (ce, updated_context)):
-    return Result.Ok((arguments.addArgument(Argument(ce, atIndex: arguments.count() + 1)), updated_context))
+    return Result.Ok(
+      (arguments.addArgument(Argument(ce, atIndex: arguments.count() + 1)), updated_context))
   case .Error(let e): return Result.Error(e)
   }
 }

Sources/P4Compiler/Expression.swift

@@ -163,7 +163,7 @@ struct Expression {
     let expression_parsers: [CompilableExpression.Type] = [
       P4BooleanValue.self, P4StringValue.self, P4IntValue.self, TypedIdentifier.self,
       BinaryOperatorExpression.self, ArrayAccessExpression.self, FieldAccessExpression.self,
-      FunctionCall.self
+      FunctionCall.self,
     ]
 
     for candidate_expression_parser in expression_parsers {
@@ -680,10 +680,14 @@ extension FunctionCall: CompilableExpression {
       return Result.Error(maybe_callee_name.error()!)
     }
 
-    let maybe_callee = switch context.types.lookup(identifier: callee_name) {
+    let maybe_callee =
-      case .Ok(let looked_up): switch looked_up {
+      switch context.types.lookup(identifier: callee_name) {
+      case .Ok(let looked_up):
+        switch looked_up {
         case let callee as FunctionDeclaration: Result.Ok(callee)  // What we found is actually a function declaration
-        default: Result<FunctionDeclaration>.Error(ErrorOnNode(node: currentChild!, withError: "\(callee_name) is not a function"))
+        default:
+          Result<FunctionDeclaration>.Error(
+            ErrorOnNode(node: currentChild!, withError: "\(callee_name) is not a function"))
         }
       case .Error(let e): Result<FunctionDeclaration>.Error(e)
       }
@@ -692,7 +696,6 @@ extension FunctionCall: CompilableExpression {
       return .Error(maybe_callee.error()!)
     }
 
-
     currentChildIdx += 1
     currentChildIdxSafe += 1
     if expression.childCount < currentChildIdxSafe {

Sources/P4Runtime/Expressions.swift

@@ -400,18 +400,21 @@ extension FunctionCall: EvaluatableExpression {
       guard case .Ok(let argument_value) = maybe_argument_value else {
         return .Error(Error(withMessage: "Cannot evaluate argument \(arg_idx): \(argument)"))
       }
-      called_execution = called_execution.declare(identifier: parameter.name, withValue: argument_value)
+      called_execution = called_execution.declare(
+        identifier: parameter.name, withValue: argument_value)
     }
 
     let (control_flow, _) = body.evaluate(execution: called_execution)
 
     return switch control_flow {
-      case ControlFlow.Return(let value): if let value = value {
+    case ControlFlow.Return(let value):
+      if let value = value {
         .Ok(value)
       } else {
         .Error(Error(withMessage: "No value returned from called function (\(self.callee.name))"))
       }
-      default: .Error(Error(withMessage: "No value returned from called function (\(self.callee.name))"))
+    default:
+      .Error(Error(withMessage: "No value returned from called function (\(self.callee.name))"))
     }
   }
 

Sources/P4Runtime/Parser.swift

@@ -47,7 +47,12 @@ extension ParserStateDirectTransition: EvaluatableParserState {
       switch control_flow {
       case .Next: program = next_program  // Ok!
       case .Error: return (reject, next_program)
-        default: return (reject, next_program.setError(error: Error(withMessage: "Invalid control flow (\(control_flow) in parser)")))
+      default:
+        return (
+          reject,
+          next_program.setError(
+            error: Error(withMessage: "Invalid control flow (\(control_flow) in parser)"))
+        )
       }
     }
     let res = program.scopes.lookup(identifier: get_next_state())
@@ -102,7 +107,12 @@ extension ParserStateSelectTransition: EvaluatableParserState {
       switch control_flow {
       case .Next: program = next_program  // Ok!
       case .Error: return (reject, next_program)
-        default: return (reject, next_program.setError(error: Error(withMessage: "Invalid control flow (\(control_flow) in parser)")))
+      default:
+        return (
+          reject,
+          next_program.setError(
+            error: Error(withMessage: "Invalid control flow (\(control_flow) in parser)"))
+        )
       }
     }
 

Sources/P4Runtime/Statements.swift

@@ -113,5 +113,3 @@ extension ReturnStatement: EvaluatableStatement {
     }
   }
 }
-
-