diff --git a/.cargo_vcs_info.json b/.cargo_vcs_info.json
index 9ef75e5..aa1c5bb 100644
--- a/.cargo_vcs_info.json
+++ b/.cargo_vcs_info.json
@@ -1,5 +1,5 @@
 {
   "git": {
-    "sha1": "4e53e072808815ed6b847c77193c568ee076c29d"
+    "sha1": "0a4fdff3b012ed4d4b603800bf971239e5a966ba"
   }
 }
diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
new file mode 100644
index 0000000..6baaaea
--- /dev/null
+++ b/.github/workflows/main.yml
@@ -0,0 +1,83 @@
+name: CI
+
+on:
+  push:
+    branches: [auto]
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  linux-ci:
+    name: Linux
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        toolchain: ["stable", "beta", "nightly", "1.36.0"]
+        include:
+          - toolchain: stable
+            env:
+              DO_FUZZ: 1
+          - toolchain: beta
+            env:
+              DO_FUZZ: 1
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install packages
+        run: sudo apt-get install -y binutils-dev libunwind8-dev libcurl4-openssl-dev libelf-dev libdw-dev cmake gcc libiberty-dev
+
+      - name: Install toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: ${{ matrix.toolchain }}
+          override: true
+
+      - name: Cargo build
+        run: cargo build --verbose
+
+      - name: Cargo test
+        run: cargo test --verbose
+
+      - name: Cargo test w/ serde
+        run: cargo test --verbose --features serde
+
+      - name: Cargo check w/o default features
+        if: matrix.toolchain == 'nightly'
+        run: cargo check --verbose --no-default-features
+
+      - name: Cargo test w/ union
+        if: matrix.toolchain == 'beta'
+        run: cargo test --verbose --features union
+
+      - name: Cargo test all features
+        if: matrix.toolchain == 'nightly'
+        run: cargo test --verbose --all-features
+
+      - name: Cargo bench
+        if: matrix.toolchain == 'nightly'
+        run: cargo bench --verbose bench
+
+      - name: miri
+        if: matrix.toolchain == 'nightly'
+        run: bash ./scripts/run_miri.sh
+
+      - name: fuzz
+        if: env.DO_FUZZ == '1'
+        working-directory: fuzz
+        run: ./travis_fuzz.sh
+
+  build_result:
+    name: homu build finished
+    runs-on: ubuntu-latest
+    needs:
+      - "linux-ci"
+
+    steps:
+      - name: Mark the job as successful
+        run: exit 0
+        if: success()
+      - name: Mark the job as unsuccessful
+        run: exit 1
+        if: "!success()"
+
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index 32fba28..0000000
--- a/.travis.yml
+++ /dev/null
@@ -1,37 +0,0 @@
-language: rust
-addons:
-  apt:
-    update: true
-    packages:
-      - binutils-dev
-      - libunwind8-dev
-      - libcurl4-openssl-dev
-      - libelf-dev
-      - libdw-dev
-      - cmake
-      - gcc
-      - libiberty-dev
-matrix:
-  include:
-    - rust: 1.36.0
-    - rust: nightly
-    - rust: beta
-      env: DO_FUZZ=true
-    - rust: stable
-      env: DO_FUZZ=true
-script: |
-  cargo build --verbose &&
-  cargo test --verbose &&
-  cargo test --verbose --features serde &&
-  ([ $TRAVIS_RUST_VERSION != nightly ] || cargo check --verbose --no-default-features) &&
-  ([ $TRAVIS_RUST_VERSION != beta ] || cargo test --verbose --features union) &&
-  ([ $TRAVIS_RUST_VERSION != nightly ] || cargo test --verbose --all-features) &&
-  ([ $TRAVIS_RUST_VERSION != nightly ] || cargo bench --verbose bench) &&
-  ([ $TRAVIS_RUST_VERSION != nightly ] || bash ./scripts/run_miri.sh) &&
-  if [ "$DO_FUZZ" = true ]
-  then
-  (
-    cd fuzz
-    ./travis-fuzz.sh
-  )
-  fi
diff --git a/Android.bp b/Android.bp
index f7fbc23..b82f929 100644
--- a/Android.bp
+++ b/Android.bp
@@ -42,7 +42,7 @@
     host_supported: true,
     crate_name: "smallvec",
     cargo_env_compat: true,
