Remove curly brace CPP Lint checks

CODING_STANDARD.md

@@ -19,7 +19,9 @@ Formatting is enforced using clang-format. For more information about this, see
       - Nested function calls do not need to be broken up into separate lines
         even if the outer function call does.
 - If a method is bigger than 50 lines, break it into parts.
-- Put matching `{ }` into the same column.
+- Put matching `{ }` into the same column, except for lambdas, where you should
+  place `{` directly after the closing `)`. This rule also doesn't apply to
+  initializer lists.
 - Spaces around binary operators (`=`, `+`, `==` ...)
 - Space after comma (parameter lists, argument lists, ...)
 - Space after colon inside `for`

scripts/cpplint.py

@@ -3972,14 +3972,6 @@ def CheckBracesSpacing(filename, clean_lines, linenum, nesting_state, error):
       error(filename, linenum, 'whitespace/braces', 5,
             'Missing space before {')
 
-  # Make sure '} else {' has spaces.
-  # if Search(r'}else', line):
-  #   error(filename, linenum, 'whitespace/braces', 5,
-  #        'Missing space before else')
-  if (Search(r'^.*[^\s].*}$', line) or Search(r'^.*[^\s].*{$', line)) and not(Search(r'{[^}]*}', line)):
-     error(filename, linenum, 'whitespace/braces', 5,
-           'Put braces on a separate next line')
-
   # You shouldn't have a space before a semicolon at the end of the line.
   # There's a special case for "for" since the style guide allows space before
   # the semicolon there.

src/goto-programs/goto_convert.cpp

