Merge pull request #906 from lonvia/enable-wextra

Fix various unused parameter issues and enable -Wextra on travis

Author: lonvia

.travis.yml

@@ -57,22 +57,22 @@ matrix:
     - os: linux
       compiler: "clang-3.8"
       env: T="clang38_pg92_dbtest" LUAJIT_OPTION="OFF"
-           CXXFLAGS="-pedantic -Werror"
+           CXXFLAGS="-pedantic -Wextra -Werror"
            CC=clang-3.8 CXX=clang++-3.8
       addons: *clang38_pg92
 
     - os: linux
       compiler: "clang-7"
       env: T="clang7_pg96_dbtest_luajit" LUAJIT_OPTION="ON"
-           CXXFLAGS="-pedantic -Werror"
+           CXXFLAGS="-pedantic -Wextra -Werror"
            CC=clang-7 CXX=clang++-7
       addons: *clang7_pg96
 
   # ---- OSX + CLANG ---------------------------
     - os: osx
       compiler: clang
       env: T="osx_clang_NoDB" LUAJIT_OPTION="OFF" TEST_NODB=1
-           CXXFLAGS="-pedantic -Werror"
+           CXXFLAGS="-pedantic -Wextra -Werror"
       before_install:
         - brew install lua; brew install lua
       before_script:
@@ -84,14 +84,14 @@ matrix:
     - os: linux
       compiler: "gcc-4.8"
       env: T="gcc48_pg96_dbtest" LUAJIT_OPTION="OFF"
-           CXXFLAGS="-pedantic -Werror"
+           CXXFLAGS="-pedantic -Wextra -Werror"
            CC=gcc-4.8 CXX=g++-4.8
       addons: *gcc48_pg96
 
     - os: linux
       compiler: gcc-8
       env: T="gcc8_pg96_dbtest_luajit" LUAJIT_OPTION="ON"
-           CXXFLAGS="-pedantic -Werror"
+           CXXFLAGS="-pedantic -Wextra -Werror"
            CC=gcc-8 CXX=g++-8
       addons: *gcc8_pg96
 

middle-ram.cpp

@@ -157,7 +157,7 @@ void middle_ram_t::analyze(void)
 
 void middle_ram_t::start() {}
 
