libstdc++: Add nodiscard attribute to filesystem operations

Some of these are not truly "pure" because they access the file system,
e.g. exists and file_size, but they do not modify anything and are only
useful for the return value.

If you really want to use one of those functions just to check whether
an error is reported (either via an exception or an error_code&
argument) you can still do so, but you need to cast the discarded result
to void.  Several tests need such a change, because they were indeed
only calling the functions to check for expected errors.

libstdc++-v3/ChangeLog:

	* include/bits/fs_ops.h: Add nodiscard to all pure functions.
	* include/experimental/bits/fs_ops.h: Likewise.
	* testsuite/27_io/filesystem/operations/all.cc: Do not discard
	results of absolute and canonical.
	* testsuite/27_io/filesystem/operations/absolute.cc: Cast
	discarded result to void.
	* testsuite/27_io/filesystem/operations/canonical.cc: Likewise.
	* testsuite/27_io/filesystem/operations/exists.cc: Likewise.
	* testsuite/27_io/filesystem/operations/is_empty.cc: Likewise.
	* testsuite/27_io/filesystem/operations/read_symlink.cc:
	Likewise.
	* testsuite/27_io/filesystem/operations/status.cc: Likewise.
	* testsuite/27_io/filesystem/operations/symlink_status.cc:
	Likewise.
	* testsuite/27_io/filesystem/operations/temp_directory_path.cc:
	Likewise.
	* testsuite/experimental/filesystem/operations/canonical.cc:
	Likewise.
	* testsuite/experimental/filesystem/operations/exists.cc:
	Likewise.
	* testsuite/experimental/filesystem/operations/is_empty.cc:
	Likewise.
	* testsuite/experimental/filesystem/operations/read_symlink.cc:
	Likewise.
	* testsuite/experimental/filesystem/operations/temp_directory_path.cc:
	Likewise.

