anchor.diff:              | Some e -> e.Print(printer)
               | None ->
                   if isArrow then
  -                    // TODO: Remove parens if we only have one argument (and no annotation)
  +                    // Remove parens if we only have one argument? (and no annotation)
                       printer.Print("(")
                       printer.PrintCommaSeparatedArray(parameters)
                       printer.Print(") => ")
                       match body.Body with
  -                    | [|:? ReturnStatement as r |] -> r.Argument.Print(printer)
  +                    | [|:? ReturnStatement as r |] ->
  +                        printer.ComplexExpressionWithParens(r.Argument, objExpr=true)
                       | _ -> printer.PrintBlock(body.Body, skipNewLineAtEnd=true)
                   else
                   printer.Print("function ")
  
positive.code:                 if i < nodes.Length - 1 then
                      printSeparator printer
  
          member printer.PrintCommaSeparatedArray(nodes: #Node array) =
              printer.PrintArray(nodes, (fun p x -> x.Print(p)), (fun p -> p.Print(", ")))
  
          // TODO: (super) type parameters, implements
          member printer.PrintClass(id: Identifier option, superClass: Expression option, body: ClassBody, loc) =
  
negative.code:             printer.PrintOptional("finally ", finalizer)
  
  // Declarations
  type VariableDeclarator(id, ?init) =
      member _.Id: Pattern = id
      member _.Init: Expression option = init
  
  type VariableDeclarationKind = Var | Let | Const
  
  type VariableDeclaration(kind_, declarations, ?loc) =
      let kind = match kind_ with Var -> "var" | Let -> "let" | Const -> "const"
      new (var, ?init, ?kind, ?loc) =
          VariableDeclaration(defaultArg kind Let, [|VariableDeclarator(var, ?init=init)|], ?loc=loc)
      member _.Declarations: VariableDeclarator array = declarations
      member _.Kind: string = kind
      interface Declaration with
          member _.Print(printer) =
              printer.Print(kind + " ", ?loc=loc)
              let canConflict = declarations.Length > 1
              for i = 0 to declarations.Length - 1 do
                  let decl = declarations.[i]
                  printer.Print(decl.Id)
                  match decl.Init with
                  | None -> ()
                  | Some e ->
                      printer.Print(" = ")
                      if canConflict then printer.ComplexExpressionWithParens(e)
                      else printer.SequenceExpressionWithParens(e)
                  if i < declarations.Length - 1 then
                      printer.Print(", ")
  
  // Loops
  type WhileStatement(test, body, ?loc) =
  