[common,geometry] Remove inline destructors (#22030)

common/symbolic/chebyshev_basis_element.cc

@@ -31,6 +31,8 @@ ChebyshevBasisElement::ChebyshevBasisElement(
     const Eigen::Ref<const Eigen::VectorXi>& degrees)
     : PolynomialBasisElement(vars, degrees) {}
 
+ChebyshevBasisElement::~ChebyshevBasisElement() = default;
+
 bool ChebyshevBasisElement::operator<(
     const ChebyshevBasisElement& other) const {
   return this->lexicographical_compare(other);

common/symbolic/chebyshev_basis_element.h

@@ -40,7 +40,7 @@ class ChebyshevBasisElement : public PolynomialBasisElement {
   ChebyshevBasisElement(const Eigen::Ref<const VectorX<Variable>>& vars,
                         const Eigen::Ref<const Eigen::VectorXi>& degrees);
 
-  ~ChebyshevBasisElement() override = default;
+  ~ChebyshevBasisElement() override;
 
   /**
    * Compares two ChebyshevBasisElement in lexicographic order.

common/symbolic/expression/environment.cc

@@ -57,6 +57,8 @@ Environment::Environment(map m) : map_{std::move(m)} {
   }
 }
 
+Environment::~Environment() = default;
+
 void Environment::insert(const key_type& key, const mapped_type& elem) {
   throw_if_nan(elem);
   map_.emplace(key, elem);

common/symbolic/expression/environment.h

@@ -75,6 +75,8 @@ class Environment {
    */
   explicit Environment(map m);
 
+  ~Environment();
+
   /** Returns an iterator to the beginning. */
   iterator begin() { return map_.begin(); }
   /** Returns an iterator to the end. */

common/symbolic/expression/expression.h

@@ -166,6 +166,8 @@ symbolic::Expression can be used as a scalar type of Eigen types.
 class Expression {
  public:
   DRAKE_DEFAULT_COPY_AND_MOVE_AND_ASSIGN(Expression);
+
+  // The destructor is inlined for performance.
   ~Expression() = default;
 
   /** Default constructor. It constructs Zero(). */

common/symbolic/expression/expression_cell.cc

@@ -244,6 +244,8 @@ UnaryExpressionCell::UnaryExpressionCell(const ExpressionKind k, Expression e,
                                          const bool is_expanded)
     : ExpressionCell{k, is_poly, is_expanded}, e_{std::move(e)} {}
 
+UnaryExpressionCell::~UnaryExpressionCell() = default;
+
 void UnaryExpressionCell::HashAppendDetail(DelegatingHasher* hasher) const {
   DRAKE_ASSERT(hasher != nullptr);
   using drake::hash_append;
@@ -281,6 +283,8 @@ BinaryExpressionCell::BinaryExpressionCell(const ExpressionKind k,
       e1_{std::move(e1)},
       e2_{std::move(e2)} {}
 
+BinaryExpressionCell::~BinaryExpressionCell() = default;
+
 void BinaryExpressionCell::HashAppendDetail(DelegatingHasher* hasher) const {
   DRAKE_ASSERT(hasher != nullptr);
   using drake::hash_append;
@@ -328,6 +332,8 @@ ExpressionVar::ExpressionVar(Variable v)
   DRAKE_DEMAND(var_.get_type() != Variable::Type::BOOLEAN);
 }
 
+ExpressionVar::~ExpressionVar() = default;
+
 void ExpressionVar::HashAppendDetail(DelegatingHasher* hasher) const {
   DRAKE_ASSERT(hasher != nullptr);
   using drake::hash_append;
@@ -400,6 +406,8 @@ ostream& ExpressionVar::Display(ostream& os) const {
 ExpressionNaN::ExpressionNaN()
     : ExpressionCell{ExpressionKind::NaN, false, false} {}
 
+ExpressionNaN::~ExpressionNaN() = default;
+
 void ExpressionNaN::HashAppendDetail(DelegatingHasher*) const {}
 
 Variables ExpressionNaN::GetVariables() const {
@@ -451,6 +459,8 @@ ExpressionAdd::ExpressionAdd(const double constant,
   DRAKE_ASSERT(!expr_to_coeff_map_.empty());
 }
 
+ExpressionAdd::~ExpressionAdd() = default;
+
 void ExpressionAdd::HashAppendDetail(DelegatingHasher* hasher) const {
   using drake::hash_append;
   hash_append(*hasher, constant_);
@@ -617,6 +627,8 @@ ExpressionAddFactory::ExpressionAddFactory(const ExpressionAdd& add)
   is_expanded_ = add.is_expanded();
 }
 
+ExpressionAddFactory::~ExpressionAddFactory() = default;
+
 void ExpressionAddFactory::AddExpression(const Expression& e) {
   if (is_constant(e)) {
     const double v{get_constant_value(e)};
@@ -732,6 +744,8 @@ ExpressionMul::ExpressionMul(const double constant,
   DRAKE_ASSERT(!base_to_exponent_map_.empty());
 }
 
+ExpressionMul::~ExpressionMul() = default;
+
 void ExpressionMul::HashAppendDetail(DelegatingHasher* hasher) const {
   using drake::hash_append;
   hash_append(*hasher, constant_);
@@ -946,6 +960,8 @@ ExpressionMulFactory::ExpressionMulFactory(const ExpressionMul& mul)
   is_expanded_ = mul.is_expanded();
 }
 
+ExpressionMulFactory::~ExpressionMulFactory() = default;
+
 void ExpressionMulFactory::AddExpression(const Expression& e) {
   if (constant_ == 0.0) {
     return;  // Do nothing if it already represented 0.
@@ -1075,6 +1091,8 @@ ExpressionDiv::ExpressionDiv(const Expression& e1, const Expression& e2)
     : BinaryExpressionCell{ExpressionKind::Div, e1, e2,
                            e1.is_polynomial() && is_constant(e2), false} {}
 
+ExpressionDiv::~ExpressionDiv() = default;
+
 namespace {
 // Helper class to implement ExpressionDiv::Expand. Given a symbolic expression
 // `e` and a constant `n`, it pushes the division in `e / n` inside for the
@@ -1281,6 +1299,8 @@ double ExpressionDiv::DoEvaluate(const double v1, const double v2) const {
 ExpressionLog::ExpressionLog(const Expression& e)
     : UnaryExpressionCell{ExpressionKind::Log, e, false, e.is_expanded()} {}
 
+ExpressionLog::~ExpressionLog() = default;
+
 void ExpressionLog::check_domain(const double v) {
   if (!(v >= 0)) {
     ostringstream oss;
@@ -1321,6 +1341,8 @@ double ExpressionLog::DoEvaluate(const double v) const {
 ExpressionAbs::ExpressionAbs(const Expression& e)
     : UnaryExpressionCell{ExpressionKind::Abs, e, false, e.is_expanded()} {}
 
+ExpressionAbs::~ExpressionAbs() = default;
+
 Expression ExpressionAbs::Expand() const {
   const Expression& arg{get_argument()};
   return abs(arg.is_expanded() ? arg : arg.Expand());
@@ -1356,6 +1378,8 @@ double ExpressionAbs::DoEvaluate(const double v) const {
 ExpressionExp::ExpressionExp(const Expression& e)
     : UnaryExpressionCell{ExpressionKind::Exp, e, false, e.is_expanded()} {}
 
+ExpressionExp::~ExpressionExp() = default;
+
 Expression ExpressionExp::Expand() const {
   const Expression& arg{get_argument()};
   return exp(arg.is_expanded() ? arg : arg.Expand());
@@ -1386,6 +1410,8 @@ double ExpressionExp::DoEvaluate(const double v) const {
 ExpressionSqrt::ExpressionSqrt(const Expression& e)
     : UnaryExpressionCell{ExpressionKind::Sqrt, e, false, e.is_expanded()} {}
 
+ExpressionSqrt::~ExpressionSqrt() = default;
+
 void ExpressionSqrt::check_domain(const double v) {
   if (!(v >= 0)) {
     ostringstream oss;
@@ -1428,6 +1454,8 @@ ExpressionPow::ExpressionPow(const Expression& e1, const Expression& e2)
                            determine_polynomial(e1, e2),
                            IsLeafExpression(e1) && IsLeafExpression(e2)} {}
 
+ExpressionPow::~ExpressionPow() = default;
+
 void ExpressionPow::check_domain(const double v1, const double v2) {
   if (std::isfinite(v1) && (v1 < 0.0) && std::isfinite(v2) && !is_integer(v2)) {
     ostringstream oss;
@@ -1473,6 +1501,8 @@ double ExpressionPow::DoEvaluate(const double v1, const double v2) const {
 ExpressionSin::ExpressionSin(const Expression& e)
     : UnaryExpressionCell{ExpressionKind::Sin, e, false, e.is_expanded()} {}
 
+ExpressionSin::~ExpressionSin() = default;
+
 Expression ExpressionSin::Expand() const {
   const Expression& arg{get_argument()};
   return sin(arg.is_expanded() ? arg : arg.Expand());
@@ -1503,6 +1533,8 @@ double ExpressionSin::DoEvaluate(const double v) const {
 ExpressionCos::ExpressionCos(const Expression& e)
     : UnaryExpressionCell{ExpressionKind::Cos, e, false, e.is_expanded()} {}
 
+ExpressionCos::~ExpressionCos() = default;
+
 Expression ExpressionCos::Expand() const {
   const Expression& arg{get_argument()};
   return cos(arg.is_expanded() ? arg : arg.Expand());
@@ -1533,6 +1565,8 @@ double ExpressionCos::DoEvaluate(const double v) const {
 ExpressionTan::ExpressionTan(const Expression& e)
     : UnaryExpressionCell{ExpressionKind::Tan, e, false, e.is_expanded()} {}
 
+ExpressionTan::~ExpressionTan() = default;
+
 Expression ExpressionTan::Expand() const {
   const Expression& arg{get_argument()};
   return tan(arg.is_expanded() ? arg : arg.Expand());
@@ -1563,6 +1597,8 @@ double ExpressionTan::DoEvaluate(const double v) const {
 ExpressionAsin::ExpressionAsin(const Expression& e)
     : UnaryExpressionCell{ExpressionKind::Asin, e, false, e.is_expanded()} {}
 
+ExpressionAsin::~ExpressionAsin() = default;
+
 void ExpressionAsin::check_domain(const double v) {
   if (!((v >= -1.0) && (v <= 1.0))) {
     ostringstream oss;
@@ -1603,6 +1639,8 @@ double ExpressionAsin::DoEvaluate(const double v) const {
 ExpressionAcos::ExpressionAcos(const Expression& e)
     : UnaryExpressionCell{ExpressionKind::Acos, e, false, e.is_expanded()} {}
 
+ExpressionAcos::~ExpressionAcos() = default;
+
 void ExpressionAcos::check_domain(const double v) {
   if (!((v >= -1.0) && (v <= 1.0))) {
     ostringstream oss;
@@ -1643,6 +1681,8 @@ double ExpressionAcos::DoEvaluate(const double v) const {
 ExpressionAtan::ExpressionAtan(const Expression& e)
     : UnaryExpressionCell{ExpressionKind::Atan, e, false, e.is_expanded()} {}
 
+ExpressionAtan::~ExpressionAtan() = default;
+
 Expression ExpressionAtan::Expand() const {
   const Expression& arg{get_argument()};
   return atan(arg.is_expanded() ? arg : arg.Expand());
@@ -1674,6 +1714,8 @@ ExpressionAtan2::ExpressionAtan2(const Expression& e1, const Expression& e2)
     : BinaryExpressionCell{ExpressionKind::Atan2, e1, e2, false,
                            e1.is_expanded() && e2.is_expanded()} {}
 
+ExpressionAtan2::~ExpressionAtan2() = default;
+
 Expression ExpressionAtan2::Expand() const {
   const Expression& e1{get_first_argument()};
   const Expression& e2{get_second_argument()};
@@ -1711,6 +1753,8 @@ double ExpressionAtan2::DoEvaluate(const double v1, const double v2) const {
 ExpressionSinh::ExpressionSinh(const Expression& e)
     : UnaryExpressionCell{ExpressionKind::Sinh, e, false, e.is_expanded()} {}
 
+ExpressionSinh::~ExpressionSinh() = default;
+
 Expression ExpressionSinh::Expand() const {
   const Expression& arg{get_argument()};
   return sinh(arg.is_expanded() ? arg : arg.Expand());
@@ -1741,6 +1785,8 @@ double ExpressionSinh::DoEvaluate(const double v) const {
 ExpressionCosh::ExpressionCosh(const Expression& e)
     : UnaryExpressionCell{ExpressionKind::Cosh, e, false, e.is_expanded()} {}
 
+ExpressionCosh::~ExpressionCosh() = default;
+
 Expression ExpressionCosh::Expand() const {
   const Expression& arg{get_argument()};
   return cosh(arg.is_expanded() ? arg : arg.Expand());
@@ -1771,6 +1817,8 @@ double ExpressionCosh::DoEvaluate(const double v) const {
 ExpressionTanh::ExpressionTanh(const Expression& e)
     : UnaryExpressionCell{ExpressionKind::Tanh, e, false, e.is_expanded()} {}
 
+ExpressionTanh::~ExpressionTanh() = default;
+
 Expression ExpressionTanh::Expand() const {
   const Expression& arg{get_argument()};
   return tanh(arg.is_expanded() ? arg : arg.Expand());
@@ -1802,6 +1850,8 @@ ExpressionMin::ExpressionMin(const Expression& e1, const Expression& e2)
     : BinaryExpressionCell{ExpressionKind::Min, e1, e2, false,
                            e1.is_expanded() && e2.is_expanded()} {}
 
+ExpressionMin::~ExpressionMin() = default;
+
 Expression ExpressionMin::Expand() const {
   const Expression& e1{get_first_argument()};
   const Expression& e2{get_second_argument()};
@@ -1844,6 +1894,8 @@ ExpressionMax::ExpressionMax(const Expression& e1, const Expression& e2)
     : BinaryExpressionCell{ExpressionKind::Max, e1, e2, false,
                            e1.is_expanded() && e2.is_expanded()} {}
 
+ExpressionMax::~ExpressionMax() = default;
+
 Expression ExpressionMax::Expand() const {
   const Expression& e1{get_first_argument()};
   const Expression& e2{get_second_argument()};
@@ -1885,6 +1937,8 @@ double ExpressionMax::DoEvaluate(const double v1, const double v2) const {
 ExpressionCeiling::ExpressionCeiling(const Expression& e)
     : UnaryExpressionCell{ExpressionKind::Ceil, e, false, e.is_expanded()} {}
 
+ExpressionCeiling::~ExpressionCeiling() = default;
+
 Expression ExpressionCeiling::Expand() const {
   const Expression& arg{get_argument()};
   return ceil(arg.is_expanded() ? arg : arg.Expand());
@@ -1920,6 +1974,8 @@ double ExpressionCeiling::DoEvaluate(const double v) const {
 ExpressionFloor::ExpressionFloor(const Expression& e)
     : UnaryExpressionCell{ExpressionKind::Floor, e, false, e.is_expanded()} {}
 
+ExpressionFloor::~ExpressionFloor() = default;
+
 Expression ExpressionFloor::Expand() const {
   const Expression& arg{get_argument()};
   return floor(arg.is_expanded() ? arg : arg.Expand());
@@ -1961,6 +2017,8 @@ ExpressionIfThenElse::ExpressionIfThenElse(Formula f_cond, Expression e_then,
       e_then_{std::move(e_then)},
       e_else_{std::move(e_else)} {}
 
+ExpressionIfThenElse::~ExpressionIfThenElse() = default;
+
 void ExpressionIfThenElse::HashAppendDetail(DelegatingHasher* hasher) const {
   using drake::hash_append;
   hash_append(*hasher, f_cond_);
@@ -2078,6 +2136,8 @@ ExpressionUninterpretedFunction::ExpressionUninterpretedFunction(
       name_{std::move(name)},
       arguments_{std::move(arguments)} {}
 
+ExpressionUninterpretedFunction::~ExpressionUninterpretedFunction() = default;
+
 void ExpressionUninterpretedFunction::HashAppendDetail(
     DelegatingHasher* hasher) const {
   using drake::hash_append;