-    cargo_pkg_version: "1.6.1",
+    cargo_pkg_version: "1.8.0",
     srcs: ["src/lib.rs"],
     edition: "2018",
     apex_available: [
diff --git a/Cargo.toml b/Cargo.toml
index 1759894..7ff65de 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -3,17 +3,16 @@
 # When uploading crates to the registry Cargo will automatically
 # "normalize" Cargo.toml files for maximal compatibility
 # with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies
+# to registry (e.g., crates.io) dependencies.
 #
-# If you believe there's an error in this file please file an
-# issue against the rust-lang/cargo repository. If you're
-# editing this file be aware that the upstream Cargo.toml
-# will likely look very different (and much more reasonable)
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
 
 [package]
 edition = "2018"
 name = "smallvec"
-version = "1.6.1"
+version = "1.8.0"
 authors = ["The Servo Project Developers"]
 description = "'Small vector' optimization: store up to a small number of items on the stack"
 documentation = "https://docs.rs/smallvec/"
@@ -22,6 +21,13 @@
 categories = ["data-structures"]
 license = "MIT/Apache-2.0"
 repository = "https://github.com/servo/rust-smallvec"
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = ["--cfg", "docsrs"]
+[dependencies.arbitrary]
+version = "1"
+optional = true
+
 [dependencies.serde]
 version = "1"
 optional = true
@@ -31,6 +37,7 @@
 
 [features]
 const_generics = []
+const_new = ["const_generics"]
 may_dangle = []
 specialization = []
 union = []
diff --git a/Cargo.toml.orig b/Cargo.toml.orig
index b19b93e..605fdb3 100644
--- a/Cargo.toml.orig
+++ b/Cargo.toml.orig
@@ -1,6 +1,6 @@
 [package]
 name = "smallvec"
-version = "1.6.1"
+version = "1.8.0"
 edition = "2018"
 authors = ["The Servo Project Developers"]
 license = "MIT/Apache-2.0"
@@ -13,6 +13,7 @@
 
 [features]
 const_generics = []
+const_new = ["const_generics"]
 write = []
 union = []
 specialization = []
@@ -20,6 +21,11 @@
 
 [dependencies]
 serde = { version = "1", optional = true, default-features = false }
+arbitrary = { version = "1", optional = true }
 
 [dev_dependencies]
 bincode = "1.0.1"
+
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = ["--cfg", "docsrs"]
diff --git a/METADATA b/METADATA
index 3ff6a4b..e726d44 100644
--- a/METADATA
+++ b/METADATA
@@ -7,13 +7,13 @@
   }
   url {
     type: ARCHIVE
-    value: "https://static.crates.io/crates/smallvec/smallvec-1.6.1.crate"
+    value: "https://static.crates.io/crates/smallvec/smallvec-1.8.0.crate"
   }
-  version: "1.6.1"
+  version: "1.8.0"
   license_type: NOTICE
   last_upgrade_date {
-    year: 2021
-    month: 1
-    day: 8
+    year: 2022
+    month: 3
+    day: 1
   }
 }
diff --git a/TEST_MAPPING b/TEST_MAPPING
index 713deb2..b91be4d 100644
--- a/TEST_MAPPING
+++ b/TEST_MAPPING
@@ -5,6 +5,9 @@
       "path": "external/rust/crates/parking_lot_core"
     },
     {
+      "path": "external/rust/crates/tinyvec"
+    },
+    {
       "path": "external/rust/crates/vulkano"
     }
   ],
diff --git a/benches/bench.rs b/benches/bench.rs
index 7a3c07e..ad73226 100644
--- a/benches/bench.rs
+++ b/benches/bench.rs
@@ -159,12 +159,11 @@
 
     b.iter(|| {
         let mut vec = V::new();
-        // Add one element, with each iteration we insert one before the end.
-        // This means that we benchmark the insertion operation and not the
-        // time it takes to `ptr::copy` the data.
+        // Always insert at position 0 so that we are subject to shifts of
+        // many different lengths.
         vec.push(0);
         for x in 0..n {
-            insert_noinline(&mut vec, x as _, x);
+            insert_noinline(&mut vec, 0, x);
         }
         vec
     });
@@ -179,8 +178,8 @@
     b.iter(|| {
         let mut vec = V::from_elem(0, n as _);
 
-        for x in (0..n - 1).rev() {
-            remove_noinline(&mut vec, x);
+        for _ in 0..n {
+            remove_noinline(&mut vec, 0);
         }
     });
 }
