clang: Enable -Weverything, fix all warnings

CMakeLists.txt

@@ -78,6 +78,7 @@ set(CPPDAP_LIST
     ${CPPDAP_SRC_DIR}/protocol_types.cpp
     ${CPPDAP_SRC_DIR}/session.cpp
     ${CPPDAP_SRC_DIR}/socket.cpp
+    ${CPPDAP_SRC_DIR}/typeinfo.cpp
     ${CPPDAP_SRC_DIR}/typeof.cpp
 )
 

include/dap/future.h

@@ -89,7 +89,7 @@ class future {
 };
 
 template <typename T>
-future<T>::future(const std::shared_ptr<State>& state) : state(state) {}
+future<T>::future(const std::shared_ptr<State>& s) : state(s) {}
 
 template <typename T>
 bool future<T>::valid() const {

include/dap/serialization.h

@@ -38,6 +38,8 @@ struct Field {
 // Methods that return a bool use this to indicate success.
 class Deserializer {
  public:
+  virtual ~Deserializer() = default;
+
   // deserialization methods for simple data types.
   // If the stored object is not of the correct type, then these function will
   // return false.
@@ -104,7 +106,7 @@ bool Deserializer::deserialize(dap::optional<T>* opt) const {
   T v;
   if (deserialize(&v)) {
     *opt = v;
-  };
+  }
   return true;
 }
 
@@ -132,6 +134,8 @@ class FieldSerializer;
 // Methods that return a bool use this to indicate success.
 class Serializer {
  public:
+  virtual ~Serializer() = default;
+
   // serialization methods for simple data types.
   virtual bool serialize(boolean) = 0;
   virtual bool serialize(integer) = 0;
@@ -215,6 +219,8 @@ class FieldSerializer {
   template <typename T>
   using IsSerializeFunc = std::is_convertible<T, SerializeFunc>;
 
+  virtual ~FieldSerializer() = default;
+
   // field() encodes a field to the struct object referenced by this Serializer.
   // The SerializeFunc will be called with a Serializer used to encode the
   // field's data.

include/dap/session.h

@@ -98,14 +98,13 @@ struct ResponseOrError {
 };
 
 template <typename T>
-ResponseOrError<T>::ResponseOrError(const T& response) : response(response) {}
+ResponseOrError<T>::ResponseOrError(const T& resp) : response(resp) {}
 template <typename T>
-ResponseOrError<T>::ResponseOrError(T&& response)
-    : response(std::move(response)) {}
+ResponseOrError<T>::ResponseOrError(T&& resp) : response(std::move(resp)) {}
 template <typename T>
-ResponseOrError<T>::ResponseOrError(const Error& error) : error(error) {}
+ResponseOrError<T>::ResponseOrError(const Error& err) : error(err) {}
 template <typename T>
-ResponseOrError<T>::ResponseOrError(Error&& error) : error(std::move(error)) {}
+ResponseOrError<T>::ResponseOrError(Error&& err) : error(std::move(err)) {}
 template <typename T>
 ResponseOrError<T>::ResponseOrError(const ResponseOrError& other)
     : response(other.response), error(other.error) {}
@@ -148,7 +147,7 @@ class Session {
   using ArgTy = typename detail::ArgTy<F>::type;
 
  public:
-  virtual ~Session() = default;
+  virtual ~Session();
 
   // ErrorHandler is the type of callback function used for reporting protocol
   // errors.

include/dap/typeinfo.h

@@ -28,6 +28,7 @@ class Serializer;
 // types. TypeInfo is used by the serialization system to encode and decode DAP
 // requests, responses, events and structs.
 struct TypeInfo {
+  virtual ~TypeInfo();
   virtual std::string name() const = 0;
   virtual size_t size() const = 0;
   virtual size_t alignment() const = 0;

include/dap/typeof.h

@@ -26,7 +26,7 @@ namespace dap {
 // template type T.
 template <typename T>
 struct BasicTypeInfo : public TypeInfo {
-  BasicTypeInfo(const std::string& name) : name_(name) {}
+  constexpr BasicTypeInfo(std::string&& name) : name_(std::move(name)) {}
 
   // TypeInfo compliance
   inline std::string name() const { return name_; }
@@ -88,6 +88,15 @@ struct TypeOf<null> {
   static const TypeInfo* type();
 };
 
+// TypeOf for template types requires dynamic generation of type information,
+// triggering the clang -Wexit-time-destructors warning.
+// TODO(bclayton): See if there's a way to avoid this, without requiring manual
+// instantiation of each type.
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wexit-time-destructors"
+#endif  // __clang__
+
 template <typename T>
 struct TypeOf<array<T>> {
   static inline const TypeInfo* type() {
@@ -114,6 +123,10 @@ struct TypeOf<optional<T>> {
   }
 };
 
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif  // __clang__
+
 // DAP_OFFSETOF() macro is a generalization of the offsetof() macro defined in
 // <cstddef>. It evaluates to the offset of the given field, with fewer
 // restrictions than offsetof(). We cast the address '32' and subtract it again,

include/dap/variant.h

@@ -72,7 +72,7 @@ variant<T0, Types...>::variant() : value(T0()) {}
 
 template <typename T0, typename... Types>
 template <typename T>
-variant<T0, Types...>::variant(const T& value) : value(value) {
+variant<T0, Types...>::variant(const T& v) : value(v) {
   static_assert(accepts<T>(), "variant does not accept template type T");
 }
 

src/protocol_events.cpp

@@ -21,53 +21,37 @@
 
 namespace dap {
 
-BreakpointEvent::BreakpointEvent() = default;
-BreakpointEvent::~BreakpointEvent() = default;
 DAP_IMPLEMENT_STRUCT_TYPEINFO(BreakpointEvent,
                               "breakpoint",
                               DAP_FIELD(breakpoint, "breakpoint"),
                               DAP_FIELD(reason, "reason"));
 
-CapabilitiesEvent::CapabilitiesEvent() = default;
-CapabilitiesEvent::~CapabilitiesEvent() = default;
 DAP_IMPLEMENT_STRUCT_TYPEINFO(CapabilitiesEvent,
                               "capabilities",
                               DAP_FIELD(capabilities, "capabilities"));
 
-ContinuedEvent::ContinuedEvent() = default;
-ContinuedEvent::~ContinuedEvent() = default;
 DAP_IMPLEMENT_STRUCT_TYPEINFO(ContinuedEvent,
                               "continued",
                               DAP_FIELD(allThreadsContinued,
                                         "allThreadsContinued"),
                               DAP_FIELD(threadId, "threadId"));
 
-ExitedEvent::ExitedEvent() = default;
-ExitedEvent::~ExitedEvent() = default;
 DAP_IMPLEMENT_STRUCT_TYPEINFO(ExitedEvent,
                               "exited",
                               DAP_FIELD(exitCode, "exitCode"));
 
-InitializedEvent::InitializedEvent() = default;
-InitializedEvent::~InitializedEvent() = default;
 DAP_IMPLEMENT_STRUCT_TYPEINFO(InitializedEvent, "initialized");
 
-LoadedSourceEvent::LoadedSourceEvent() = default;
-LoadedSourceEvent::~LoadedSourceEvent() = default;
 DAP_IMPLEMENT_STRUCT_TYPEINFO(LoadedSourceEvent,
                               "loadedSource",
                               DAP_FIELD(reason, "reason"),
                               DAP_FIELD(source, "source"));
 
-ModuleEvent::ModuleEvent() = default;
-ModuleEvent::~ModuleEvent() = default;
 DAP_IMPLEMENT_STRUCT_TYPEINFO(ModuleEvent,
                               "module",
                               DAP_FIELD(module, "module"),
                               DAP_FIELD(reason, "reason"));
 
-OutputEvent::OutputEvent() = default;
-OutputEvent::~OutputEvent() = default;
 DAP_IMPLEMENT_STRUCT_TYPEINFO(OutputEvent,
                               "output",
                               DAP_FIELD(category, "category"),
@@ -80,8 +64,6 @@ DAP_IMPLEMENT_STRUCT_TYPEINFO(OutputEvent,
                               DAP_FIELD(variablesReference,
                                         "variablesReference"));
 
-ProcessEvent::ProcessEvent() = default;
-ProcessEvent::~ProcessEvent() = default;
 DAP_IMPLEMENT_STRUCT_TYPEINFO(ProcessEvent,
                               "process",
                               DAP_FIELD(isLocalProcess, "isLocalProcess"),
@@ -90,15 +72,11 @@ DAP_IMPLEMENT_STRUCT_TYPEINFO(ProcessEvent,
                               DAP_FIELD(startMethod, "startMethod"),
                               DAP_FIELD(systemProcessId, "systemProcessId"));
 
-ProgressEndEvent::ProgressEndEvent() = default;
-ProgressEndEvent::~ProgressEndEvent() = default;
 DAP_IMPLEMENT_STRUCT_TYPEINFO(ProgressEndEvent,
                               "progressEnd",
                               DAP_FIELD(message, "message"),
                               DAP_FIELD(progressId, "progressId"));
 
-ProgressStartEvent::ProgressStartEvent() = default;
-ProgressStartEvent::~ProgressStartEvent() = default;
 DAP_IMPLEMENT_STRUCT_TYPEINFO(ProgressStartEvent,
                               "progressStart",
                               DAP_FIELD(cancellable, "cancellable"),
@@ -108,16 +86,12 @@ DAP_IMPLEMENT_STRUCT_TYPEINFO(ProgressStartEvent,
                               DAP_FIELD(requestId, "requestId"),
                               DAP_FIELD(title, "title"));
 
-ProgressUpdateEvent::ProgressUpdateEvent() = default;
-ProgressUpdateEvent::~ProgressUpdateEvent() = default;
 DAP_IMPLEMENT_STRUCT_TYPEINFO(ProgressUpdateEvent,
                               "progressUpdate",
                               DAP_FIELD(message, "message"),
                               DAP_FIELD(percentage, "percentage"),
                               DAP_FIELD(progressId, "progressId"));
 
-StoppedEvent::StoppedEvent() = default;
-StoppedEvent::~StoppedEvent() = default;
 DAP_IMPLEMENT_STRUCT_TYPEINFO(StoppedEvent,
                               "stopped",
                               DAP_FIELD(allThreadsStopped, "allThreadsStopped"),
@@ -127,14 +101,10 @@ DAP_IMPLEMENT_STRUCT_TYPEINFO(StoppedEvent,
                               DAP_FIELD(text, "text"),
                               DAP_FIELD(threadId, "threadId"));
 
-TerminatedEvent::TerminatedEvent() = default;
-TerminatedEvent::~TerminatedEvent() = default;
 DAP_IMPLEMENT_STRUCT_TYPEINFO(TerminatedEvent,
                               "terminated",
                               DAP_FIELD(restart, "restart"));
 
-ThreadEvent::ThreadEvent() = default;
-ThreadEvent::~ThreadEvent() = default;
 DAP_IMPLEMENT_STRUCT_TYPEINFO(ThreadEvent,
                               "thread",
                               DAP_FIELD(reason, "reason"),

src/session.cpp

@@ -481,6 +481,8 @@ Error::Error(const char* msg, ...) {
   message = buf;
 }
 
+Session::~Session() = default;
+
 std::unique_ptr<Session> Session::create() {
   return std::unique_ptr<Session>(new Impl());
 }

src/typeinfo.cpp

+// Copyright 2020 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "dap/typeinfo.h"
+
+namespace dap {
+
+TypeInfo::~TypeInfo() = default;
+
+}  // namespace dap

tools/protocol_gen/protocol_gen.go

@@ -313,16 +313,6 @@ func (s *cppStruct) writeHeader(w io.Writer) {
 		io.WriteString(w, ";")
 	}
 
-	// constructor
-	io.WriteString(w, "\n\n  ")
-	io.WriteString(w, s.name)
-	io.WriteString(w, "();")
-
-	// destructor
-	io.WriteString(w, "\n  ~")
-	io.WriteString(w, s.name)
-	io.WriteString(w, "();\n")
-
 	for _, f := range s.fields {
 		if f.desc != "" {
 			io.WriteString(w, "\n  // ")
@@ -353,18 +343,6 @@ func (s *cppStruct) writeHeader(w io.Writer) {
 }
 
 func (s *cppStruct) writeCPP(w io.Writer) {
-	// constructor
-	io.WriteString(w, s.name)
-	io.WriteString(w, "::")
-	io.WriteString(w, s.name)
-	io.WriteString(w, "() = default;\n")
-
-	// destructor
-	io.WriteString(w, s.name)
-	io.WriteString(w, "::~")
-	io.WriteString(w, s.name)
-	io.WriteString(w, "() = default;\n")
-
 	// typeinfo
 	io.WriteString(w, "DAP_IMPLEMENT_STRUCT_TYPEINFO(")
 	io.WriteString(w, s.name)