diff --git a/QuantLib.vcxproj b/QuantLib.vcxproj
index a4efc7bcc40..b6932c13874 100644
--- a/QuantLib.vcxproj
+++ b/QuantLib.vcxproj
@@ -923,6 +923,7 @@
     <ClInclude Include="ql\instruments\equitytotalreturnswap.hpp" />
     <ClInclude Include="ql\instruments\europeanoption.hpp" />
     <ClInclude Include="ql\instruments\fixedratebondforward.hpp" />
+    <ClInclude Include="ql\instruments\fixedvsfloatingswap.hpp" />
     <ClInclude Include="ql\instruments\floatfloatswap.hpp" />
     <ClInclude Include="ql\instruments\floatfloatswaption.hpp" />
     <ClInclude Include="ql\instruments\forward.hpp" />
@@ -2183,6 +2184,7 @@
     <ClCompile Include="ql\instruments\doublebarriertype.cpp" />
     <ClCompile Include="ql\instruments\equitytotalreturnswap.cpp" />
     <ClCompile Include="ql\instruments\europeanoption.cpp" />
+    <ClCompile Include="ql\instruments\fixedvsfloatingswap.cpp" />
     <ClCompile Include="ql\instruments\floatfloatswap.cpp" />
     <ClCompile Include="ql\instruments\floatfloatswaption.cpp" />
     <ClCompile Include="ql\instruments\forward.cpp" />
diff --git a/QuantLib.vcxproj.filters b/QuantLib.vcxproj.filters
index 6f8cacb3663..17f37995f21 100644
--- a/QuantLib.vcxproj.filters
+++ b/QuantLib.vcxproj.filters
@@ -828,6 +828,9 @@
     <ClInclude Include="ql\instruments\fixedratebondforward.hpp">
       <Filter>instruments</Filter>
     </ClInclude>
+    <ClInclude Include="ql\instruments\fixedvsfloatingswap.hpp">
+      <Filter>instruments</Filter>
+    </ClInclude>
     <ClInclude Include="ql\instruments\forward.hpp">
       <Filter>instruments</Filter>
     </ClInclude>
@@ -4712,6 +4715,9 @@
     <ClCompile Include="ql\instruments\europeanoption.cpp">
       <Filter>instruments</Filter>
     </ClCompile>
+    <ClCompile Include="ql\instruments\fixedvsfloatingswap.cpp">
+      <Filter>instruments</Filter>
+    </ClCompile>
     <ClCompile Include="ql\instruments\forward.cpp">
       <Filter>instruments</Filter>
     </ClCompile>