diff --git a/src/arbitrary.rs b/src/arbitrary.rs
new file mode 100644
index 0000000..cbdfcb0
--- /dev/null
+++ b/src/arbitrary.rs
@@ -0,0 +1,19 @@
+use crate::{Array, SmallVec};
+use arbitrary::{Arbitrary, Unstructured};
+
+impl<'a, A: Array> Arbitrary<'a> for SmallVec<A>
+where
+    <A as Array>::Item: Arbitrary<'a>,
+{
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        u.arbitrary_iter()?.collect()
+    }
+
+    fn arbitrary_take_rest(u: Unstructured<'a>) -> arbitrary::Result<Self> {
+        u.arbitrary_take_rest_iter()?.collect()
+    }
+
+    fn size_hint(depth: usize) -> (usize, Option<usize>) {
+        arbitrary::size_hint::and(<usize as Arbitrary>::size_hint(depth), (0, None))
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
index 5e9de82..1699a71 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -43,12 +43,18 @@
 //!
 //! ### `const_generics`
 //!
-//! **This feature is unstable and requires a nightly build of the Rust toolchain.**
+//! **This feature requires Rust 1.51.**
 //!
 //! When this feature is enabled, `SmallVec` works with any arrays of any size, not just a fixed
 //! list of sizes.
 //!
-//! Tracking issue: [rust-lang/rust#44580](https://github.com/rust-lang/rust/issues/44580)
+//! ### `const_new`
+//!
+//! **This feature requires Rust 1.51.**
+//!
+//! This feature exposes the functions [`SmallVec::new_const`], [`SmallVec::from_const`], and [`smallvec_inline`] which enables the `SmallVec` to be initialized from a const context.
+//! For details, see the
+//! [Rust Reference](https://doc.rust-lang.org/reference/const_eval.html#const-functions).
 //!
 //! ### `specialization`
 //!
@@ -71,6 +77,7 @@
 //! Tracking issue: [rust-lang/rust#34761](https://github.com/rust-lang/rust/issues/34761)
 
 #![no_std]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 #![cfg_attr(feature = "specialization", allow(incomplete_features))]
 #![cfg_attr(feature = "specialization", feature(specialization))]
 #![cfg_attr(feature = "may_dangle", feature(dropck_eyepatch))]
@@ -172,6 +179,52 @@
     });
 }
 
+/// Creates an inline [`SmallVec`] containing the arguments. This macro is enabled by the feature `const_new`.
+///
+/// `smallvec_inline!` allows `SmallVec`s to be defined with the same syntax as array expressions in `const` contexts.
+/// The inline storage `A` will always be an array of the size specified by the arguments.
+/// There are two forms of this macro:
+///
+/// - Create a [`SmallVec`] containing a given list of elements:
+///
+/// ```
+/// # #[macro_use] extern crate smallvec;
+/// # use smallvec::SmallVec;
+/// # fn main() {
+/// const V: SmallVec<[i32; 3]> = smallvec_inline![1, 2, 3];
+/// assert_eq!(V[0], 1);
+/// assert_eq!(V[1], 2);
+/// assert_eq!(V[2], 3);
+/// # }
+/// ```
+///
+/// - Create a [`SmallVec`] from a given element and size:
+///
+/// ```
+/// # #[macro_use] extern crate smallvec;
+/// # use smallvec::SmallVec;
+/// # fn main() {
+/// const V: SmallVec<[i32; 3]> = smallvec_inline![1; 3];
+/// assert_eq!(V, SmallVec::from_buf([1, 1, 1]));
+/// # }
+/// ```
+///
+/// Note that the behavior mimics that of array expressions, in contrast to [`smallvec`].
+#[cfg(feature = "const_new")]
+#[cfg_attr(docsrs, doc(cfg(feature = "const_new")))]
+#[macro_export]
+macro_rules! smallvec_inline {
+    // count helper: transform any expression into 1
+    (@one $x:expr) => (1usize);
+    ($elem:expr; $n:expr) => ({
+        $crate::SmallVec::<[_; $n]>::from_const([$elem; $n])
+    });
+    ($($x:expr),+ $(,)?) => ({
+        const N: usize = 0usize $(+ $crate::smallvec_inline!(@one $x))*;
+        $crate::SmallVec::<[_; N]>::from_const([$($x,)*])
+    });
+}
+
 /// `panic!()` in debug builds, optimization hint in release.
 #[cfg(not(feature = "union"))]
 macro_rules! debug_unreachable {
@@ -355,6 +408,17 @@
     heap: (*mut A::Item, usize),
 }
 