-void middle_ram_t::stop(osmium::thread::Pool &pool)
+void middle_ram_t::stop(osmium::thread::Pool &)
 {
     cache.reset(nullptr);
 

output-multi.cpp

@@ -172,7 +172,7 @@ int output_multi_t::pending_relation(osmid_t id, int exists) {
     buffer.clear();
     if (m_mid->relations_get(id, buffer)) {
         auto const &rel = buffer.get<osmium::Relation>(0);
-        ret = process_relation(rel, exists, true);
+        ret = process_relation(rel, exists);
     }
 
     return ret;
@@ -350,9 +350,7 @@ int output_multi_t::process_way(osmium::Way *way) {
     return 0;
 }
 
-
-int output_multi_t::process_relation(osmium::Relation const &rel,
-                                     bool exists, bool pending)
+int output_multi_t::process_relation(osmium::Relation const &rel, bool exists)
 {
     //if it may exist already, delete it first
     if(exists)

output-multi.hpp

@@ -72,7 +72,7 @@ class output_multi_t : public output_t
     int process_node(osmium::Node const &node);
     int process_way(osmium::Way *way);
     int reprocess_way(osmium::Way *way, bool exists);
-    int process_relation(osmium::Relation const &rel, bool exists, bool pending=false);
+    int process_relation(osmium::Relation const &rel, bool exists);
     void copy_node_to_table(osmid_t id, const std::string &geom, taglist_t &tags);
     void copy_to_table(const osmid_t id, geometry_processor::wkb_t const &geom,
                        taglist_t &tags);

output-pgsql.cpp

@@ -226,7 +226,7 @@ int output_pgsql_t::pending_relation(osmid_t id, int exists) {
         }
 
         auto const &rel = rels_buffer.get<osmium::Relation>(0);
-        return pgsql_process_relation(rel, true);
+        return pgsql_process_relation(rel);
     }
 
     return 0;
@@ -288,8 +288,7 @@ int output_pgsql_t::way_add(osmium::Way *way)
 
 
 /* This is the workhorse of pgsql_add_relation, split out because it is used as the callback for iterate relations */
-int output_pgsql_t::pgsql_process_relation(osmium::Relation const &rel,
-                                           bool pending)
+int output_pgsql_t::pgsql_process_relation(osmium::Relation const &rel)
 {
     taglist_t prefiltered_tags;
     if (m_tagtransform->filter_tags(rel, nullptr, nullptr, *m_export_list.get(),
@@ -381,7 +380,7 @@ int output_pgsql_t::relation_add(osmium::Relation const &rel)
         return 0;
     }
 
-    return pgsql_process_relation(rel, false);
+    return pgsql_process_relation(rel);
 }
 
 /* Delete is easy, just remove all traces of this object. We don't need to

output-pgsql.hpp

@@ -62,7 +62,7 @@ class output_pgsql_t : public output_t {
 protected:
     void pgsql_out_way(osmium::Way const &way, taglist_t *tags, bool polygon,
                        bool roads);
-    int pgsql_process_relation(osmium::Relation const &rel, bool pending);
+    int pgsql_process_relation(osmium::Relation const &rel);
     int pgsql_delete_way_from_output(osmid_t osm_id);
     int pgsql_delete_relation_from_output(osmid_t osm_id);
 

tagtransform-c.cpp

@@ -204,10 +204,9 @@ bool c_tagtransform_t::filter_tags(osmium::OSMObject const &o, int *polygon,
 }
 
 bool c_tagtransform_t::filter_rel_member_tags(
-    taglist_t const &rel_tags, osmium::memory::Buffer const &members,
-    rolelist_t const &member_roles, int *make_boundary, int *make_polygon,
-    int *roads, export_list const &exlist, taglist_t &out_tags,
-    bool allow_typeless)
+    taglist_t const &rel_tags, osmium::memory::Buffer const &,
+    rolelist_t const &, int *make_boundary, int *make_polygon, int *roads,
+    export_list const &, taglist_t &out_tags, bool allow_typeless)
 {
     //if it has a relation figure out what kind it is
     const std::string *type = rel_tags.get("type");

tests/test-expire-tiles.cpp

@@ -442,6 +442,8 @@ void test_expire_merge_complete() {
 
 int main(int argc, char *argv[])
 {
+    (void)argc;
+    (void)argv;
     srand(0);
 
     //try each test if any fail we will exit

tests/test-hstore-match-only.cpp

@@ -32,6 +32,8 @@ The tags of inteest are specified in hstore-match-only.style
 #include "tests/common-pg.hpp"
 
 int main(int argc, char *argv[]) {
+    (void)argc;
+    (void)argv;
     std::unique_ptr<pg::tempdb> db;
 
     try {

tests/test-middle-flat.cpp

@@ -23,54 +23,59 @@
 
 /* This is basically the same as test-middle-pgsql, but with flat nodes. */
 
-void run_tests(options_t options, const std::string cache_type) {
-  options.append = false;
-  options.create = true;
-  options.flat_node_cache_enabled = true;
-  // flat nodes truncates the file each time it's started, so we can reuse the same file
-  options.flat_node_file = boost::optional<std::string>(FLAT_NODES_FILE_NAME);
-
-  {
-      test_middle_helper<middle_pgsql_t> t(options);
-
-      if (t.test_node_set() != 0) {
-          throw std::runtime_error("test_node_set failed.");
-      }
-  }
-
-  {
-      test_middle_helper<middle_pgsql_t> t(options);
-
-      if (t.test_nodes_comprehensive_set() != 0) {
-          throw std::runtime_error("test_nodes_comprehensive_set failed.");
-      }
-  }
-
-  /* This should work, but doesn't. More tests are needed that look at updates
+void run_tests(options_t options)
+{
+    options.append = false;
+    options.create = true;
+    options.flat_node_cache_enabled = true;
+    // flat nodes truncates the file each time it's started, so we can reuse the same file
+    options.flat_node_file = boost::optional<std::string>(FLAT_NODES_FILE_NAME);
+
+    {
+        test_middle_helper<middle_pgsql_t> t(options);
+
+        if (t.test_node_set() != 0) {
+            throw std::runtime_error("test_node_set failed.");
+        }
+    }
+
+    {
+        test_middle_helper<middle_pgsql_t> t(options);
+
+        if (t.test_nodes_comprehensive_set() != 0) {
+            throw std::runtime_error("test_nodes_comprehensive_set failed.");
+        }
+    }
+
+    /* This should work, but doesn't. More tests are needed that look at updates
      without the complication of ways.
   */
-  {
-      // First make sure we have an empty table.
-      { test_middle_helper<middle_pgsql_t> t(options); }
+    {
+        // First make sure we have an empty table.
+        {
+            test_middle_helper<middle_pgsql_t> t(options);
+        }
 
-      // Switch to append mode because this tests updates
-      options.append = true;
-      options.create = false;
+        // Switch to append mode because this tests updates
+        options.append = true;
+        options.create = false;
 
-      test_middle_helper<middle_pgsql_t> t(options);
+        test_middle_helper<middle_pgsql_t> t(options);
 
-      t.commit();
+        t.commit();
 
-      if (t.test_way_set() != 0) {
-          throw std::runtime_error("test_way_set failed.");
-      }
-  }
+        if (t.test_way_set() != 0) {
+            throw std::runtime_error("test_way_set failed.");
+        }
+    }
 }
 int main(int argc, char *argv[]) {
-  std::unique_ptr<pg::tempdb> db;
+    (void)argc;
+    (void)argv;
+    std::unique_ptr<pg::tempdb> db;
 
-  try {
-    db.reset(new pg::tempdb);
+    try {
+        db.reset(new pg::tempdb);
   } catch (const std::exception &e) {
     std::cerr << "Unable to setup database: " << e.what() << "\n";
     return 77; // <-- code to skip this test.
@@ -89,15 +94,15 @@ int main(int argc, char *argv[]) {
     cleanup::file flat_nodes_file(FLAT_NODES_FILE_NAME);
 
     options.alloc_chunkwise = ALLOC_SPARSE | ALLOC_DENSE; // what you get with optimized
-    run_tests(options, "optimized");
+    run_tests(options);
     options.alloc_chunkwise = ALLOC_SPARSE;
-    run_tests(options, "sparse");
+    run_tests(options);
 
     options.alloc_chunkwise = ALLOC_DENSE;
-    run_tests(options, "dense");
+    run_tests(options);
 
     options.alloc_chunkwise = ALLOC_DENSE | ALLOC_DENSE_CHUNK; // what you get with chunk
-    run_tests(options, "chunk");
+    run_tests(options);
 
   } catch (const std::exception &e) {
     std::cerr << "ERROR: " << e.what() << std::endl;