diff --git a/libstdc++-v3/include/bits/fs_ops.h b/libstdc++-v3/include/bits/fs_ops.h
index 0281c6540d013e764540ac17ca0100bd770c987f..1ae8fe12374df758019b148737381e08c209c5e7 100644 (file)
--- a/libstdc++-v3/include/bits/fs_ops.h
+++ b/libstdc++-v3/include/bits/fs_ops.h
@@ -44,10 +44,16 @@ namespace filesystem
    *  @{
    */
 
+  [[nodiscard]]
   path absolute(const path& __p);
+
+  [[nodiscard]]
   path absolute(const path& __p, error_code& __ec);
 
+  [[nodiscard]]
   path canonical(const path& __p);
+
+  [[nodiscard]]
   path canonical(const path& __p, error_code& __ec);
 
   inline void
@@ -100,25 +106,34 @@ namespace filesystem
   void create_symlink(const path& __to, const path& __new_symlink,
                      error_code& __ec) noexcept;
 
+  [[nodiscard]]
   path current_path();
+
+  [[nodiscard]]
   path current_path(error_code& __ec);
+
   void current_path(const path& __p);
   void current_path(const path& __p, error_code& __ec) noexcept;
 
+  [[nodiscard]]
   bool
   equivalent(const path& __p1, const path& __p2);
 
+  [[nodiscard]]
   bool
   equivalent(const path& __p1, const path& __p2, error_code& __ec) noexcept;
 
+  [[nodiscard]]
   inline bool
   exists(file_status __s) noexcept
   { return status_known(__s) && __s.type() != file_type::not_found; }
 
+  [[nodiscard]]
   inline bool
   exists(const path& __p)
   { return exists(status(__p)); }
 
+  [[nodiscard]]
   inline bool
   exists(const path& __p, error_code& __ec) noexcept
   {
@@ -131,63 +146,85 @@ namespace filesystem
     return false;
   }
 
+  [[nodiscard]]
   uintmax_t file_size(const path& __p);
+
+  [[nodiscard]]
   uintmax_t file_size(const path& __p, error_code& __ec) noexcept;
 
+  [[nodiscard]]
   uintmax_t hard_link_count(const path& __p);
+
+  [[nodiscard]]
   uintmax_t hard_link_count(const path& __p, error_code& __ec) noexcept;
 
+  [[nodiscard]]
   inline bool
   is_block_file(file_status __s) noexcept
   { return __s.type() == file_type::block; }
 
+  [[nodiscard]]
   inline bool
   is_block_file(const path& __p)
   { return is_block_file(status(__p)); }
 
+  [[nodiscard]]
   inline bool
   is_block_file(const path& __p, error_code& __ec) noexcept
   { return is_block_file(status(__p, __ec)); }
 
+  [[nodiscard]]
   inline bool
   is_character_file(file_status __s) noexcept
   { return __s.type() == file_type::character; }
 
+  [[nodiscard]]
   inline bool
   is_character_file(const path& __p)
   { return is_character_file(status(__p)); }
 
+  [[nodiscard]]
   inline bool
   is_character_file(const path& __p, error_code& __ec) noexcept
   { return is_character_file(status(__p, __ec)); }
 
+  [[nodiscard]]
   inline bool
   is_directory(file_status __s) noexcept
   { return __s.type() == file_type::directory; }
 
+  [[nodiscard]]
   inline bool
   is_directory(const path& __p)
   { return is_directory(status(__p)); }
 
+  [[nodiscard]]
   inline bool
   is_directory(const path& __p, error_code& __ec) noexcept
   { return is_directory(status(__p, __ec)); }
 
+  [[nodiscard]]
   bool is_empty(const path& __p);
+
+  [[nodiscard]]
   bool is_empty(const path& __p, error_code& __ec);
 
+  [[nodiscard]]
   inline bool
   is_fifo(file_status __s) noexcept
   { return __s.type() == file_type::fifo; }
 
+  [[nodiscard]]
   inline bool
   is_fifo(const path& __p)
   { return is_fifo(status(__p)); }
 
+  [[nodiscard]]
   inline bool
   is_fifo(const path& __p, error_code& __ec) noexcept
   { return is_fifo(status(__p, __ec)); }
 
+  [[nodiscard]]
   inline bool
   is_other(file_status __s) noexcept
   {
@@ -195,52 +232,67 @@ namespace filesystem
       && !is_symlink(__s);
   }
 
+  [[nodiscard]]
   inline bool
   is_other(const path& __p)
   { return is_other(status(__p)); }
 
+  [[nodiscard]]
   inline bool
   is_other(const path& __p, error_code& __ec) noexcept
   { return is_other(status(__p, __ec)); }
 
+  [[nodiscard]]
   inline bool
   is_regular_file(file_status __s) noexcept
   { return __s.type() == file_type::regular; }
 
+  [[nodiscard]]
   inline bool
   is_regular_file(const path& __p)
   { return is_regular_file(status(__p)); }
 
+  [[nodiscard]]
   inline bool
   is_regular_file(const path& __p, error_code& __ec) noexcept
   { return is_regular_file(status(__p, __ec)); }
 
+  [[nodiscard]]
   inline bool
   is_socket(file_status __s) noexcept
   { return __s.type() == file_type::socket; }
 
+  [[nodiscard]]
   inline bool
   is_socket(const path& __p)
   { return is_socket(status(__p)); }
 
+  [[nodiscard]]
   inline bool
   is_socket(const path& __p, error_code& __ec) noexcept
   { return is_socket(status(__p, __ec)); }
 
+  [[nodiscard]]
   inline bool
   is_symlink(file_status __s) noexcept
   { return __s.type() == file_type::symlink; }
 
+  [[nodiscard]]
   inline bool
   is_symlink(const path& __p)
   { return is_symlink(symlink_status(__p)); }
 
+  [[nodiscard]]
   inline bool
   is_symlink(const path& __p, error_code& __ec) noexcept
   { return is_symlink(symlink_status(__p, __ec)); }
 
+  [[nodiscard]]
   file_time_type  last_write_time(const path& __p);
+
+  [[nodiscard]]
   file_time_type  last_write_time(const path& __p, error_code& __ec) noexcept;
+
   void last_write_time(const path& __p, file_time_type __new_time);
   void last_write_time(const path& __p, file_time_type __new_time,
                       error_code& __ec) noexcept;
@@ -257,19 +309,30 @@ namespace filesystem
   permissions(const path& __p, perms __prms, perm_options __opts,
              error_code& __ec) noexcept;
 
+  [[nodiscard]]
   inline path proximate(const path& __p, error_code& __ec)
   { return proximate(__p, current_path(), __ec); }
 
+  [[nodiscard]]
   path proximate(const path& __p, const path& __base = current_path());
+
+  [[nodiscard]]
   path proximate(const path& __p, const path& __base, error_code& __ec);
 
+  [[nodiscard]]
   path read_symlink(const path& __p);
+
+  [[nodiscard]]
   path read_symlink(const path& __p, error_code& __ec);
 
+  [[nodiscard]]
   inline path relative(const path& __p, error_code& __ec)
   { return relative(__p, current_path(), __ec); }
 
+  [[nodiscard]]
   path relative(const path& __p, const path& __base = current_path());
+
+  [[nodiscard]]
   path relative(const path& __p, const path& __base, error_code& __ec);
 
   bool remove(const path& __p);
@@ -284,22 +347,38 @@ namespace filesystem
   void resize_file(const path& __p, uintmax_t __size);
   void resize_file(const path& __p, uintmax_t __size, error_code& __ec) noexcept;
 
+  [[nodiscard]]
   space_info space(const path& __p);
+
+  [[nodiscard]]
   space_info space(const path& __p, error_code& __ec) noexcept;
 
+  [[nodiscard]]
   file_status status(const path& __p);
+
+  [[nodiscard]]
   file_status status(const path& __p, error_code& __ec) noexcept;
 
+  [[nodiscard]]
   inline bool status_known(file_status __s) noexcept
   { return __s.type() != file_type::none; }
 
+  [[nodiscard]]
   file_status symlink_status(const path& __p);
+
+  [[nodiscard]]
   file_status symlink_status(const path& __p, error_code& __ec) noexcept;
 
+  [[nodiscard]]
   path temp_directory_path();
+
+  [[nodiscard]]
   path temp_directory_path(error_code& __ec);
 
+  [[nodiscard]]
   path weakly_canonical(const path& __p);
+
+  [[nodiscard]]
   path weakly_canonical(const path& __p, error_code& __ec);
 
   /// @} group filesystem

diff --git a/libstdc++-v3/include/experimental/bits/fs_ops.h b/libstdc++-v3/include/experimental/bits/fs_ops.h
index 773f27c66872efc22031a885dca2e4708d9890f2..e37dc9ae81117eded0559cc896385eb206d79dd9 100644 (file)
--- a/libstdc++-v3/include/experimental/bits/fs_ops.h
+++ b/libstdc++-v3/include/experimental/bits/fs_ops.h
@@ -51,10 +51,16 @@ inline namespace v1
    * @{
    */
 
+  [[__nodiscard__]]
   path absolute(const path& __p, const path& __base = current_path());
 
+  [[__nodiscard__]]
   path canonical(const path& __p, const path& __base = current_path());
+
+  [[__nodiscard__]]
   path canonical(const path& __p, error_code& __ec);
+
+  [[__nodiscard__]]
   path canonical(const path& __p, const path& __base, error_code& __ec);
 
   inline void
@@ -66,6 +72,7 @@ inline namespace v1
   { copy(__from, __to, copy_options::none, __ec); }
 
   void copy(const path& __from, const path& __to, copy_options __options);
+
   void copy(const path& __from, const path& __to, copy_options __options,
            error_code& __ec) noexcept;
 
@@ -107,25 +114,34 @@ inline namespace v1
   void create_symlink(const path& __to, const path& __new_symlink,
                      error_code& __ec) noexcept;
 
+  [[__nodiscard__]]
   path current_path();
+
+  [[__nodiscard__]]
   path current_path(error_code& __ec);
+
   void current_path(const path& __p);
   void current_path(const path& __p, error_code& __ec) noexcept;
 
+  [[__nodiscard__]]
   bool
   equivalent(const path& __p1, const path& __p2);
 
+  [[__nodiscard__]]
   bool
   equivalent(const path& __p1, const path& __p2, error_code& __ec) noexcept;
 
+  [[__nodiscard__]]
   inline bool
   exists(file_status __s) noexcept
   { return status_known(__s) && __s.type() != file_type::not_found; }
 
+  [[__nodiscard__]]
   inline bool
   exists(const path& __p)
   { return exists(status(__p)); }
 
+  [[__nodiscard__]]
   inline bool
   exists(const path& __p, error_code& __ec) noexcept
   {
@@ -138,63 +154,84 @@ inline namespace v1
     return false;
   }
 
+  [[__nodiscard__]]
   uintmax_t file_size(const path& __p);
+
+  [[__nodiscard__]]
   uintmax_t file_size(const path& __p, error_code& __ec) noexcept;
 
+  [[__nodiscard__]]
   uintmax_t hard_link_count(const path& __p);
+
+  [[__nodiscard__]]
   uintmax_t hard_link_count(const path& __p, error_code& __ec) noexcept;
 
+  [[__nodiscard__]]
   inline bool
   is_block_file(file_status __s) noexcept
   { return __s.type() == file_type::block; }
 
+  [[__nodiscard__]]
   inline bool
   is_block_file(const path& __p)
   { return is_block_file(status(__p)); }
 
+  [[__nodiscard__]]
   inline bool
   is_block_file(const path& __p, error_code& __ec) noexcept
   { return is_block_file(status(__p, __ec)); }
 
+  [[__nodiscard__]]
   inline bool
   is_character_file(file_status __s) noexcept
   { return __s.type() == file_type::character; }
 
+  [[__nodiscard__]]
   inline bool
   is_character_file(const path& __p)
   { return is_character_file(status(__p)); }
 
+  [[__nodiscard__]]
   inline bool
   is_character_file(const path& __p, error_code& __ec) noexcept
   { return is_character_file(status(__p, __ec)); }
 
+  [[__nodiscard__]]
   inline bool
   is_directory(file_status __s) noexcept
   { return __s.type() == file_type::directory; }
 
+  [[__nodiscard__]]
   inline bool
   is_directory(const path& __p)
   { return is_directory(status(__p)); }
 
+  [[__nodiscard__]]
   inline bool
   is_directory(const path& __p, error_code& __ec) noexcept
   { return is_directory(status(__p, __ec)); }
 
+  [[__nodiscard__]]
   bool is_empty(const path& __p);
+  [[__nodiscard__]]
   bool is_empty(const path& __p, error_code& __ec) noexcept;
 
+  [[__nodiscard__]]
   inline bool
   is_fifo(file_status __s) noexcept
   { return __s.type() == file_type::fifo; }
 
+  [[__nodiscard__]]
   inline bool
   is_fifo(const path& __p)
   { return is_fifo(status(__p)); }
 
+  [[__nodiscard__]]
   inline bool
   is_fifo(const path& __p, error_code& __ec) noexcept
   { return is_fifo(status(__p, __ec)); }
 
+  [[__nodiscard__]]
   inline bool
   is_other(file_status __s) noexcept
   {
@@ -202,52 +239,67 @@ inline namespace v1
       && !is_symlink(__s);
   }
 
+  [[__nodiscard__]]
   inline bool
   is_other(const path& __p)
   { return is_other(status(__p)); }
 
+  [[__nodiscard__]]
   inline bool
   is_other(const path& __p, error_code& __ec) noexcept
   { return is_other(status(__p, __ec)); }
 
+  [[__nodiscard__]]
   inline bool
   is_regular_file(file_status __s) noexcept
   { return __s.type() == file_type::regular; }
 
+  [[__nodiscard__]]
   inline bool
   is_regular_file(const path& __p)
   { return is_regular_file(status(__p)); }
 
+  [[__nodiscard__]]
   inline bool
   is_regular_file(const path& __p, error_code& __ec) noexcept
   { return is_regular_file(status(__p, __ec)); }
 
+  [[__nodiscard__]]
   inline bool
   is_socket(file_status __s) noexcept
   { return __s.type() == file_type::socket; }
 
+  [[__nodiscard__]]
   inline bool
   is_socket(const path& __p)
   { return is_socket(status(__p)); }
 
+  [[__nodiscard__]]
   inline bool
   is_socket(const path& __p, error_code& __ec) noexcept
   { return is_socket(status(__p, __ec)); }
 
+  [[__nodiscard__]]
   inline bool
   is_symlink(file_status __s) noexcept
   { return __s.type() == file_type::symlink; }
 
+  [[__nodiscard__]]
   inline bool
   is_symlink(const path& __p)
   { return is_symlink(symlink_status(__p)); }
 
+  [[__nodiscard__]]
   inline bool
   is_symlink(const path& __p, error_code& __ec) noexcept
   { return is_symlink(symlink_status(__p, __ec)); }
 
+  [[__nodiscard__]]
   file_time_type  last_write_time(const path& __p);
+
+  [[__nodiscard__]]
   file_time_type  last_write_time(const path& __p, error_code& __ec) noexcept;
+
   void last_write_time(const path& __p, file_time_type __new_time);
   void last_write_time(const path& __p, file_time_type __new_time,
                       error_code& __ec) noexcept;
@@ -255,7 +307,10 @@ inline namespace v1
   void permissions(const path& __p, perms __prms);
   void permissions(const path& __p, perms __prms, error_code& __ec) noexcept;
 
+  [[__nodiscard__]]
   path read_symlink(const path& __p);
+
+  [[__nodiscard__]]
   path read_symlink(const path& __p, error_code& __ec);
 
   bool remove(const path& __p);
@@ -270,22 +325,38 @@ inline namespace v1
   void resize_file(const path& __p, uintmax_t __size);
   void resize_file(const path& __p, uintmax_t __size, error_code& __ec) noexcept;
 
+  [[__nodiscard__]]
   space_info space(const path& __p);
+
+  [[__nodiscard__]]
   space_info space(const path& __p, error_code& __ec) noexcept;
 
+  [[__nodiscard__]]
   file_status status(const path& __p);
+
+  [[__nodiscard__]]
   file_status status(const path& __p, error_code& __ec) noexcept;
 
+  [[__nodiscard__]]
   inline bool status_known(file_status __s) noexcept
   { return __s.type() != file_type::none; }
 
+  [[__nodiscard__]]
   file_status symlink_status(const path& __p);
+
+  [[__nodiscard__]]
   file_status symlink_status(const path& __p, error_code& __ec) noexcept;
 
+  [[__nodiscard__]]
   path system_complete(const path& __p);
+
+  [[__nodiscard__]]
   path system_complete(const path& __p, error_code& __ec);
 
+  [[__nodiscard__]]
   path temp_directory_path();
+
+  [[__nodiscard__]]
   path temp_directory_path(error_code& __ec);
 
   /// @} group filesystem-ts

diff --git a/libstdc++-v3/testsuite/27_io/filesystem/operations/absolute.cc b/libstdc++-v3/testsuite/27_io/filesystem/operations/absolute.cc
index 236e1b2fad75f25db310eb2b706fe2c7a35fe786..295b755ada731923ccd1873b299b8616bebdf681 100644 (file)
--- a/libstdc++-v3/testsuite/27_io/filesystem/operations/absolute.cc
+++ b/libstdc++-v3/testsuite/27_io/filesystem/operations/absolute.cc
@@ -84,7 +84,7 @@ test03()
   VERIFY( eabs.empty() );
 
   try {
-    absolute(path{});
+    (void) absolute(path{});
     VERIFY( false );
   } catch (const std::filesystem::filesystem_error& e) {
     VERIFY( e.code() == std::errc::invalid_argument );

diff --git a/libstdc++-v3/testsuite/27_io/filesystem/operations/all.cc b/libstdc++-v3/testsuite/27_io/filesystem/operations/all.cc
index d5d6c8731c38a9e9d4d13ec6d9d418ded63c2fc0..3c8ab78b78ac55f6d58f1a909d060b2532119cf9 100644 (file)
--- a/libstdc++-v3/testsuite/27_io/filesystem/operations/all.cc
+++ b/libstdc++-v3/testsuite/27_io/filesystem/operations/all.cc
@@ -42,11 +42,11 @@ main()
   bool b [[maybe_unused]];
   std::uintmax_t size;
 
-  std::filesystem::absolute(p);
-  std::filesystem::absolute(p, ec);
+  p2 = std::filesystem::absolute(p);
+  p2 = std::filesystem::absolute(p, ec);
 
-  std::filesystem::canonical(p);
-  std::filesystem::canonical(p, ec);
+  p2 = std::filesystem::canonical(p);
+  p2 = std::filesystem::canonical(p, ec);
 
   std::filesystem::copy(p, p);
   std::filesystem::copy(p, p, ec);

diff --git a/libstdc++-v3/testsuite/27_io/filesystem/operations/canonical.cc b/libstdc++-v3/testsuite/27_io/filesystem/operations/canonical.cc
index 9c432b25acfb63b5c8a51bbccb38054027f3d262..cb916a6f6b9c0ea4858e9fe67186be2d05c75ba9 100644 (file)
--- a/libstdc++-v3/testsuite/27_io/filesystem/operations/canonical.cc
+++ b/libstdc++-v3/testsuite/27_io/filesystem/operations/canonical.cc
@@ -31,7 +31,7 @@ test01()
   const std::error_code bad_ec = make_error_code(std::errc::invalid_argument);
   std::error_code ec;
   auto p = __gnu_test::nonexistent_path();
-  canonical( p, ec );
+  (void) canonical( p, ec );
   VERIFY( ec );
 
   create_directory(p);
@@ -90,7 +90,7 @@ test02()
 #if __cpp_exceptions
   fs::path e1, e2;
   try {
-    canonical(p);
+    (void) canonical(p);
   } catch (const fs::filesystem_error& e) {
     e1 = e.path1();
     e2 = e.path2();

diff --git a/libstdc++-v3/testsuite/27_io/filesystem/operations/exists.cc b/libstdc++-v3/testsuite/27_io/filesystem/operations/exists.cc
index b3063564ab4379f7bda4c2dddc0ebeecaa7df8ae..f9956970b253a1efd893b1f72f5316358c5ccc68 100644 (file)
--- a/libstdc++-v3/testsuite/27_io/filesystem/operations/exists.cc
+++ b/libstdc++-v3/testsuite/27_io/filesystem/operations/exists.cc
@@ -95,7 +95,7 @@ test04()
   ec.clear();
   try
   {
-    exists(unr);
+    (void) exists(unr);
   }
   catch(const std::filesystem::filesystem_error& ex)
   {

diff --git a/libstdc++-v3/testsuite/27_io/filesystem/operations/is_empty.cc b/libstdc++-v3/testsuite/27_io/filesystem/operations/is_empty.cc
index 23246a4228c1066625343805d398f4cbc0c05022..d1dfd9f6dda6a07bff7e8e1e26ccac420b442d7d 100644 (file)
--- a/libstdc++-v3/testsuite/27_io/filesystem/operations/is_empty.cc
+++ b/libstdc++-v3/testsuite/27_io/filesystem/operations/is_empty.cc
@@ -40,7 +40,7 @@ test01()
   VERIFY( !result );
 
   try {
-    fs::is_empty(p);
+    (void) fs::is_empty(p);
   } catch (const fs::filesystem_error& e) {
     ec2 = e.code();
   }
@@ -51,7 +51,7 @@ test01()
   VERIFY( !result );
 
   try {
-    fs::is_empty(p/"f");
+    (void) fs::is_empty(p/"f");
   } catch (const fs::filesystem_error& e) {
     ec2 = e.code();
   }

diff --git a/libstdc++-v3/testsuite/27_io/filesystem/operations/read_symlink.cc b/libstdc++-v3/testsuite/27_io/filesystem/operations/read_symlink.cc
index 030d6271de525ae8eb1732045e76919b6ca11bff..28be8cc3a644019300774342105f7b49aa0d7c12 100644 (file)
--- a/libstdc++-v3/testsuite/27_io/filesystem/operations/read_symlink.cc
+++ b/libstdc++-v3/testsuite/27_io/filesystem/operations/read_symlink.cc
@@ -31,7 +31,7 @@ test01()
   auto p = __gnu_test::nonexistent_path();
   std::error_code ec;
 
-  read_symlink(p, ec);
+  (void) read_symlink(p, ec);
   VERIFY( ec );
 
   fs::path tgt = ".";

diff --git a/libstdc++-v3/testsuite/27_io/filesystem/operations/status.cc b/libstdc++-v3/testsuite/27_io/filesystem/operations/status.cc
index f2d2582ce414822d9b95c015d540a2bb267716c2..c43ba29fd7fb7fa80143478f5ba00939c7eafac4 100644 (file)
--- a/libstdc++-v3/testsuite/27_io/filesystem/operations/status.cc
+++ b/libstdc++-v3/testsuite/27_io/filesystem/operations/status.cc
@@ -74,7 +74,7 @@ test03()
   std::error_code ec2;
   fs::path p, p2;
   try {
-    fs::symlink_status(f.path);
+    (void) fs::symlink_status(f.path);
   } catch (const fs::filesystem_error& e) {
     caught = true;
     p = e.path1();

diff --git a/libstdc++-v3/testsuite/27_io/filesystem/operations/symlink_status.cc b/libstdc++-v3/testsuite/27_io/filesystem/operations/symlink_status.cc
index e00e4aaa78e77d669b73224fb12aff84da27b9b3..c8fa5c0f27fd214a6de9f0ff38449effc9b6f84c 100644 (file)
--- a/libstdc++-v3/testsuite/27_io/filesystem/operations/symlink_status.cc
+++ b/libstdc++-v3/testsuite/27_io/filesystem/operations/symlink_status.cc
@@ -96,7 +96,7 @@ test03()
   std::error_code ec2;
   fs::path p, p2;
   try {
-    fs::symlink_status(f.path);
+    (void) fs::symlink_status(f.path);
   } catch (const fs::filesystem_error& e) {
     caught = true;
     p = e.path1();

diff --git a/libstdc++-v3/testsuite/27_io/filesystem/operations/temp_directory_path.cc b/libstdc++-v3/testsuite/27_io/filesystem/operations/temp_directory_path.cc
index 56bd7408c2d9506403114f5f8d87b09036595353..09d97c5e01c45b953967c07b9936c06c2662786d 100644 (file)
--- a/libstdc++-v3/testsuite/27_io/filesystem/operations/temp_directory_path.cc
+++ b/libstdc++-v3/testsuite/27_io/filesystem/operations/temp_directory_path.cc
@@ -117,7 +117,7 @@ test03()
 
   std::error_code ec2;
   try {
-    fs::temp_directory_path();
+    (void) fs::temp_directory_path();
   } catch (const fs::filesystem_error& e) {
     ec2 = e.code();
   }
@@ -142,7 +142,7 @@ test04()
   std::error_code ec2;
   std::string failed_path;
   try {
-    fs::temp_directory_path();
+    (void) fs::temp_directory_path();
   } catch (const fs::filesystem_error& e) {
     ec2 = e.code();
     // On Windows the returned path will be in preferred form, i.e. using L'\\'

diff --git a/libstdc++-v3/testsuite/experimental/filesystem/operations/canonical.cc b/libstdc++-v3/testsuite/experimental/filesystem/operations/canonical.cc
index aef6725d7762c211c418e4fabb9f67d6f30a2180..92772db73ed1073853147256d7dc7b859f439ff7 100644 (file)
--- a/libstdc++-v3/testsuite/experimental/filesystem/operations/canonical.cc
+++ b/libstdc++-v3/testsuite/experimental/filesystem/operations/canonical.cc
@@ -30,11 +30,11 @@ test01()
 {
   std::error_code ec;
   auto p = __gnu_test::nonexistent_path();
-  canonical( p, ec );
+  (void) canonical( p, ec );
   VERIFY( ec );
 
   p = fs::current_path();
-  canonical( p, ec );
+  (void) canonical( p, ec );
   VERIFY( !ec );
 
   const auto root = fs::absolute("/");
@@ -67,7 +67,7 @@ test02()
   fs::path p = "rel", base = __gnu_test::nonexistent_path();
   fs::path e1, e2;
   try {
-    canonical(p, base);
+    (void) canonical(p, base);
   } catch (const fs::filesystem_error& e) {
     e1 = e.path1();
     e2 = e.path2();

diff --git a/libstdc++-v3/testsuite/experimental/filesystem/operations/exists.cc b/libstdc++-v3/testsuite/experimental/filesystem/operations/exists.cc
index 5c274d073c245fc23ee1373ab8388f1dd97f0c53..271aff9717fb94d1f798bf05aab85f8ad5b18a6b 100644 (file)
--- a/libstdc++-v3/testsuite/experimental/filesystem/operations/exists.cc
+++ b/libstdc++-v3/testsuite/experimental/filesystem/operations/exists.cc
@@ -89,7 +89,7 @@ test04()
   ec.clear();
   try
   {
-    exists(unr);
+    (void) exists(unr);
   }
   catch(const std::experimental::filesystem::filesystem_error& ex)
   {

diff --git a/libstdc++-v3/testsuite/experimental/filesystem/operations/is_empty.cc b/libstdc++-v3/testsuite/experimental/filesystem/operations/is_empty.cc
index 747236379e407d06e0f8424bc9139c8301943959..da21c8da0be08ecebc36e482892a0b59038e68f6 100644 (file)
--- a/libstdc++-v3/testsuite/experimental/filesystem/operations/is_empty.cc
+++ b/libstdc++-v3/testsuite/experimental/filesystem/operations/is_empty.cc
@@ -41,7 +41,7 @@ test01()
   VERIFY( !result );
 
   try {
-    fs::is_empty(p);
+    (void) fs::is_empty(p);
   } catch (const fs::filesystem_error& e) {
     ec2 = e.code();
   }
@@ -52,7 +52,7 @@ test01()
   VERIFY( !result );
 
   try {
-    fs::is_empty(p/"f");
+    (void) fs::is_empty(p/"f");
   } catch (const fs::filesystem_error& e) {
     ec2 = e.code();
   }

diff --git a/libstdc++-v3/testsuite/experimental/filesystem/operations/read_symlink.cc b/libstdc++-v3/testsuite/experimental/filesystem/operations/read_symlink.cc
index d0a90976a71155c32bc9f15bb34a1d07bd6e7975..a29ceeb349931f301fe97955acffe17592547418 100644 (file)
--- a/libstdc++-v3/testsuite/experimental/filesystem/operations/read_symlink.cc
+++ b/libstdc++-v3/testsuite/experimental/filesystem/operations/read_symlink.cc
@@ -32,7 +32,7 @@ test01()
   auto p = __gnu_test::nonexistent_path();
   std::error_code ec;
 
-  read_symlink(p, ec);
+  (void) read_symlink(p, ec);
   VERIFY( ec );
 
   fs::path tgt = ".";

diff --git a/libstdc++-v3/testsuite/experimental/filesystem/operations/temp_directory_path.cc b/libstdc++-v3/testsuite/experimental/filesystem/operations/temp_directory_path.cc
index 1772f9737c15f542e14d46da7c7ef2938579c061..d985f112f10b768b3ac180bb1b90dfecd36a731e 100644 (file)
--- a/libstdc++-v3/testsuite/experimental/filesystem/operations/temp_directory_path.cc
+++ b/libstdc++-v3/testsuite/experimental/filesystem/operations/temp_directory_path.cc
@@ -118,7 +118,7 @@ test03()
 
   std::error_code ec2;
   try {
-    fs::temp_directory_path();
+    (void) fs::temp_directory_path();
   } catch (const fs::filesystem_error& e) {
     ec2 = e.code();
   }
@@ -143,7 +143,7 @@ test04()
   std::error_code ec2;
   std::string failed_path;
   try {
-    fs::temp_directory_path();
+    (void) fs::temp_directory_path();
   } catch (const fs::filesystem_error& e) {
     ec2 = e.code();
     // On Windows the returned path will be in preferred form, i.e. using L'\\'