+#[cfg(all(feature = "union", feature = "const_new"))]
+impl<T, const N: usize> SmallVecData<[T; N]> {
+    #[cfg_attr(docsrs, doc(cfg(feature = "const_new")))]
+    #[inline]
+    const fn from_const(inline: MaybeUninit<[T; N]>) -> Self {
+        SmallVecData {
+            inline: core::mem::ManuallyDrop::new(inline),
+        }
+    }
+}
+
 #[cfg(feature = "union")]
 impl<A: Array> SmallVecData<A> {
     #[inline]
@@ -395,6 +459,15 @@
     Heap((*mut A::Item, usize)),
 }
 
+#[cfg(all(not(feature = "union"), feature = "const_new"))]
+impl<T, const N: usize> SmallVecData<[T; N]> {
+    #[cfg_attr(docsrs, doc(cfg(feature = "const_new")))]
+    #[inline]
+    const fn from_const(inline: MaybeUninit<[T; N]>) -> Self {
+        SmallVecData::Inline(inline)
+    }
+}
+
 #[cfg(not(feature = "union"))]
 impl<A: Array> SmallVecData<A> {
     #[inline]
@@ -483,7 +556,7 @@
     /// Construct an empty vector
     #[inline]
     pub fn new() -> SmallVec<A> {
-        // Try to detect invalid custom implementations of `Array`. Hopefuly,
+        // Try to detect invalid custom implementations of `Array`. Hopefully,
         // this check should be optimized away entirely for valid ones.
         assert!(
             mem::size_of::<A>() == A::size() * mem::size_of::<A::Item>()
@@ -725,11 +798,11 @@
         let len = self.len();
         let start = match range.start_bound() {
             Included(&n) => n,
-            Excluded(&n) => n + 1,
+            Excluded(&n) => n.checked_add(1).expect("Range start out of bounds"),
             Unbounded => 0,
         };
         let end = match range.end_bound() {
-            Included(&n) => n + 1,
+            Included(&n) => n.checked_add(1).expect("Range end out of bounds"),
             Excluded(&n) => n,
             Unbounded => len,
         };
@@ -1489,6 +1562,7 @@
 }
 
 #[cfg(feature = "write")]
+#[cfg_attr(docsrs, doc(cfg(feature = "write")))]
 impl<A: Array<Item = u8>> io::Write for SmallVec<A> {
     #[inline]
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
@@ -1509,6 +1583,7 @@
 }
 
 #[cfg(feature = "serde")]
+#[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
 impl<A: Array> Serialize for SmallVec<A>
 where
     A::Item: Serialize,
@@ -1523,6 +1598,7 @@
 }
 
 #[cfg(feature = "serde")]
+#[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
 impl<'de, A: Array> Deserialize<'de> for SmallVec<A>
 where
     A::Item: Deserialize<'de>,
@@ -1575,6 +1651,9 @@
 #[cfg(feature = "specialization")]
 mod specialization;
 
+#[cfg(feature = "arbitrary")]
+mod arbitrary;
+
 #[cfg(feature = "specialization")]
 impl<'a, A: Array> SpecFrom<A, &'a [A::Item]> for SmallVec<A>
 where
@@ -1727,6 +1806,21 @@
     fn clone(&self) -> SmallVec<A> {
         SmallVec::from(self.as_slice())
     }
+
+    fn clone_from(&mut self, source: &Self) {
+        // Inspired from `impl Clone for Vec`.
+
+        // drop anything that will not be overwritten
+        self.truncate(source.len());
+
+        // self.len <= other.len due to the truncate above, so the
+        // slices here are always in-bounds.
+        let (init, tail) = source.split_at(self.len());
+
+        // reuse the contained values' allocations/resources.
+        self.clone_from_slice(init);
+        self.extend(tail.iter().cloned());
+    }
 }
 
 impl<A: Array, B: Array> PartialEq<SmallVec<B>> for SmallVec<A>
@@ -1937,7 +2031,35 @@
     }
 }
 
-#[cfg(feature = "const_generics")]
+#[cfg(feature = "const_new")]
+impl<T, const N: usize> SmallVec<[T; N]> {
+    /// Construct an empty vector.
+    ///
+    /// This is a `const` version of [`SmallVec::new`] that is enabled by the feature `const_new`, with the limitation that it only works for arrays.
+    #[cfg_attr(docsrs, doc(cfg(feature = "const_new")))]
+    #[inline]
+    pub const fn new_const() -> Self {
+        SmallVec {
+            capacity: 0,
+            data: SmallVecData::from_const(MaybeUninit::uninit()),
+        }
+    }
+
+    /// The array passed as an argument is moved to be an inline version of `SmallVec`.
+    ///
+    /// This is a `const` version of [`SmallVec::from_buf`] that is enabled by the feature `const_new`, with the limitation that it only works for arrays.
+    #[cfg_attr(docsrs, doc(cfg(feature = "const_new")))]
+    #[inline]
+    pub const fn from_const(items: [T; N]) -> Self {
+        SmallVec {
+            capacity: N,
+            data: SmallVecData::from_const(MaybeUninit::new(items)),
+        }
+    }
+}
+
+#[cfg(all(feature = "const_generics", not(doc)))]
+#[cfg_attr(docsrs, doc(cfg(feature = "const_generics")))]
 unsafe impl<T, const N: usize> Array for [T; N] {
     type Item = T;
     fn size() -> usize {
@@ -1945,7 +2067,7 @@
     }
 }
 