diff --git a/ql/CMakeLists.txt b/ql/CMakeLists.txt
index 34e7332439f..7c2609d323b 100644
--- a/ql/CMakeLists.txt
+++ b/ql/CMakeLists.txt
@@ -285,6 +285,7 @@ set(QL_SOURCES
     instruments/doublebarriertype.cpp
     instruments/equitytotalreturnswap.cpp
     instruments/europeanoption.cpp
+    instruments/fixedvsfloatingswap.cpp
     instruments/floatfloatswap.cpp
     instruments/floatfloatswaption.cpp
     instruments/forward.cpp
@@ -1338,6 +1339,7 @@ set(QL_HEADERS
     instruments/equitytotalreturnswap.hpp
     instruments/europeanoption.hpp
     instruments/fixedratebondforward.hpp
+    instruments/fixedvsfloatingswap.hpp
     instruments/floatfloatswap.hpp
     instruments/floatfloatswaption.hpp
     instruments/forward.hpp
diff --git a/ql/instruments/Makefile.am b/ql/instruments/Makefile.am
index a223dbbf1d6..7c1021d17a2 100644
--- a/ql/instruments/Makefile.am
+++ b/ql/instruments/Makefile.am
@@ -33,6 +33,7 @@ this_include_HEADERS = \
     equitytotalreturnswap.hpp \
     europeanoption.hpp \
     fixedratebondforward.hpp \
+    fixedvsfloatingswap.hpp \
     floatfloatswap.hpp \
     floatfloatswaption.hpp \
     forward.hpp \
@@ -100,6 +101,7 @@ cpp_files = \
     doublebarriertype.cpp \
     equitytotalreturnswap.cpp \
     europeanoption.cpp \
+    fixedvsfloatingswap.cpp \
     floatfloatswap.cpp \
     floatfloatswaption.cpp \
     forward.cpp \
diff --git a/ql/instruments/all.hpp b/ql/instruments/all.hpp
index 2c3821c0b79..cd72c9a66d3 100644
--- a/ql/instruments/all.hpp
+++ b/ql/instruments/all.hpp
@@ -28,6 +28,7 @@
 #include <ql/instruments/equitytotalreturnswap.hpp>
 #include <ql/instruments/europeanoption.hpp>
 #include <ql/instruments/fixedratebondforward.hpp>
+#include <ql/instruments/fixedvsfloatingswap.hpp>
 #include <ql/instruments/floatfloatswap.hpp>
 #include <ql/instruments/floatfloatswaption.hpp>
 #include <ql/instruments/forward.hpp>
diff --git a/ql/instruments/fixedvsfloatingswap.cpp b/ql/instruments/fixedvsfloatingswap.cpp
new file mode 100644
index 00000000000..719eacba5de
--- /dev/null
+++ b/ql/instruments/fixedvsfloatingswap.cpp
@@ -0,0 +1,246 @@
+/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*
+ Copyright (C) 2000, 2001, 2002, 2003 RiskMap srl
+ Copyright (C) 2003, 2004, 2005, 2006, 2007 StatPro Italia srl
+ Copyright (C) 2007 Ferdinando Ametrano
+
+ This file is part of QuantLib, a free-software/open-source library
+ for financial quantitative analysts and developers - http://quantlib.org/
+
+ QuantLib is free software: you can redistribute it and/or modify it
+ under the terms of the QuantLib license.  You should have received a
+ copy of the license along with this program; if not, please email
+ <quantlib-dev@lists.sf.net>. The license is also available online at
+ <http://quantlib.org/license.shtml>.
+
+ This program is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE.  See the license for more details.
+*/
+
+#include <ql/cashflows/cashflows.hpp>
+#include <ql/cashflows/cashflowvectors.hpp>
+#include <ql/cashflows/couponpricer.hpp>
+#include <ql/cashflows/fixedratecoupon.hpp>
+#include <ql/indexes/iborindex.hpp>
+#include <ql/instruments/fixedvsfloatingswap.hpp>
+#include <ql/termstructures/yieldtermstructure.hpp>
+#include <utility>
+
+namespace QuantLib {
+
+    FixedVsFloatingSwap::FixedVsFloatingSwap(Type type,
+                                             std::vector<Real> fixedNominals,
+                                             Schedule fixedSchedule,
+                                             Rate fixedRate,
+                                             DayCounter fixedDayCount,
+                                             std::vector<Real> floatingNominals,
+                                             Schedule floatingSchedule,
+                                             ext::shared_ptr<IborIndex> iborIndex,
+                                             Spread spread,
+                                             DayCounter floatingDayCount,
+                                             ext::optional<BusinessDayConvention> paymentConvention,
+                                             Natural paymentLag,
+                                             const Calendar& paymentCalendar)
+    : Swap(2), type_(type), fixedNominals_(std::move(fixedNominals)), fixedSchedule_(std::move(fixedSchedule)),
+      fixedRate_(fixedRate), fixedDayCount_(std::move(fixedDayCount)),
+      floatingNominals_(std::move(floatingNominals)), floatingSchedule_(std::move(floatingSchedule)),
+      iborIndex_(std::move(iborIndex)), spread_(spread), floatingDayCount_(std::move(floatingDayCount)) {
+
+        QL_REQUIRE(iborIndex_, "null floating index provided");
+
+        if (fixedDayCount_ == DayCounter())
+            fixedDayCount_ = iborIndex_->dayCounter();
+
+        if (paymentConvention) // NOLINT(readability-implicit-bool-conversion)
+            paymentConvention_ = *paymentConvention;
+        else
+            paymentConvention_ = floatingSchedule_.businessDayConvention();
+
+        legs_[0] = FixedRateLeg(fixedSchedule_)
+            .withNotionals(fixedNominals_)
+            .withCouponRates(fixedRate_, fixedDayCount_)
+            .withPaymentAdjustment(paymentConvention_)
+            .withPaymentLag(paymentLag)
+            .withPaymentCalendar(paymentCalendar.empty() ?
+                                 fixedSchedule_.calendar() :
+                                 paymentCalendar);
+
+        // legs_[1] to be built by derived class constructor
+
+        switch (type_) {
+          case Payer:
+            payer_[0] = -1.0;
+            payer_[1] = +1.0;
+            break;
+          case Receiver:
+            payer_[0] = +1.0;
+            payer_[1] = -1.0;
+            break;
+          default:
+            QL_FAIL("Unknown vanilla-swap type");
+        }
+
+
+        // These bools tell us if we can support the old methods nominal() and nominals().
+        // There might be false negatives (i.e., if we pass constant vectors of different lengths
+        // as fixedNominals and floatingNominals) but we're going to assume that whoever uses the
+        // constructor with two vectors is mostly going to use the new methods instead.
+        sameNominals_ = std::equal(fixedNominals_.begin(), fixedNominals_.end(),
+                                   floatingNominals_.begin(), floatingNominals_.end());
+        if (!sameNominals_) {
+            constantNominals_ = false;
+        } else {
+            constantNominals_ = true;
+            Real front = fixedNominals_[0];
+            for (auto x : fixedNominals_) {
+                if (x != front) {
+                    constantNominals_ = false;
+                    break;
+                }
+            }
+        }
+    }
+
+    void FixedVsFloatingSwap::setupArguments(PricingEngine::arguments* args) const {
+
+        Swap::setupArguments(args);
+
+        auto* arguments = dynamic_cast<FixedVsFloatingSwap::arguments*>(args);
+
+        if (arguments == nullptr) // it's a swap engine...
+            return;
+
+        arguments->type = type_;
+
+        if (constantNominals_)
+            arguments->nominal = nominal();
+        else
+            arguments->nominal = Null<Real>();
+
+        const Leg& fixedCoupons = fixedLeg();
+        Size n = fixedCoupons.size();
+
+        arguments->fixedResetDates = arguments->fixedPayDates = std::vector<Date>(n);
+        arguments->fixedNominals = arguments->fixedCoupons = std::vector<Real>(n);
+
+        for (Size i=0; i<n; ++i) {
+            auto coupon = ext::dynamic_pointer_cast<FixedRateCoupon>(fixedCoupons[i]);
+
+            arguments->fixedPayDates[i] = coupon->date();
+            arguments->fixedResetDates[i] = coupon->accrualStartDate();
+            arguments->fixedCoupons[i] = coupon->amount();
+            arguments->fixedNominals[i] = coupon->nominal();
+        }
+
+        setupFloatingArguments(arguments);
+    }
+
+    Rate FixedVsFloatingSwap::fairRate() const {
+        calculate();
+        QL_REQUIRE(fairRate_ != Null<Rate>(), "result not available");
+        return fairRate_;
+    }
+
+    Spread FixedVsFloatingSwap::fairSpread() const {
+        calculate();
+        QL_REQUIRE(fairSpread_ != Null<Spread>(), "result not available");
+        return fairSpread_;
+    }
+
+    Real FixedVsFloatingSwap::fixedLegBPS() const {
+        calculate();
+        QL_REQUIRE(legBPS_[0] != Null<Real>(), "result not available");
+        return legBPS_[0];
+    }
+
+    Real FixedVsFloatingSwap::floatingLegBPS() const {
+        calculate();
+        QL_REQUIRE(legBPS_[1] != Null<Real>(), "result not available");
+        return legBPS_[1];
+    }
+
+    Real FixedVsFloatingSwap::fixedLegNPV() const {
+        calculate();
+        QL_REQUIRE(legNPV_[0] != Null<Real>(), "result not available");
+        return legNPV_[0];
+    }
+
+    Real FixedVsFloatingSwap::floatingLegNPV() const {
+        calculate();
+        QL_REQUIRE(legNPV_[1] != Null<Real>(), "result not available");
+        return legNPV_[1];
+    }
+
+    void FixedVsFloatingSwap::setupExpired() const {
+        Swap::setupExpired();
+        legBPS_[0] = legBPS_[1] = 0.0;
+        fairRate_ = Null<Rate>();
+        fairSpread_ = Null<Spread>();
+    }
+
+    void FixedVsFloatingSwap::fetchResults(const PricingEngine::results* r) const {
+        static const Spread basisPoint = 1.0e-4;
+
+        Swap::fetchResults(r);
+
+        const auto* results = dynamic_cast<const FixedVsFloatingSwap::results*>(r);
+        if (results != nullptr) { // might be a swap engine, so no error is thrown
+            fairRate_ = results->fairRate;
+            fairSpread_ = results->fairSpread;
+        } else {
+            fairRate_ = Null<Rate>();
+            fairSpread_ = Null<Spread>();
+        }
+
+        if (fairRate_ == Null<Rate>()) {
+            // calculate it from other results
+            if (legBPS_[0] != Null<Real>())
+                fairRate_ = fixedRate_ - NPV_/(legBPS_[0]/basisPoint);
+        }
+        if (fairSpread_ == Null<Spread>()) {
+            // ditto
+            if (legBPS_[1] != Null<Real>())
+                fairSpread_ = spread_ - NPV_/(legBPS_[1]/basisPoint);
+        }
+    }
+
+    void FixedVsFloatingSwap::arguments::validate() const {
+        Swap::arguments::validate();
+        QL_REQUIRE(fixedNominals.size() == fixedPayDates.size(),
+                   "number of fixed nominals different from "
+                   "number of fixed payment dates");
+        QL_REQUIRE(fixedResetDates.size() == fixedPayDates.size(),
+                   "number of fixed start dates different from "
+                   "number of fixed payment dates");
+        QL_REQUIRE(fixedPayDates.size() == fixedCoupons.size(),
+                   "number of fixed payment dates different from "
+                   "number of fixed coupon amounts");
+        QL_REQUIRE(floatingNominals.size() == floatingPayDates.size(),
+                   "number of floating nominals different from "
+                   "number of floating payment dates");
+        QL_REQUIRE(floatingResetDates.size() == floatingPayDates.size(),
+                   "number of floating start dates different from "
+                   "number of floating payment dates");
+        QL_REQUIRE(floatingFixingDates.size() == floatingPayDates.size(),
+                   "number of floating fixing dates different from "
+                   "number of floating payment dates");
+        QL_REQUIRE(floatingAccrualTimes.size() == floatingPayDates.size(),
+                   "number of floating accrual Times different from "
+                   "number of floating payment dates");
+        QL_REQUIRE(floatingSpreads.size() == floatingPayDates.size(),
+                   "number of floating spreads different from "
+                   "number of floating payment dates");
+        QL_REQUIRE(floatingPayDates.size() == floatingCoupons.size(),
+                   "number of floating payment dates different from "
+                   "number of floating coupon amounts");
+    }
+
+    void FixedVsFloatingSwap::results::reset() {
+        Swap::results::reset();
+        fairRate = Null<Rate>();
+        fairSpread = Null<Spread>();
+    }
+
+}
diff --git a/ql/instruments/fixedvsfloatingswap.hpp b/ql/instruments/fixedvsfloatingswap.hpp
new file mode 100644
index 00000000000..71187063c17
--- /dev/null
+++ b/ql/instruments/fixedvsfloatingswap.hpp
@@ -0,0 +1,231 @@
+/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*
+ Copyright (C) 2000, 2001, 2002, 2003 RiskMap srl
+ Copyright (C) 2003, 2004, 2005, 2006, 2007 StatPro Italia srl
+ Copyright (C) 2006, 2008 Ferdinando Ametrano
+
+ This file is part of QuantLib, a free-software/open-source library
+ for financial quantitative analysts and developers - http://quantlib.org/
+
+ QuantLib is free software: you can redistribute it and/or modify it
+ under the terms of the QuantLib license.  You should have received a
+ copy of the license along with this program; if not, please email
+ <quantlib-dev@lists.sf.net>. The license is also available online at
+ <http://quantlib.org/license.shtml>.
+
+ This program is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE.  See the license for more details.
+*/
+
+/*! \file fixedvsfloatingswap.hpp
+    \brief Fixed-rate vs floating-rate swap
+*/
+
+#ifndef quantlib_fixed_vs_floating_swap_hpp
+#define quantlib_fixed_vs_floating_swap_hpp
+
+#include <ql/instruments/swap.hpp>
+#include <ql/time/daycounter.hpp>
+#include <ql/time/schedule.hpp>
+#include <ql/optional.hpp>
+
+namespace QuantLib {
+
+    class IborIndex;
+
+    //! Fixed vs floating swap
+    /*! \ingroup instruments
+
+        If no payment convention is passed, the convention of the
+        floating-rate schedule is used.
+
+        \warning if <tt>Settings::includeReferenceDateCashFlows()</tt>
+                 is set to <tt>true</tt>, payments occurring at the
+                 settlement date of the swap might be included in the
+                 NPV and therefore affect the fair-rate and
+                 fair-spread calculation. This might not be what you
+                 want.
+    */
+    class FixedVsFloatingSwap : public Swap {
+      public:
+        class arguments;
+        class results;
+        class engine;
+        FixedVsFloatingSwap(Type type,
+                            std::vector<Real> fixedNominals,
+                            Schedule fixedSchedule,
+                            Rate fixedRate,
+                            DayCounter fixedDayCount,
+                            std::vector<Real> floatingNominals,
+                            Schedule floatingSchedule,
+                            ext::shared_ptr<IborIndex> iborIndex,
+                            Spread spread,
+                            DayCounter floatingDayCount,
+                            ext::optional<BusinessDayConvention> paymentConvention = ext::nullopt,
+                            Natural paymentLag = 0,
+                            const Calendar& paymentCalendar = Calendar());
+        //! \name Inspectors
+        //@{
+        Type type() const;
+
+        /*! This throws if the nominal is not constant across coupons. */
+        Real nominal() const;
+        /*! This throws if the nominals are not the same for the two legs. */
+        const std::vector<Real>& nominals() const;
+
+        const std::vector<Real>& fixedNominals() const;
+        const Schedule& fixedSchedule() const;
+        Rate fixedRate() const;
+        const DayCounter& fixedDayCount() const;
+
+        const std::vector<Real>& floatingNominals() const;
+        const Schedule& floatingSchedule() const;
+        const ext::shared_ptr<IborIndex>& iborIndex() const;
+        Spread spread() const;
+        const DayCounter& floatingDayCount() const;
+
+        BusinessDayConvention paymentConvention() const;
+
+        const Leg& fixedLeg() const;
+        const Leg& floatingLeg() const;
+        //@}
+
+        //! \name Results
+        //@{
+        Real fixedLegBPS() const;
+        Real fixedLegNPV() const;
+        Rate fairRate() const;
+
+        Real floatingLegBPS() const;
+        Real floatingLegNPV() const;
+        Spread fairSpread() const;
+        //@}
+        // other
+        void setupArguments(PricingEngine::arguments* args) const override;
+        void fetchResults(const PricingEngine::results*) const override;
+
+      private:
+        void setupExpired() const override;
+        virtual void setupFloatingArguments(arguments* args) const = 0;
+        Type type_;
+        std::vector<Real> fixedNominals_;
+        Schedule fixedSchedule_;
+        Rate fixedRate_;
+        DayCounter fixedDayCount_;
+        std::vector<Real> floatingNominals_;
+        Schedule floatingSchedule_;
+        ext::shared_ptr<IborIndex> iborIndex_;
+        Spread spread_;
+        DayCounter floatingDayCount_;
+        BusinessDayConvention paymentConvention_;
+        // results
+        mutable Rate fairRate_;
+        mutable Spread fairSpread_;
+
+        bool constantNominals_, sameNominals_;
+    };
+
+
+    //! %Arguments for simple swap calculation
+    class FixedVsFloatingSwap::arguments : public Swap::arguments {
+      public:
+        arguments() : nominal(Null<Real>()) {}
+        Type type = Receiver;
+        Real nominal;
+
+        std::vector<Real> fixedNominals;
+        std::vector<Date> fixedResetDates;
+        std::vector<Date> fixedPayDates;
+        std::vector<Real> floatingNominals;
+        std::vector<Time> floatingAccrualTimes;
+        std::vector<Date> floatingResetDates;
+        std::vector<Date> floatingFixingDates;
+        std::vector<Date> floatingPayDates;
+
+        std::vector<Real> fixedCoupons;
+        std::vector<Spread> floatingSpreads;
+        std::vector<Real> floatingCoupons;
+        void validate() const override;
+    };
+
+    //! %Results from simple swap calculation
+    class FixedVsFloatingSwap::results : public Swap::results {
+      public:
+        Rate fairRate;
+        Spread fairSpread;
+        void reset() override;
+    };
+
+    class FixedVsFloatingSwap::engine : public GenericEngine<FixedVsFloatingSwap::arguments,
+                                                             FixedVsFloatingSwap::results> {};
+
+
+    // inline definitions
+
+    inline Swap::Type FixedVsFloatingSwap::type() const {
+        return type_;
+    }
+
+    inline Real FixedVsFloatingSwap::nominal() const {
+        QL_REQUIRE(constantNominals_, "nominal is not constant");
+        return fixedNominals_[0];
+    }
+
+    inline const std::vector<Real>& FixedVsFloatingSwap::nominals() const {
+        QL_REQUIRE(sameNominals_, "different nominals on fixed and floating leg");
+        return fixedNominals_;
+    }
+
+    inline const std::vector<Real>& FixedVsFloatingSwap::fixedNominals() const {
+        return fixedNominals_;
+    }
+
+    inline const Schedule& FixedVsFloatingSwap::fixedSchedule() const {
+        return fixedSchedule_;
+    }
+
+    inline Rate FixedVsFloatingSwap::fixedRate() const {
+        return fixedRate_;
+    }
+
+    inline const DayCounter& FixedVsFloatingSwap::fixedDayCount() const {
+        return fixedDayCount_;
+    }
+
+    inline const std::vector<Real>& FixedVsFloatingSwap::floatingNominals() const {
+        return floatingNominals_;
+    }
+
+    inline const Schedule& FixedVsFloatingSwap::floatingSchedule() const {
+        return floatingSchedule_;
+    }
+
+    inline const ext::shared_ptr<IborIndex>& FixedVsFloatingSwap::iborIndex() const {
+        return iborIndex_;
+    }
+
+    inline Spread FixedVsFloatingSwap::spread() const {
+        return spread_;
+    }
+
+    inline const DayCounter& FixedVsFloatingSwap::floatingDayCount() const {
+        return floatingDayCount_;
+    }
+
+    inline BusinessDayConvention FixedVsFloatingSwap::paymentConvention() const {
+        return paymentConvention_;
+    }
+
+    inline const Leg& FixedVsFloatingSwap::fixedLeg() const {
+        return legs_[0];
+    }
+
+    inline const Leg& FixedVsFloatingSwap::floatingLeg() const {
+        return legs_[1];
+    }
+
+}
+
+#endif
diff --git a/ql/instruments/overnightindexedswap.cpp b/ql/instruments/overnightindexedswap.cpp
index 0481b11ebbb..27de3ac89c3 100644
--- a/ql/instruments/overnightindexedswap.cpp
+++ b/ql/instruments/overnightindexedswap.cpp
@@ -112,122 +112,58 @@ namespace QuantLib {
                                                Schedule fixedSchedule,
                                                Rate fixedRate,
                                                DayCounter fixedDC,
-                                               std::vector<Real> overnightNominals,
-                                               Schedule overnightSchedule,
-                                               ext::shared_ptr<OvernightIndex> overnightIndex,
+                                               const std::vector<Real>& overnightNominals,
+                                               const Schedule& overnightSchedule,
+                                               const ext::shared_ptr<OvernightIndex>& overnightIndex,
                                                Spread spread,
                                                Natural paymentLag,
                                                BusinessDayConvention paymentAdjustment,
                                                const Calendar& paymentCalendar,
                                                bool telescopicValueDates,
                                                RateAveraging::Type averagingMethod)
-    : Swap(2), type_(type), fixedNominals_(std::move(fixedNominals)),
-      fixedSchedule_(std::move(fixedSchedule)), fixedRate_(fixedRate), fixedDC_(std::move(fixedDC)),
-      overnightNominals_(std::move(overnightNominals)), overnightSchedule_(std::move(overnightSchedule)),
-      overnightIndex_(std::move(overnightIndex)), spread_(spread), averagingMethod_(averagingMethod) {
-        if (fixedDC_ == DayCounter())
-            fixedDC_ = overnightIndex_->dayCounter();
-        legs_[0] = FixedRateLeg(fixedSchedule_)
-                       .withNotionals(fixedNominals_)
-                       .withCouponRates(fixedRate_, fixedDC_)
-                       .withPaymentLag(paymentLag)
-                       .withPaymentAdjustment(paymentAdjustment)
-                       .withPaymentCalendar(paymentCalendar.empty() ? fixedSchedule_.calendar() :
-                                                                      paymentCalendar);
+    : FixedVsFloatingSwap(type, std::move(fixedNominals), std::move(fixedSchedule), fixedRate, std::move(fixedDC),
+                          overnightNominals, overnightSchedule, overnightIndex,
+                          spread, DayCounter(), ext::nullopt),
+      overnightIndex_(overnightIndex), averagingMethod_(averagingMethod) {
 
         legs_[1] =
-            OvernightLeg(overnightSchedule_, overnightIndex_)
-                .withNotionals(overnightNominals_)
-                .withSpreads(spread_)
+            OvernightLeg(overnightSchedule, overnightIndex_)
+                .withNotionals(overnightNominals)
+                .withSpreads(spread)
                 .withTelescopicValueDates(telescopicValueDates)
                 .withPaymentLag(paymentLag)
                 .withPaymentAdjustment(paymentAdjustment)
-                .withPaymentCalendar(paymentCalendar.empty() ? overnightSchedule_.calendar() :
-                                                               paymentCalendar)
+                .withPaymentCalendar(paymentCalendar.empty() ?
+                                     overnightSchedule.calendar() :
+                                     paymentCalendar)
                 .withAveragingMethod(averagingMethod_);
+    }
 
-        for (Size j = 0; j < 2; ++j) {
-            for (auto& i : legs_[j])
-                registerWith(i);
-        }
-
-        switch (type_) {
-            case Payer:
-                payer_[0] = -1.0;
-                payer_[1] = +1.0;
-                break;
-            case Receiver:
-                payer_[0] = +1.0;
-                payer_[1] = -1.0;
-                break;
-            default:
-                QL_FAIL("Unknown overnight-swap type");
-        }
-
-        // These bools tell us if we can support the old methods nominal() and nominals().
-        // There might be false negatives (i.e., if we pass constant vectors of different lengths
-        // as fixedNominals and floatingNominals) but we're going to assume that whoever uses the
-        // constructor with two vectors is mostly going to use the new methods instead.
-        sameNominals_ = std::equal(fixedNominals_.begin(), fixedNominals_.end(),
-                                   overnightNominals_.begin(), overnightNominals_.end());
-        if (!sameNominals_) {
-            constantNominals_ = false;
-        } else {
-            constantNominals_ = true;
-            Real front = fixedNominals_[0];
-            for (auto x : fixedNominals_) {
-                if (x != front) {
-                    constantNominals_ = false;
-                    break;
-                }
+    void OvernightIndexedSwap::setupFloatingArguments(arguments* args) const {
+        const Leg& floatingCoupons = floatingLeg();
+        Size n = floatingCoupons.size();
+
+        args->floatingResetDates = args->floatingPayDates = args->floatingFixingDates = std::vector<Date>(n);
+        args->floatingAccrualTimes = std::vector<Time>(n);
+        args->floatingSpreads = std::vector<Spread>(n);
+        args->floatingCoupons = args->floatingNominals = std::vector<Real>(n);
+
+        for (Size i=0; i<n; ++i) {
+            auto coupon = ext::dynamic_pointer_cast<OvernightIndexedCoupon>(floatingCoupons[i]);
+
+            args->floatingResetDates[i] = coupon->accrualStartDate();
+            args->floatingPayDates[i] = coupon->date();
+            args->floatingNominals[i] = coupon->nominal();
+
+            args->floatingFixingDates[i] = coupon->fixingDate();
+            args->floatingAccrualTimes[i] = coupon->accrualPeriod();
+            args->floatingSpreads[i] = coupon->spread();
+            try {
+                args->floatingCoupons[i] = coupon->amount();
+            } catch (Error&) {
+                args->floatingCoupons[i] = Null<Real>();
             }
         }
     }
 
-    Real OvernightIndexedSwap::fairRate() const {
-        static Spread basisPoint = 1.0e-4;
-        calculate();
-        return fixedRate_ - NPV_ / (fixedLegBPS() / basisPoint);
-    }
-
-    Spread OvernightIndexedSwap::fairSpread() const {
-        static Spread basisPoint = 1.0e-4;
-        calculate();
-        return spread_ - NPV_ / (overnightLegBPS() / basisPoint);
-    }
-
-    Real OvernightIndexedSwap::fixedLegBPS() const {
-        calculate();
-        QL_REQUIRE(legBPS_[0] != Null<Real>(), "result not available");
-        return legBPS_[0];
-    }
-
-    Real OvernightIndexedSwap::overnightLegBPS() const {
-        calculate();
-        QL_REQUIRE(legBPS_[1] != Null<Real>(), "result not available");
-        return legBPS_[1];
-    }
-
-    Real OvernightIndexedSwap::fixedLegNPV() const {
-        calculate();
-        QL_REQUIRE(legNPV_[0] != Null<Real>(), "result not available");
-        return legNPV_[0];
-    }
-
-    Real OvernightIndexedSwap::overnightLegNPV() const {
-        calculate();
-        QL_REQUIRE(legNPV_[1] != Null<Real>(), "result not available");
-        return legNPV_[1];
-    }
-
-    Real OvernightIndexedSwap::nominal() const {
-        QL_REQUIRE(constantNominals_, "varying nominals");
-        return fixedNominals_[0];
-    }
-
-    const std::vector<Real>& OvernightIndexedSwap::nominals() const {
-        QL_REQUIRE(sameNominals_, "different nominals on fixed and floating leg");
-        return fixedNominals_;
-    }
-
 }
diff --git a/ql/instruments/overnightindexedswap.hpp b/ql/instruments/overnightindexedswap.hpp
index 661e8602f57..4abc65a202d 100644
--- a/ql/instruments/overnightindexedswap.hpp
+++ b/ql/instruments/overnightindexedswap.hpp
@@ -28,7 +28,7 @@
 #define quantlib_overnight_indexed_swap_hpp
 
 #include <ql/cashflows/rateaveraging.hpp>
-#include <ql/instruments/swap.hpp>
+#include <ql/instruments/fixedvsfloatingswap.hpp>
 #include <ql/time/businessdayconvention.hpp>
 #include <ql/time/calendar.hpp>
 #include <ql/time/daycounter.hpp>
@@ -36,11 +36,10 @@
 
 namespace QuantLib {
 
-    class Schedule;
     class OvernightIndex;
 
     //! Overnight indexed swap: fix vs compounded overnight rate
-    class OvernightIndexedSwap : public Swap {
+    class OvernightIndexedSwap : public FixedVsFloatingSwap {
       public:
         OvernightIndexedSwap(Type type,
                              Real nominal,
@@ -87,9 +86,9 @@ namespace QuantLib {
                              Schedule fixedSchedule,
                              Rate fixedRate,
                              DayCounter fixedDC,
-                             std::vector<Real> overnightNominals,
-                             Schedule overnightSchedule,
-                             ext::shared_ptr<OvernightIndex> overnightIndex,
+                             const std::vector<Real>& overnightNominals,
+                             const Schedule& overnightSchedule,
+                             const ext::shared_ptr<OvernightIndex>& overnightIndex,
                              Spread spread = 0.0,
                              Natural paymentLag = 0,
                              BusinessDayConvention paymentAdjustment = Following,
@@ -99,59 +98,29 @@ namespace QuantLib {
 
         //! \name Inspectors
         //@{
-        Type type() const { return type_; }
-
-        /*! This throws if the nominal is not constant across coupons. */
-        Real nominal() const;
-        /*! This throws if the nominals are not the same for the two legs. */
-        const std::vector<Real>& nominals() const;
-
         Frequency paymentFrequency() const {
-            return std::max(fixedSchedule_.tenor().frequency(),
-                            overnightSchedule_.tenor().frequency());
+            return std::max(fixedSchedule().tenor().frequency(),
+                            floatingSchedule().tenor().frequency());
         }
 
-        const std::vector<Real>& fixedNominals() const { return fixedNominals_; }
-        const Schedule& fixedSchedule() const { return fixedSchedule_; }
-        Rate fixedRate() const { return fixedRate_; }
-        const DayCounter& fixedDayCount() const { return fixedDC_; }
-
-        const std::vector<Real>& overnightNominals() const { return overnightNominals_; }
-        const Schedule& overnightSchedule() const { return overnightSchedule_; }
+        const std::vector<Real>& overnightNominals() const { return floatingNominals(); }
+        const Schedule& overnightSchedule() const { return floatingSchedule(); }
         const ext::shared_ptr<OvernightIndex>& overnightIndex() const { return overnightIndex_; }
-        Spread spread() const { return spread_; }
-
-        const Leg& fixedLeg() const { return legs_[0]; }
-        const Leg& overnightLeg() const { return legs_[1]; }
+        const Leg& overnightLeg() const { return floatingLeg(); }
 
         RateAveraging::Type averagingMethod() const { return averagingMethod_; }
         //@}
 
         //! \name Results
         //@{
-        Real fixedLegBPS() const;
-        Real fixedLegNPV() const;
-        Real fairRate() const;
-
-        Real overnightLegBPS() const;
-        Real overnightLegNPV() const;
-        Spread fairSpread() const;
+        Real overnightLegBPS() const { return floatingLegBPS(); }
+        Real overnightLegNPV() const { return floatingLegNPV(); }
         //@}
       private:
-        Type type_;
+        void setupFloatingArguments(arguments* args) const override;
 
-        std::vector<Real> fixedNominals_;
-        Schedule fixedSchedule_;
-        Rate fixedRate_;
-        DayCounter fixedDC_;
-
-        std::vector<Real> overnightNominals_;
-        Schedule overnightSchedule_;
         ext::shared_ptr<OvernightIndex> overnightIndex_;
-        Spread spread_;
         RateAveraging::Type averagingMethod_;
-
-        bool constantNominals_, sameNominals_;
     };
 
 }
diff --git a/ql/instruments/vanillaswap.cpp b/ql/instruments/vanillaswap.cpp
index ff1489b8224..6bddb48b9f1 100644
--- a/ql/instruments/vanillaswap.cpp
+++ b/ql/instruments/vanillaswap.cpp
@@ -19,15 +19,10 @@
  FOR A PARTICULAR PURPOSE.  See the license for more details.
 */
 
-#include <ql/cashflows/cashflows.hpp>
-#include <ql/cashflows/cashflowvectors.hpp>
-#include <ql/cashflows/couponpricer.hpp>
-#include <ql/cashflows/fixedratecoupon.hpp>
 #include <ql/cashflows/iborcoupon.hpp>
 #include <ql/indexes/iborindex.hpp>
 #include <ql/instruments/vanillaswap.hpp>
 #include <ql/termstructures/yieldtermstructure.hpp>
-#include <ql/optional.hpp>
 #include <utility>
 
 namespace QuantLib {
@@ -38,203 +33,50 @@ namespace QuantLib {
                              Rate fixedRate,
                              DayCounter fixedDayCount,
                              Schedule floatSchedule,
-                             ext::shared_ptr<IborIndex> iborIndex,
+                             ext::shared_ptr<IborIndex> index,
                              Spread spread,
                              DayCounter floatingDayCount,
                              ext::optional<BusinessDayConvention> paymentConvention,
                              ext::optional<bool> useIndexedCoupons)
-    : Swap(2), type_(type), nominal_(nominal), fixedSchedule_(std::move(fixedSchedule)),
-      fixedRate_(fixedRate), fixedDayCount_(std::move(fixedDayCount)),
-      floatingSchedule_(std::move(floatSchedule)), iborIndex_(std::move(iborIndex)),
-      spread_(spread), floatingDayCount_(std::move(floatingDayCount)) {
-
-        if (paymentConvention) // NOLINT(readability-implicit-bool-conversion)
-            paymentConvention_ = *paymentConvention;
-        else
-            paymentConvention_ = floatingSchedule_.businessDayConvention();
-
-        legs_[0] = FixedRateLeg(fixedSchedule_)
-            .withNotionals(nominal_)
-            .withCouponRates(fixedRate_, fixedDayCount_)
-            .withPaymentAdjustment(paymentConvention_);
-
-        legs_[1] = IborLeg(floatingSchedule_, iborIndex_)
-            .withNotionals(nominal_)
-            .withPaymentDayCounter(floatingDayCount_)
-            .withPaymentAdjustment(paymentConvention_)
-            .withSpreads(spread_)
+    : FixedVsFloatingSwap(type, {nominal}, std::move(fixedSchedule), fixedRate, std::move(fixedDayCount),
+                          {nominal}, std::move(floatSchedule), std::move(index), spread, std::move(floatingDayCount),
+                          paymentConvention) {
+
+        legs_[1] = IborLeg(floatingSchedule(), iborIndex())
+            .withNotionals(this->floatingNominals())
+            .withPaymentDayCounter(this->floatingDayCount())
+            .withPaymentAdjustment(this->paymentConvention())
+            .withSpreads(this->spread())
             .withIndexedCoupons(useIndexedCoupons);
         for (Leg::const_iterator i = legs_[1].begin(); i < legs_[1].end(); ++i)
             registerWith(*i);
-
-        switch (type_) {
-          case Payer:
-            payer_[0] = -1.0;
-            payer_[1] = +1.0;
-            break;
-          case Receiver:
-            payer_[0] = +1.0;
-            payer_[1] = -1.0;
-            break;
-          default:
-            QL_FAIL("Unknown vanilla-swap type");
-        }
     }
 
-    void VanillaSwap::setupArguments(PricingEngine::arguments* args) const {
-
-        Swap::setupArguments(args);
-
-        auto* arguments = dynamic_cast<VanillaSwap::arguments*>(args);
-
-        if (arguments == nullptr) // it's a swap engine...
-            return;
-
-        arguments->type = type_;
-        arguments->nominal = nominal_;
-
-        const Leg& fixedCoupons = fixedLeg();
-
-        arguments->fixedResetDates = arguments->fixedPayDates =
-            std::vector<Date>(fixedCoupons.size());
-        arguments->fixedCoupons = std::vector<Real>(fixedCoupons.size());
-
-        for (Size i=0; i<fixedCoupons.size(); ++i) {
-            ext::shared_ptr<FixedRateCoupon> coupon =
-                ext::dynamic_pointer_cast<FixedRateCoupon>(fixedCoupons[i]);
-
-            arguments->fixedPayDates[i] = coupon->date();
-            arguments->fixedResetDates[i] = coupon->accrualStartDate();
-            arguments->fixedCoupons[i] = coupon->amount();
-        }
-
+    void VanillaSwap::setupFloatingArguments(arguments* args) const {
         const Leg& floatingCoupons = floatingLeg();
+        Size n = floatingCoupons.size();
+
+        args->floatingResetDates = args->floatingPayDates = args->floatingFixingDates = std::vector<Date>(n);
+        args->floatingAccrualTimes = std::vector<Time>(n);
+        args->floatingSpreads = std::vector<Spread>(n);
+        args->floatingCoupons = args->floatingNominals = std::vector<Real>(n);
 
-        arguments->floatingResetDates = arguments->floatingPayDates =
-            arguments->floatingFixingDates =
-            std::vector<Date>(floatingCoupons.size());
-        arguments->floatingAccrualTimes =
-            std::vector<Time>(floatingCoupons.size());
-        arguments->floatingSpreads =
-            std::vector<Spread>(floatingCoupons.size());
-        arguments->floatingCoupons = std::vector<Real>(floatingCoupons.size());
-        for (Size i=0; i<floatingCoupons.size(); ++i) {
-            ext::shared_ptr<IborCoupon> coupon =
-                ext::dynamic_pointer_cast<IborCoupon>(floatingCoupons[i]);
+        for (Size i=0; i<n; ++i) {
+            auto coupon = ext::dynamic_pointer_cast<IborCoupon>(floatingCoupons[i]);
 
-            arguments->floatingResetDates[i] = coupon->accrualStartDate();
-            arguments->floatingPayDates[i] = coupon->date();
+            args->floatingResetDates[i] = coupon->accrualStartDate();
+            args->floatingPayDates[i] = coupon->date();
+            args->floatingNominals[i] = coupon->nominal();
 
-            arguments->floatingFixingDates[i] = coupon->fixingDate();
-            arguments->floatingAccrualTimes[i] = coupon->accrualPeriod();
-            arguments->floatingSpreads[i] = coupon->spread();
+            args->floatingFixingDates[i] = coupon->fixingDate();
+            args->floatingAccrualTimes[i] = coupon->accrualPeriod();
+            args->floatingSpreads[i] = coupon->spread();
             try {
-                arguments->floatingCoupons[i] = coupon->amount();
+                args->floatingCoupons[i] = coupon->amount();
             } catch (Error&) {
-                arguments->floatingCoupons[i] = Null<Real>();
+                args->floatingCoupons[i] = Null<Real>();
             }
         }
     }
 
-    Rate VanillaSwap::fairRate() const {
-        calculate();
-        QL_REQUIRE(fairRate_ != Null<Rate>(), "result not available");
-        return fairRate_;
-    }
-
-    Spread VanillaSwap::fairSpread() const {
-        calculate();
-        QL_REQUIRE(fairSpread_ != Null<Spread>(), "result not available");
-        return fairSpread_;
-    }
-
-    Real VanillaSwap::fixedLegBPS() const {
-        calculate();
-        QL_REQUIRE(legBPS_[0] != Null<Real>(), "result not available");
-        return legBPS_[0];
-    }
-
-    Real VanillaSwap::floatingLegBPS() const {
-        calculate();
-        QL_REQUIRE(legBPS_[1] != Null<Real>(), "result not available");
-        return legBPS_[1];
-    }
-
-    Real VanillaSwap::fixedLegNPV() const {
-        calculate();
-        QL_REQUIRE(legNPV_[0] != Null<Real>(), "result not available");
-        return legNPV_[0];
-    }
-
-    Real VanillaSwap::floatingLegNPV() const {
-        calculate();
-        QL_REQUIRE(legNPV_[1] != Null<Real>(), "result not available");
-        return legNPV_[1];
-    }
-
-    void VanillaSwap::setupExpired() const {
-        Swap::setupExpired();
-        legBPS_[0] = legBPS_[1] = 0.0;
-        fairRate_ = Null<Rate>();
-        fairSpread_ = Null<Spread>();
-    }
-
-    void VanillaSwap::fetchResults(const PricingEngine::results* r) const {
-        static const Spread basisPoint = 1.0e-4;
-
-        Swap::fetchResults(r);
-
-        const auto* results = dynamic_cast<const VanillaSwap::results*>(r);
-        if (results != nullptr) { // might be a swap engine, so no error is thrown
-            fairRate_ = results->fairRate;
-            fairSpread_ = results->fairSpread;
-        } else {
-            fairRate_ = Null<Rate>();
-            fairSpread_ = Null<Spread>();
-        }
-
-        if (fairRate_ == Null<Rate>()) {
-            // calculate it from other results
-            if (legBPS_[0] != Null<Real>())
-                fairRate_ = fixedRate_ - NPV_/(legBPS_[0]/basisPoint);
-        }
-        if (fairSpread_ == Null<Spread>()) {
-            // ditto
-            if (legBPS_[1] != Null<Real>())
-                fairSpread_ = spread_ - NPV_/(legBPS_[1]/basisPoint);
-        }
-    }
-
-    void VanillaSwap::arguments::validate() const {
-        Swap::arguments::validate();
-        QL_REQUIRE(nominal != Null<Real>(), "nominal null or not set");
-        QL_REQUIRE(fixedResetDates.size() == fixedPayDates.size(),
-                   "number of fixed start dates different from "
-                   "number of fixed payment dates");
-        QL_REQUIRE(fixedPayDates.size() == fixedCoupons.size(),
-                   "number of fixed payment dates different from "
-                   "number of fixed coupon amounts");
-        QL_REQUIRE(floatingResetDates.size() == floatingPayDates.size(),
-                   "number of floating start dates different from "
-                   "number of floating payment dates");
-        QL_REQUIRE(floatingFixingDates.size() == floatingPayDates.size(),
-                   "number of floating fixing dates different from "
-                   "number of floating payment dates");
-        QL_REQUIRE(floatingAccrualTimes.size() == floatingPayDates.size(),
-                   "number of floating accrual Times different from "
-                   "number of floating payment dates");
-        QL_REQUIRE(floatingSpreads.size() == floatingPayDates.size(),
-                   "number of floating spreads different from "
-                   "number of floating payment dates");
-        QL_REQUIRE(floatingPayDates.size() == floatingCoupons.size(),
-                   "number of floating payment dates different from "
-                   "number of floating coupon amounts");
-    }
-
-    void VanillaSwap::results::reset() {
-        Swap::results::reset();
-        fairRate = Null<Rate>();
-        fairSpread = Null<Spread>();
-    }
-
 }
diff --git a/ql/instruments/vanillaswap.hpp b/ql/instruments/vanillaswap.hpp
index 3515da552a1..f841da2bfde 100644
--- a/ql/instruments/vanillaswap.hpp
+++ b/ql/instruments/vanillaswap.hpp
@@ -26,7 +26,7 @@
 #ifndef quantlib_vanilla_swap_hpp
 #define quantlib_vanilla_swap_hpp
 
-#include <ql/instruments/swap.hpp>
+#include <ql/instruments/fixedvsfloatingswap.hpp>
 #include <ql/time/daycounter.hpp>
 #include <ql/time/schedule.hpp>
 #include <ql/optional.hpp>
@@ -35,7 +35,7 @@ namespace QuantLib {
 
     class IborIndex;
 
-    //! Plain-vanilla swap: fix vs floating leg
+    //! Plain-vanilla swap: fix vs ibor leg
     /*! \ingroup instruments
 
         If no payment convention is passed, the convention of the
@@ -62,11 +62,8 @@ namespace QuantLib {
         - the correctness of the returned value is tested by checking
           it against a known good value.
     */
-    class VanillaSwap : public Swap {
+    class VanillaSwap : public FixedVsFloatingSwap {
       public:
-        class arguments;
-        class results;
-        class engine;
         VanillaSwap(Type type,
                     Real nominal,
                     Schedule fixedSchedule,
@@ -78,140 +75,11 @@ namespace QuantLib {
                     DayCounter floatingDayCount,
                     ext::optional<BusinessDayConvention> paymentConvention = ext::nullopt,
                     ext::optional<bool> useIndexedCoupons = ext::nullopt);
-        //! \name Inspectors
-        //@{
-        Type type() const;
-        Real nominal() const;
-
-        const Schedule& fixedSchedule() const;
-        Rate fixedRate() const;
-        const DayCounter& fixedDayCount() const;
-
-        const Schedule& floatingSchedule() const;
-        const ext::shared_ptr<IborIndex>& iborIndex() const;
-        Spread spread() const;
-        const DayCounter& floatingDayCount() const;
-
-        BusinessDayConvention paymentConvention() const;
-
-        const Leg& fixedLeg() const;
-        const Leg& floatingLeg() const;
-        //@}
-
-        //! \name Results
-        //@{
-        Real fixedLegBPS() const;
-        Real fixedLegNPV() const;
-        Rate fairRate() const;
-
-        Real floatingLegBPS() const;
-        Real floatingLegNPV() const;
-        Spread fairSpread() const;
-        //@}
-        // other
-        void setupArguments(PricingEngine::arguments* args) const override;
-        void fetchResults(const PricingEngine::results*) const override;
 
       private:
-        void setupExpired() const override;
-        Type type_;
-        Real nominal_;
-        Schedule fixedSchedule_;
-        Rate fixedRate_;
-        DayCounter fixedDayCount_;
-        Schedule floatingSchedule_;
-        ext::shared_ptr<IborIndex> iborIndex_;
-        Spread spread_;
-        DayCounter floatingDayCount_;
-        BusinessDayConvention paymentConvention_;
-        // results
-        mutable Rate fairRate_;
-        mutable Spread fairSpread_;
+        void setupFloatingArguments(arguments* args) const override;
     };
 
-
-    //! %Arguments for simple swap calculation
-    class VanillaSwap::arguments : public Swap::arguments {
-      public:
-        arguments() : nominal(Null<Real>()) {}
-        Type type = Receiver;
-        Real nominal;
-
-        std::vector<Date> fixedResetDates;
-        std::vector<Date> fixedPayDates;
-        std::vector<Time> floatingAccrualTimes;
-        std::vector<Date> floatingResetDates;
-        std::vector<Date> floatingFixingDates;
-        std::vector<Date> floatingPayDates;
-
-        std::vector<Real> fixedCoupons;
-        std::vector<Spread> floatingSpreads;
-        std::vector<Real> floatingCoupons;
-        void validate() const override;
-    };
-
-    //! %Results from simple swap calculation
-    class VanillaSwap::results : public Swap::results {
-      public:
-        Rate fairRate;
-        Spread fairSpread;
-        void reset() override;
-    };
-
-    class VanillaSwap::engine : public GenericEngine<VanillaSwap::arguments,
-                                                     VanillaSwap::results> {};
-
-
-    // inline definitions
-
-    inline Swap::Type VanillaSwap::type() const {
-        return type_;
-    }
-
-    inline Real VanillaSwap::nominal() const {
-        return nominal_;
-    }
-
-    inline const Schedule& VanillaSwap::fixedSchedule() const {
-        return fixedSchedule_;
-    }
-
-    inline Rate VanillaSwap::fixedRate() const {
-        return fixedRate_;
-    }
-
-    inline const DayCounter& VanillaSwap::fixedDayCount() const {
-        return fixedDayCount_;
-    }
-
-    inline const Schedule& VanillaSwap::floatingSchedule() const {
-        return floatingSchedule_;
-    }
-
-    inline const ext::shared_ptr<IborIndex>& VanillaSwap::iborIndex() const {
-        return iborIndex_;
-    }
-
-    inline Spread VanillaSwap::spread() const {
-        return spread_;
-    }
-
-    inline const DayCounter& VanillaSwap::floatingDayCount() const {
-        return floatingDayCount_;
-    }
-
-    inline BusinessDayConvention VanillaSwap::paymentConvention() const {
-        return paymentConvention_;
-    }
-
-    inline const Leg& VanillaSwap::fixedLeg() const {
-        return legs_[0];
-    }
-
-    inline const Leg& VanillaSwap::floatingLeg() const {
-        return legs_[1];
-    }
-
 }
 
 #endif
diff --git a/ql/models/shortrate/twofactormodels/g2.cpp b/ql/models/shortrate/twofactormodels/g2.cpp
index 9ad62c7ad95..95ea872f869 100644
--- a/ql/models/shortrate/twofactormodels/g2.cpp
+++ b/ql/models/shortrate/twofactormodels/g2.cpp
@@ -218,6 +218,9 @@ namespace QuantLib {
     Real G2::swaption(const Swaption::arguments& arguments,
                       Rate fixedRate, Real range, Size intervals) const {
 
+        QL_REQUIRE(arguments.nominal != Null<Real>(),
+                   "non-constant nominals are not supported yet");
+
         Date settlement = termStructure()->referenceDate();
         DayCounter dayCounter = termStructure()->dayCounter();
         Time start = dayCounter.yearFraction(settlement,
@@ -238,7 +241,7 @@ namespace QuantLib {
         Real upper = function.mux() + range*function.sigmax();
         Real lower = function.mux() - range*function.sigmax();
         SegmentIntegral integrator(intervals);
-        return arguments.nominal*w*termStructure()->discount(start)*
+        return arguments.nominal * w * termStructure()->discount(start) *
             integrator(function, lower, upper);
     }
 
diff --git a/ql/pricingengines/swap/cvaswapengine.cpp b/ql/pricingengines/swap/cvaswapengine.cpp
index cdff7ea1fab..cbc9ab34156 100644
--- a/ql/pricingengines/swap/cvaswapengine.cpp
+++ b/ql/pricingengines/swap/cvaswapengine.cpp
@@ -115,6 +115,9 @@ namespace QuantLib {
     QL_REQUIRE(!swaptionletEngine_.empty(),
                  "no swap option engine set");
 
+    QL_REQUIRE(arguments_.nominal != Null<Real>(),
+               "non-constant nominals are not supported yet");
+
     Date priceDate = defaultTS_->referenceDate();
 
     Real cumOptVal = 0., 
diff --git a/ql/pricingengines/swap/discretizedswap.cpp b/ql/pricingengines/swap/discretizedswap.cpp
index a525009d41e..b1b51877876 100644
--- a/ql/pricingengines/swap/discretizedswap.cpp
+++ b/ql/pricingengines/swap/discretizedswap.cpp
@@ -201,6 +201,9 @@ namespace QuantLib {
         bond.initialize(method(), floatingPayTimes_[i]);
         bond.rollback(time_);
 
+        QL_REQUIRE(arguments_.nominal != Null<Real>(),
+                   "non-constant nominals are not supported yet");
+
         Real nominal = arguments_.nominal;
         Time T = arguments_.floatingAccrualTimes[i];
         Spread spread = arguments_.floatingSpreads[i];
diff --git a/ql/pricingengines/swaption/gaussian1djamshidianswaptionengine.cpp b/ql/pricingengines/swaption/gaussian1djamshidianswaptionengine.cpp
index 14ab984b741..9d648898c61 100644
--- a/ql/pricingengines/swaption/gaussian1djamshidianswaptionengine.cpp
+++ b/ql/pricingengines/swaption/gaussian1djamshidianswaptionengine.cpp
@@ -71,6 +71,9 @@ namespace QuantLib {
                    "non zero spread (" << arguments_.swap->spread()
                                        << ") not allowed"); // PC
 
+        QL_REQUIRE(arguments_.nominal != Null<Real>(),
+                   "non-constant nominals are not supported yet");
+
         Date referenceDate;
         DayCounter dayCounter;
 
diff --git a/ql/pricingengines/swaption/gaussian1dswaptionengine.cpp b/ql/pricingengines/swaption/gaussian1dswaptionengine.cpp
index 326c195e12b..a7790294fbe 100644
--- a/ql/pricingengines/swaption/gaussian1dswaptionengine.cpp
+++ b/ql/pricingengines/swaption/gaussian1dswaptionengine.cpp
@@ -29,6 +29,9 @@ namespace QuantLib {
                    "cash settled (ParYieldCurve) swaptions not priced with "
                    "Gaussian1dSwaptionEngine");
 
+        QL_REQUIRE(arguments_.nominal != Null<Real>(),
+                   "non-constant nominals are not supported yet");
+
         Date settlement = model_->termStructure()->referenceDate();
 
         if (arguments_.exercise->dates().back() <=
diff --git a/ql/pricingengines/swaption/jamshidianswaptionengine.cpp b/ql/pricingengines/swaption/jamshidianswaptionengine.cpp
index 493a560ba8c..9a15e3a16df 100644
--- a/ql/pricingengines/swaption/jamshidianswaptionengine.cpp
+++ b/ql/pricingengines/swaption/jamshidianswaptionengine.cpp
@@ -66,6 +66,9 @@ namespace QuantLib {
 
         QL_REQUIRE(arguments_.swap->spread() == 0.0, "non zero spread (" << arguments_.swap->spread() << ") not allowed");
 
+        QL_REQUIRE(arguments_.nominal != Null<Real>(),
+                   "non-constant nominals are not supported yet");
+
         QL_REQUIRE(!model_.empty(), "no model specified");
 
         Date referenceDate;
diff --git a/ql/termstructures/volatility/optionlet/capletvariancecurve.hpp b/ql/termstructures/volatility/optionlet/capletvariancecurve.hpp
index 8414f852ea6..8ca06945d1b 100644
--- a/ql/termstructures/volatility/optionlet/capletvariancecurve.hpp
+++ b/ql/termstructures/volatility/optionlet/capletvariancecurve.hpp
@@ -87,10 +87,7 @@ namespace QuantLib {
     CapletVarianceCurve::smileSectionImpl(Time t) const {
         // dummy strike
         Volatility atmVol = blackCurve_.blackVol(t, 0.05, true);
-        return ext::shared_ptr<SmileSection>(new
-            FlatSmileSection(t,
-                             atmVol,
-                             dayCounter()));
+        return ext::make_shared<FlatSmileSection>(t, atmVol, dayCounter());
     }
 
     inline
diff --git a/test-suite/libormarketmodel.cpp b/test-suite/libormarketmodel.cpp
index 7bf6860c50e..61737a99bac 100644
--- a/test-suite/libormarketmodel.cpp
+++ b/test-suite/libormarketmodel.cpp
@@ -221,13 +221,12 @@ void LiborMarketModelTest::testCapletPricing() {
     ext::shared_ptr<AnalyticCapFloorEngine> engine1(
                             new AnalyticCapFloorEngine(model, termStructure));
 
-    ext::shared_ptr<Cap> cap1(
-        new Cap(process->cashFlows(),
-                std::vector<Rate>(size, 0.04)));
-    cap1->setPricingEngine(engine1);
+    auto cap1 = Cap(process->cashFlows(),
+                    std::vector<Rate>(size, 0.04));
+    cap1.setPricingEngine(engine1);
 
     const Real expected = 0.015853935178;
-    const Real calculated = cap1->NPV();
+    const Real calculated = cap1.NPV();
 
     if (std::fabs(expected - calculated) > tolerance)
         BOOST_ERROR("Failed to reproduce npv"
@@ -289,10 +288,10 @@ void LiborMarketModelTest::testCalibration() {
         Handle<Quote> capVol(
             ext::shared_ptr<Quote>(new SimpleQuote(capVols[i-2])));
 
-        ext::shared_ptr<BlackCalibrationHelper> caphelper(
-            new CapHelper(maturity, capVol, index, Annual,
-                          index->dayCounter(), true, termStructure,
-                          BlackCalibrationHelper::ImpliedVolError));
+        auto caphelper =
+            ext::make_shared<CapHelper>(maturity, capVol, index, Annual,
+                                        index->dayCounter(), true, termStructure,
+                                        BlackCalibrationHelper::ImpliedVolError);
 
         caphelper->setPricingEngine(ext::shared_ptr<PricingEngine>(
                            new AnalyticCapFloorEngine(model, termStructure)));
@@ -307,12 +306,12 @@ void LiborMarketModelTest::testCalibration() {
                     ext::shared_ptr<Quote>(
                         new SimpleQuote(swaptionVols[swapVolIndex++])));
 
-                ext::shared_ptr<BlackCalibrationHelper> swaptionHelper(
-                    new SwaptionHelper(maturity, len, swaptionVol, index,
-                                       index->tenor(), dayCounter,
-                                       index->dayCounter(),
-                                       termStructure,
-                                       BlackCalibrationHelper::ImpliedVolError));
+                auto swaptionHelper =
+                    ext::make_shared<SwaptionHelper>(maturity, len, swaptionVol, index,
+                                                     index->tenor(), dayCounter,
+                                                     index->dayCounter(),
+                                                     termStructure,
+                                                     BlackCalibrationHelper::ImpliedVolError);
 
                 swaptionHelper->setPricingEngine(
                      ext::shared_ptr<PricingEngine>(
@@ -440,8 +439,7 @@ void LiborMarketModelTest::testSwaptionPricing() {
                 ext::shared_ptr<Exercise> exercise(
                     new EuropeanExercise(process->fixingDates()[i]));
 
-                ext::shared_ptr<Swaption> swaption(
-                    new Swaption(forwardSwap, exercise));
+                auto swaption = ext::make_shared<Swaption>(forwardSwap, exercise);
                 swaption->setPricingEngine(engine);
 
                 GeneralStatistics stat;
diff --git a/test-suite/overnightindexedswap.cpp b/test-suite/overnightindexedswap.cpp
index 787e27593d0..2bb43456922 100644
--- a/test-suite/overnightindexedswap.cpp
+++ b/test-suite/overnightindexedswap.cpp
@@ -570,7 +570,7 @@ void OvernightIndexedSwapTest::testConstructorsAndNominals() {
     BOOST_CHECK_EQUAL(ois_2.paymentFrequency(), Annual);
 
     BOOST_CHECK_EXCEPTION(ois_2.nominal(), Error,
-                          ExpectedErrorMessage("varying nominal"));
+                          ExpectedErrorMessage("nominal is not constant"));
 
     BOOST_CHECK_EQUAL(ois_2.nominals().size(), Size(2));
     BOOST_CHECK_EQUAL(ois_2.nominals()[0], nominal);
@@ -632,7 +632,7 @@ void OvernightIndexedSwapTest::testConstructorsAndNominals() {
     BOOST_CHECK_EQUAL(ois_4.paymentFrequency(), Semiannual);
 
     BOOST_CHECK_EXCEPTION(ois_4.nominal(), Error,
-                          ExpectedErrorMessage("varying nominals"));
+                          ExpectedErrorMessage("nominal is not constant"));
 
     BOOST_CHECK_EXCEPTION(ois_4.nominals(), Error,
                           ExpectedErrorMessage("different nominals"));