@@ -1823,10 +1823,8 @@ void goto_convertt::generate_ifthenelse(
   // Note this depends on the fact that `instructions` is a std::list
   // and so goto-program-destructive-append preserves iterator validity.
   if(is_guarded_goto)
-    guarded_gotos.push_back({ // NOLINT(whitespace/braces)
-      tmp_v.instructions.begin(),
-      tmp_w.instructions.begin(),
-      guard});
+    guarded_gotos.push_back(
+      {tmp_v.instructions.begin(), tmp_w.instructions.begin(), guard});
 
   dest.destructive_append(tmp_v);
   dest.destructive_append(tmp_w);

src/goto-programs/lazy_goto_model.h

@@ -53,11 +53,11 @@ class lazy_goto_modelt : public abstract_goto_modelt
     message_handlert &message_handler)
   {
     return lazy_goto_modelt(
-      [&handler, &options]
-      (goto_model_functiont &fun, const abstract_goto_modelt &model) { // NOLINT(*)
+      [&handler,
+       &options](goto_model_functiont &fun, const abstract_goto_modelt &model) {
         handler.process_goto_function(fun, model, options);
       },
-      [&handler, &options] (goto_modelt &goto_model) -> bool { // NOLINT(*)
+      [&handler, &options](goto_modelt &goto_model) -> bool {
         return handler.process_goto_functions(goto_model, options);
       },
       message_handler);

src/goto-symex/symex_main.cpp

@@ -166,8 +166,8 @@ void goto_symext::symex_threaded_step(
 static goto_symext::get_goto_functiont get_function_from_goto_functions(
   const goto_functionst &goto_functions)
 {
-  return [&goto_functions](const irep_idt &key) ->
-    const goto_functionst::goto_functiont & { // NOLINT(*)
+  return [&goto_functions](
+           const irep_idt &key) -> const goto_functionst::goto_functiont & {
     return goto_functions.function_map.at(key);
   };
 }

src/java_bytecode/expr2java.h

@@ -66,7 +66,7 @@ std::string floating_point_to_java_string(float_type value)
     return class_name + ".POSITIVE_INFINITY";
   if(std::isinf(value) && value <= 0.)
     return class_name + ".NEGATIVE_INFINITY";
-  const std::string decimal = [&]() -> std::string { // NOLINT
+  const std::string decimal = [&]() -> std::string {
     // Using ostringstream instead of to_string to get string without
     // trailing zeros
     std::ostringstream raw_stream;
@@ -76,7 +76,7 @@ std::string floating_point_to_java_string(float_type value)
       return raw_decimal + ".0";
     return raw_decimal;
   }();
-  const bool is_lossless = [&] { // NOLINT
+  const bool is_lossless = [&] {
     if(value == std::numeric_limits<float_type>::min())
       return true;
     try
@@ -88,7 +88,7 @@ std::string floating_point_to_java_string(float_type value)
       return false;
     }
   }();
-  const std::string lossless = [&]() -> std::string { // NOLINT
+  const std::string lossless = [&]() -> std::string {
     if(is_lossless)
       return decimal;
     std::ostringstream stream;

src/java_bytecode/java_bytecode_convert_method.cpp

@@ -895,10 +895,8 @@ static void gather_symbol_live_ranges(
   if(e.id()==ID_symbol)
   {
     const auto &symexpr=to_symbol_expr(e);
-    auto findit=
-      result.insert({ // NOLINT(whitespace/braces)
-        symexpr.get_identifier(),
-        java_bytecode_convert_methodt::variablet()});
+    auto findit = result.insert(
+      {symexpr.get_identifier(), java_bytecode_convert_methodt::variablet()});
     auto &var=findit.first->second;
     if(findit.second)
     {

src/java_bytecode/java_bytecode_instrument.cpp

@@ -75,7 +75,7 @@ class java_bytecode_instrumentt:public messaget
   optionalt<codet> instrument_expr(const exprt &expr);
 };
 
-const std::vector<std::string> exception_needed_classes = { // NOLINT
+const std::vector<std::string> exception_needed_classes = {
   "java.lang.ArithmeticException",
   "java.lang.ArrayIndexOutOfBoundsException",
   "java.lang.ClassCastException",

src/java_bytecode/java_bytecode_language.cpp

@@ -157,7 +157,7 @@ bool java_bytecode_languaget::parse(
   {
     string_preprocess.initialize_known_type_table();
 
-    auto get_string_base_classes = [this](const irep_idt &id) { // NOLINT (*)
+    auto get_string_base_classes = [this](const irep_idt &id) {
       return string_preprocess.get_string_type_base_classes(id);
     };
 

src/java_bytecode/remove_exceptions.cpp

@@ -572,7 +572,7 @@ void remove_exceptions(
   std::map<irep_idt, std::set<irep_idt>> exceptions_map;
   uncaught_exceptions(goto_functions, ns, exceptions_map);
   remove_exceptionst::function_may_throwt function_may_throw =
-    [&exceptions_map](const irep_idt &id) { // NOLINT(whitespace/braces)
+    [&exceptions_map](const irep_idt &id) {
       return !exceptions_map[id].empty();
     };
   remove_exceptionst remove_exceptions(

src/java_bytecode/remove_instanceof.cpp

@@ -90,9 +90,7 @@ std::size_t remove_instanceoft::lower_instanceof(
   // Sort alphabetically to make order of generated disjuncts
   // independent of class loading order
   std::sort(
-    children.begin(),
-    children.end(),
-    [](const irep_idt &a, const irep_idt &b) { // NOLINT
+    children.begin(), children.end(), [](const irep_idt &a, const irep_idt &b) {
       return a.compare(b) < 0;
     });
 

src/java_bytecode/replace_java_nondet.cpp

@@ -249,9 +249,7 @@ static goto_programt::targett check_and_replace_target(
     "goto_program missing END_FUNCTION instruction");
 
   std::for_each(
-    target,
-    after_matching_assignment,
-    [](goto_programt::instructiont &instr) { // NOLINT (*)
+    target, after_matching_assignment, [](goto_programt::instructiont &instr) {
       instr.make_skip();
     });
 

src/jbmc/jbmc_parse_options.cpp

@@ -493,13 +493,13 @@ int jbmc_parse_optionst::doit()
   std::function<void(bmct &, const symbol_tablet &)> configure_bmc = nullptr;
   if(options.get_bool_option("java-unwind-enum-static"))
   {
-    configure_bmc = [](
-      bmct &bmc, const symbol_tablet &symbol_table) { // NOLINT (*)
-        bmc.add_loop_unwind_handler([&symbol_table](
-                                      const irep_idt &function_id,
-                                      unsigned loop_number,
-                                      unsigned unwind,
-                                      unsigned &max_unwind) { // NOLINT (*)
+    configure_bmc = [](bmct &bmc, const symbol_tablet &symbol_table) {
+      bmc.add_loop_unwind_handler(
+        [&symbol_table](
+          const irep_idt &function_id,
+          unsigned loop_number,
+          unsigned unwind,
+          unsigned &max_unwind) {
           return java_enum_static_init_unwind_handler(
             function_id,
             loop_number,
@@ -564,7 +564,7 @@ int jbmc_parse_optionst::doit()
     // executes. If --paths is active, these dump routines run after every
     // paths iteration. Its return value indicates that if we ran any dump
     // function, then we should skip the actual solver phase.
-    auto callback_after_symex = [this, &lazy_goto_model]() { // NOLINT (*)
+    auto callback_after_symex = [this, &lazy_goto_model]() {
       return show_loaded_functions(lazy_goto_model);
     };
 
@@ -729,11 +729,10 @@ void jbmc_parse_optionst::process_goto_function(
         remove_exceptions_typest::REMOVE_ADDED_INSTANCEOF);
     }
 
-    auto function_is_stub =
-      [&symbol_table, &model](const irep_idt &id) { // NOLINT(*)
-        return symbol_table.lookup_ref(id).value.is_nil() &&
-               !model.can_produce_function(id);
-      };
+    auto function_is_stub = [&symbol_table, &model](const irep_idt &id) {
+      return symbol_table.lookup_ref(id).value.is_nil() &&
+             !model.can_produce_function(id);
+    };
 
     remove_returns(function, function_is_stub);
 

src/jsil/jsil_types.cpp

@@ -15,54 +15,38 @@ Author: Daiva Naudziuniene, [email protected]
 
 typet jsil_any_type()
 {
-  return jsil_union_typet({ // NOLINT(whitespace/braces)
-                          jsil_empty_type(),
-                          jsil_reference_type(),
-                          jsil_value_type()
-                          });
+  return jsil_union_typet(
+    {jsil_empty_type(), jsil_reference_type(), jsil_value_type()});
 }
 
 typet jsil_value_or_empty_type()
 {
-  return jsil_union_typet({ // NOLINT(whitespace/braces)
-                          jsil_value_type(),
-                          jsil_empty_type()
-                          });
+  return jsil_union_typet({jsil_value_type(), jsil_empty_type()});
 }
 
 typet jsil_value_or_reference_type()
 {
-  return jsil_union_typet({ // NOLINT(whitespace/braces)
-                          jsil_value_type(),
-                          jsil_reference_type()
-                          });
+  return jsil_union_typet({jsil_value_type(), jsil_reference_type()});
 }
 
 typet jsil_value_type()
 {
-  return jsil_union_typet({ // NOLINT(whitespace/braces)
-                          jsil_undefined_type(),
-                          jsil_null_type(),
-                          jsil_prim_type(),
-                          jsil_object_type()
-                          });
+  return jsil_union_typet(
+    {jsil_undefined_type(),
+     jsil_null_type(),
+     jsil_prim_type(),
+     jsil_object_type()});
 }
 
 typet jsil_prim_type()
 {
-  return jsil_union_typet({ // NOLINT(whitespace/braces)
-                          floatbv_typet(),
-                          string_typet(),
-                          bool_typet()
-                          });
+  return jsil_union_typet({floatbv_typet(), string_typet(), bool_typet()});
 }
 
 typet jsil_reference_type()
 {
-  return jsil_union_typet({ // NOLINT(whitespace/braces)
-                          jsil_member_reference_type(),
-                          jsil_variable_reference_type()
-                          });
+  return jsil_union_typet(
+    {jsil_member_reference_type(), jsil_variable_reference_type()});
 }
 
 typet jsil_member_reference_type()
@@ -77,10 +61,8 @@ typet jsil_variable_reference_type()
 
 typet jsil_object_type()
 {
-  return jsil_union_typet({ // NOLINT(whitespace/braces)
-                          jsil_user_object_type(),
-                          jsil_builtin_object_type()
-                          });
+  return jsil_union_typet(
+    {jsil_user_object_type(), jsil_builtin_object_type()});
 }
 
 typet jsil_user_object_type()

src/solvers/refinement/string_constraint_generator_transformation.cpp

@@ -128,7 +128,7 @@ exprt string_constraint_generatort::add_axioms_for_substring(
   lemmas.push_back(equal_exprt(res.length(), minus_exprt(end1, start1)));
 
   // Axiom 2.
-  constraints.push_back([&] { // NOLINT
+  constraints.push_back([&] {
     const symbol_exprt idx = fresh_univ_index("QA_index_substring", index_type);
     return string_constraintt(
       idx, res.length(), equal_exprt(res[idx], str[plus_exprt(start1, idx)]));
@@ -197,7 +197,7 @@ exprt string_constraint_generatort::add_axioms_for_trim(
   constraints.push_back(a6);
 
   // Axiom 7.
-  constraints.push_back([&] { // NOLINT
+  constraints.push_back([&] {
     const symbol_exprt n2 = fresh_univ_index("QA_index_trim2", index_type);
     const minus_exprt bound(minus_exprt(str.length(), idx), res.length());
     const binary_relation_exprt eqn2(
@@ -473,7 +473,7 @@ exprt string_constraint_generatort::add_axioms_for_replace(
     char_array_of_pointer(f.arguments()[1], f.arguments()[0]);
   if(
     const auto maybe_chars =
-      to_char_pair(f.arguments()[3], f.arguments()[4], [this](const exprt &e) { // NOLINT
+      to_char_pair(f.arguments()[3], f.arguments()[4], [this](const exprt &e) {
         return get_string_expr(e);
       }))
   {

src/solvers/refinement/string_refinement.cpp

@@ -692,7 +692,7 @@ decision_proceduret::resultt string_refinementt::dec_solve()
     constraints.begin(),
     constraints.end(),
     std::back_inserter(axioms.universal),
-    [&](string_constraintt constraint) { // NOLINT
+    [&](string_constraintt constraint) {
       symbol_resolve.replace_expr(constraint);
       DATA_INVARIANT(
         is_valid_string_constraint(error(), ns, constraint),
@@ -707,14 +707,14 @@ decision_proceduret::resultt string_refinementt::dec_solve()
     not_contains_constraints.begin(),
     not_contains_constraints.end(),
     std::back_inserter(axioms.not_contains),
-    [&](string_not_contains_constraintt axiom) { // NOLINT
+    [&](string_not_contains_constraintt axiom) {
       symbol_resolve.replace_expr(axiom);
       return axiom;
     });
 
   for(const auto &nc_axiom : axioms.not_contains)
   {
-    const auto &witness_type = [&] { // NOLINT
+    const auto &witness_type = [&] {
       const auto &rtype = to_array_type(nc_axiom.s0().type());
       const typet &index_type = rtype.size().type();
       return array_typet(index_type, infinity_exprt(index_type));
@@ -1920,7 +1920,7 @@ static void update_index_set(
 static optionalt<exprt>
 find_index(const exprt &expr, const exprt &str, const symbol_exprt &qvar)
 {
-  auto index_str_containing_qvar = [&](const exprt &e) { // NOLINT
+  auto index_str_containing_qvar = [&](const exprt &e) {
     if(auto index_expr = expr_try_dynamic_cast<index_exprt>(e))
     {
       const auto &arr = index_expr->array();

src/util/graph.h

@@ -486,7 +486,7 @@ void get_reachable(
   {
     auto n = stack.back();
     stack.pop_back();
-    for_each_successor(n, [&](const nodet &node) { // NOLINT
+    for_each_successor(n, [&](const nodet &node) {
       if(set.insert(node).second)
         stack.push_back(node);
     });
@@ -749,8 +749,8 @@ void output_dot_generic(
     &for_each_succ,
   const std::function<std::string(const node_index_type &)> node_to_string)
 {
-  for_each_node([&](const node_index_type &i) {      // NOLINT
-    for_each_succ(i, [&](const node_index_type &n) { // NOLINT
+  for_each_node([&](const node_index_type &i) {
+    for_each_succ(i, [&](const node_index_type &n) {
       out << node_to_string(i) << " -> " << node_to_string(n) << '\n';
     });
   });
@@ -784,14 +784,13 @@ template <class N>
 void grapht<N>::output_dot(std::ostream &out) const
 {
   const auto for_each_node =
-    [&](const std::function<void(const node_indext &)> &f) { // NOLINT
+    [&](const std::function<void(const node_indext &)> &f) {
       for(node_indext i = 0; i < nodes.size(); ++i)
         f(i);
     };
 
   const auto for_each_succ = [&](
-    const node_indext &i,
-    const std::function<void(const node_indext &)> &f) { // NOLINT
+    const node_indext &i, const std::function<void(const node_indext &)> &f) {
     for_each_successor(i, f);
   };
 

unit/java_bytecode/inherited_static_fields/inherited_static_fields.cpp

@@ -19,13 +19,10 @@
 /// \return true if a suitable symbol_exprt is found
 static bool contains_symbol_reference(const exprt &expr, const irep_idt &id)
 {
-  return
-    std::any_of(
-      expr.depth_begin(),
-      expr.depth_end(),
-      [id](const exprt &e) { // NOLINT (*)
-        return e.id() == ID_symbol && to_symbol_expr(e).get_identifier() == id;
-      });
+  return std::any_of(
+    expr.depth_begin(), expr.depth_end(), [id](const exprt &e) {
+      return e.id() == ID_symbol && to_symbol_expr(e).get_identifier() == id;
+    });
 }
 
 SCENARIO(