-#[cfg(not(feature = "const_generics"))]
+#[cfg(any(not(feature = "const_generics"), doc))]
 macro_rules! impl_array(
     ($($size:expr),+) => {
         $(
@@ -1957,7 +2079,7 @@
     }
 );
 
-#[cfg(not(feature = "const_generics"))]
+#[cfg(any(not(feature = "const_generics"), doc))]
 impl_array!(
     0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
     26, 27, 28, 29, 30, 31, 32, 36, 0x40, 0x60, 0x80, 0x100, 0x200, 0x400, 0x600, 0x800, 0x1000,
diff --git a/src/tests.rs b/src/tests.rs
index 19f6da8..7643fd7 100644
--- a/src/tests.rs
+++ b/src/tests.rs
@@ -111,6 +111,13 @@
     assert_eq!(v.drain(1..).collect::<Vec<_>>(), &[4, 5]);
     // drain should not change the capacity
     assert_eq!(v.capacity(), old_capacity);
+
+    // Exercise the tail-shifting code when in the inline state
+    // This has the potential to produce UB due to aliasing
+    let mut v: SmallVec<[u8; 2]> = SmallVec::new();
+    v.push(1);
+    v.push(2);
+    assert_eq!(v.drain(..1).collect::<Vec<_>>(), &[1]);
 }
 
 #[test]
@@ -424,6 +431,13 @@
 }
 
 #[test]
+#[should_panic]
+fn drain_overflow() {
+    let mut v: SmallVec<[u8; 8]> = smallvec![0];
+    v.drain(..=std::usize::MAX);
+}
+
+#[test]
 fn test_insert_from_slice() {
     let mut v: SmallVec<[u8; 8]> = SmallVec::new();
     for x in 0..4 {
@@ -896,6 +910,35 @@
     let _v = SmallVec::<[i32; 987]>::default();
 }
 
+#[cfg(feature = "const_new")]
+#[test]
+fn const_new() {
+    let v = const_new_inner();
+    assert_eq!(v.capacity(), 4);
+    assert_eq!(v.len(), 0);
+    let v = const_new_inline_sized();
+    assert_eq!(v.capacity(), 4);
+    assert_eq!(v.len(), 4);
+    assert_eq!(v[0], 1);
+    let v = const_new_inline_args();
+    assert_eq!(v.capacity(), 2);
+    assert_eq!(v.len(), 2);
+    assert_eq!(v[0], 1);
+    assert_eq!(v[1], 4);
+}
+#[cfg(feature = "const_new")]
+const fn const_new_inner() -> SmallVec<[i32; 4]> {
+    SmallVec::<[i32; 4]>::new_const()
+}
+#[cfg(feature = "const_new")]
+const fn const_new_inline_sized() -> SmallVec<[i32; 4]> {
+    crate::smallvec_inline![1; 4]
+}
+#[cfg(feature = "const_new")]
+const fn const_new_inline_args() -> SmallVec<[i32; 2]> {
+    crate::smallvec_inline![1, 4]
+}
+
 #[test]
 fn empty_macro() {
     let _v: SmallVec<[u8; 1]> = smallvec![];
@@ -918,3 +961,25 @@
     v.insert_many(0, iter);
     assert_eq!(&*v, &[0, 2, 4, 123]);
 }
+
+#[test]
+fn test_clone_from() {
+    let mut a: SmallVec<[u8; 2]> = SmallVec::new();
+    a.push(1);
+    a.push(2);
+    a.push(3);
+
+    let mut b: SmallVec<[u8; 2]> = SmallVec::new();
+    b.push(10);
+
+    let mut c: SmallVec<[u8; 2]> = SmallVec::new();
+    c.push(20);
+    c.push(21);
+    c.push(22);
+
+    a.clone_from(&b);
+    assert_eq!(&*a, &[10]);
+
+    b.clone_from(&c);
+    assert_eq!(&*b, &[20, 21, 22]);
+}