Bug 1653335 - Remove uses of MakeSpan in return statements. r=froydnj

Differential Revision: https://phabricator.services.mozilla.com/D83812

dom/base/AttrArray.h

@@ -178,13 +178,12 @@ class AttrArray {
       return sizeof(Impl) + aAttrCount * sizeof(InternalAttr);
     }
 
-    mozilla::Span<const InternalAttr> NonMappedAttrs() const {
-      return mozilla::MakeSpan(static_cast<const InternalAttr*>(mBuffer),
-                               mAttrCount);
+    auto NonMappedAttrs() const {
+      return mozilla::Span<const InternalAttr>{mBuffer, mAttrCount};
     }
 
-    mozilla::Span<InternalAttr> NonMappedAttrs() {
-      return mozilla::MakeSpan(static_cast<InternalAttr*>(mBuffer), mAttrCount);
+    auto NonMappedAttrs() {
+      return mozilla::Span<InternalAttr>{mBuffer, mAttrCount};
     }
 
     Impl(const Impl&) = delete;

dom/bindings/Codegen.py

@@ -10504,10 +10504,10 @@ class CGEnum(CGThing):
             static_assert(static_cast<size_t>(${name}::EndGuard_) == Count,
                           "Mismatch between enum value and enum count");
 
-            inline Span<const char> GetString(${name} stringId) {
+            inline auto GetString(${name} stringId) {
               MOZ_ASSERT(static_cast<${type}>(stringId) < Count);
               const EnumEntry& entry = ${entry_array}[static_cast<${type}>(stringId)];
-              return MakeSpan(entry.value, entry.length);
+              return Span<const char>{entry.value, entry.length};
             }
             """,
             entry_array=ENUM_ENTRY_VARIABLE_NAME,

dom/bindings/FakeString.h

@@ -79,11 +79,14 @@ struct FakeString {
 
   operator mozilla::Span<const char_type>() const {
     MOZ_ASSERT(mDataInitialized);
-    return mozilla::MakeSpan(mData, Length());
+    // Explicitly specify template argument here to avoid instantiating
+    // Span<char_type> first and then implicitly converting to Span<const
+    // char_type>
+    return mozilla::Span<const char_type>{mData, Length()};
   }
 
   operator mozilla::Span<char_type>() {
-    return mozilla::MakeSpan(BeginWriting(), Length());
+    return mozilla::Span{BeginWriting(), Length()};
   }
 
   mozilla::BulkWriteHandle<CharT> BulkWrite(size_type aCapacity,

dom/media/MediaData.cpp

@@ -55,7 +55,7 @@ AudioData::AudioData(int64_t aOffset, const media::TimeUnit& aTime,
       mFrames(mAudioData.Length() / aChannels) {}
 
 Span<AudioDataValue> AudioData::Data() const {
-  return MakeSpan(GetAdjustedData(), mFrames * mChannels);
+  return Span{GetAdjustedData(), mFrames * mChannels};
 }
 
 bool AudioData::AdjustForStartTime(const media::TimeUnit& aStartTime) {

dom/media/MediaData.h

@@ -627,7 +627,7 @@ class MediaRawData final : public MediaData {
            mAlphaBuffer.ComputedSizeOfExcludingThis();
   }
   // Access the buffer as a Span.
-  operator Span<const uint8_t>() { return MakeSpan(Data(), Size()); }
+  operator Span<const uint8_t>() { return Span{Data(), Size()}; }
 
   const CryptoSample& mCrypto;
   RefPtr<MediaByteBuffer> mExtraData;

gfx/2d/SFNTData.cpp

@@ -63,10 +63,10 @@ class SFNTData::Font {
         GetDirEntry(TRUETYPE_TAG('h', 'e', 'a', 'd'));
     if (!dirEntry) {
       gfxWarning() << "Head table entry not found.";
-      return nullptr;
+      return {};
     }
 
-    return MakeSpan(mFontData + dirEntry->offset, dirEntry->length);
+    return {mFontData + dirEntry->offset, dirEntry->length};
   }
 
  private:

gfx/thebes/gfxFontFeatures.cpp

@@ -23,7 +23,7 @@ Span<const uint32_t> gfxFontFeatureValueSet::GetFontFeatureValuesFor(
   }
   NS_ASSERTION(entry->mValues.Length() > 0,
                "null array of font feature values");
-  return MakeSpan(entry->mValues);
+  return {entry->mValues};
 }
 
 nsTArray<uint32_t>* gfxFontFeatureValueSet::AppendFeatureValueHashEntry(

js/src/frontend/TokenStream.h

@@ -1569,8 +1569,7 @@ class TokenStreamCharsShared {
   CharBuffer& getCharBuffer() { return charBuffer; }
 };
 
-inline mozilla::Span<const char> ToCharSpan(
-    mozilla::Span<const mozilla::Utf8Unit> codeUnits) {
+inline auto ToCharSpan(mozilla::Span<const mozilla::Utf8Unit> codeUnits) {
   static_assert(alignof(char) == alignof(mozilla::Utf8Unit),
                 "must have equal alignment to reinterpret_cast<>");
   static_assert(sizeof(char) == sizeof(mozilla::Utf8Unit),
@@ -1584,8 +1583,8 @@ inline mozilla::Span<const char> ToCharSpan(
   // Second, Utf8Unit *contains* a |char|.  Examining that memory as |char|
   // is simply, per C++11 [basic.lval]p10, to access the memory according to
   // the dynamic type of the object: essentially trivially safe.
-  return mozilla::MakeSpan(reinterpret_cast<const char*>(codeUnits.data()),
-                           codeUnits.size());
+  return mozilla::Span{reinterpret_cast<const char*>(codeUnits.data()),
+                       codeUnits.size()};
 }
 
 template <typename Unit>

js/src/jit/BaselineJIT.h

@@ -262,8 +262,7 @@ class alignas(uintptr_t) BaselineScript final : public TrailingArray {
 
   template <typename T>
   mozilla::Span<T> makeSpan(Offset start, Offset end) {
-    return mozilla::MakeSpan(offsetToPointer<T>(start),
-                             numElements<T>(start, end));
+    return mozilla::Span{offsetToPointer<T>(start), numElements<T>(start, end)};
   }
 
   // We store the native code address corresponding to each bytecode offset in

js/src/vm/JSScript.h

@@ -1378,7 +1378,7 @@ class alignas(uintptr_t) PrivateScriptData final : public TrailingArray {
   // Accessors for typed array spans.
   mozilla::Span<JS::GCCellPtr> gcthings() {
     Offset offset = offsetOfGCThings();
-    return mozilla::MakeSpan(offsetToPointer<JS::GCCellPtr>(offset), ngcthings);
+    return mozilla::Span{offsetToPointer<JS::GCCellPtr>(offset), ngcthings};
   }
 
   void setFieldInitializers(FieldInitializers fieldInitializers) {

js/src/vm/SharedStencil.h

@@ -347,7 +347,7 @@ class alignas(uint32_t) ImmutableScriptData final : public TrailingArray {
   // Span over all raw bytes in this struct and its trailing arrays.
   mozilla::Span<const uint8_t> immutableData() const {
     size_t allocSize = endOffset();
-    return mozilla::MakeSpan(reinterpret_cast<const uint8_t*>(this), allocSize);
+    return mozilla::Span{reinterpret_cast<const uint8_t*>(this), allocSize};
   }
 
  private:
@@ -368,16 +368,16 @@ class alignas(uint32_t) ImmutableScriptData final : public TrailingArray {
   mozilla::Span<SrcNote> notesSpan() { return {notes(), noteLength()}; }
 
   mozilla::Span<uint32_t> resumeOffsets() {
-    return mozilla::MakeSpan(offsetToPointer<uint32_t>(resumeOffsetsOffset()),
-                             offsetToPointer<uint32_t>(scopeNotesOffset()));
+    return mozilla::Span{offsetToPointer<uint32_t>(resumeOffsetsOffset()),
+                         offsetToPointer<uint32_t>(scopeNotesOffset())};
   }
   mozilla::Span<ScopeNote> scopeNotes() {
-    return mozilla::MakeSpan(offsetToPointer<ScopeNote>(scopeNotesOffset()),
-                             offsetToPointer<ScopeNote>(tryNotesOffset()));
+    return mozilla::Span{offsetToPointer<ScopeNote>(scopeNotesOffset()),
+                         offsetToPointer<ScopeNote>(tryNotesOffset())};
   }
   mozilla::Span<TryNote> tryNotes() {
-    return mozilla::MakeSpan(offsetToPointer<TryNote>(tryNotesOffset()),
-                             offsetToPointer<TryNote>(endOffset()));
+    return mozilla::Span{offsetToPointer<TryNote>(tryNotesOffset()),
+                         offsetToPointer<TryNote>(endOffset())};
   }
 
   // Expose offsets to the JITs.

layout/style/CounterStyleManager.h

@@ -122,7 +122,7 @@ class AnonymousCounterStyle final : public CounterStyle {
   virtual AnonymousCounterStyle* AsAnonymous() override { return this; }
 
   bool IsSingleString() const { return mSingleString; }
-  Span<const nsString> GetSymbols() const { return MakeSpan(mSymbols); }
+  auto GetSymbols() const { return Span<const nsString>{mSymbols}; }
 
   StyleCounterSystem GetSystem() const;
 

layout/style/ServoStyleConstsInlines.h

@@ -217,7 +217,9 @@ inline bool StyleArcSlice<T>::IsEmpty() const {
 template <typename T>
 inline Span<const T> StyleArcSlice<T>::AsSpan() const {
   ASSERT_CANARY
-  return MakeSpan(_0.ptr->data.slice, Length());
+  // Explicitly specify template argument here to avoid instantiating Span<T>
+  // first and then implicitly converting to Span<const T>
+  return Span<const T>{_0.ptr->data.slice, Length()};
 }
 
 template <typename T>

mfbt/Buffer.h

@@ -143,12 +143,8 @@ class Buffer final {
     return Some(Buffer(std::move(data), aLength));
   }
 
-  mozilla::Span<const T> AsSpan() const {
-    return mozilla::MakeSpan(mData.get(), mLength);
-  }
-  mozilla::Span<T> AsWritableSpan() {
-    return mozilla::MakeSpan(mData.get(), mLength);
-  }
+  auto AsSpan() const { return mozilla::Span<const T>{mData.get(), mLength}; }
+  auto AsWritableSpan() { return mozilla::Span<T>{mData.get(), mLength}; }
   operator mozilla::Span<const T>() const { return AsSpan(); }
   operator mozilla::Span<T>() { return AsWritableSpan(); }
 

mfbt/Compression.cpp

@@ -122,8 +122,7 @@ Result<Span<const char>, size_t> LZ4FrameCompressionContext::BeginCompressing(
     return Err(headerSize);
   }
 
-  return MakeSpan(static_cast<const char*>(mWriteBuffer.Elements()),
-                  headerSize);
+  return Span{static_cast<const char*>(mWriteBuffer.Elements()), headerSize};
 }
 
 Result<Span<const char>, size_t>
@@ -137,8 +136,7 @@ LZ4FrameCompressionContext::ContinueCompressing(Span<const char> aInput) {
     return Err(outputSize);
   }
 
-  return MakeSpan(static_cast<const char*>(mWriteBuffer.Elements()),
-                  outputSize);
+  return Span{static_cast<const char*>(mWriteBuffer.Elements()), outputSize};
 }
 
 Result<Span<const char>, size_t> LZ4FrameCompressionContext::EndCompressing() {
@@ -149,8 +147,7 @@ Result<Span<const char>, size_t> LZ4FrameCompressionContext::EndCompressing() {
     return Err(outputSize);
   }
 
-  return MakeSpan(static_cast<const char*>(mWriteBuffer.Elements()),
-                  outputSize);
+  return Span{static_cast<const char*>(mWriteBuffer.Elements()), outputSize};
 }
 
 LZ4FrameDecompressionContext::LZ4FrameDecompressionContext(bool aStableDest)

mfbt/Vector.h

@@ -501,10 +501,12 @@ class MOZ_NON_PARAM Vector final : private AllocPolicy {
   }
 
   operator mozilla::Span<const T>() const {
-    return mozilla::MakeSpan(mBegin, mLength);
+    // Explicitly specify template argument here to avoid instantiating Span<T>
+    // first and then implicitly converting to Span<const T>
+    return mozilla::Span<const T>{mBegin, mLength};
   }
 
-  operator mozilla::Span<T>() { return mozilla::MakeSpan(mBegin, mLength); }
+  operator mozilla::Span<T>() { return mozilla::Span{mBegin, mLength}; }
 
   class Range {
     friend class Vector;

mozglue/misc/NativeNt.h

@@ -840,7 +840,7 @@ class MOZ_RAII PEHeaders final {
     // The Windows loader has an internal limit of 96 sections (per PE spec)
     auto numSections =
         std::min(mPeHeader->FileHeader.NumberOfSections, WORD(96));
-    return MakeSpan(base, numSections);
+    return Span{base, numSections};
   }
 
   PIMAGE_RESOURCE_DIRECTORY_ENTRY

parser/html/nsHtml5OwningUTF16Buffer.cpp

@@ -49,7 +49,7 @@ void nsHtml5OwningUTF16Buffer::Swap(nsHtml5OwningUTF16Buffer* aOther) {
 
 Span<char16_t> nsHtml5OwningUTF16Buffer::TailAsSpan(int32_t aBufferSize) {
   MOZ_ASSERT(aBufferSize >= getEnd());
-  return MakeSpan(getBuffer() + getEnd(), aBufferSize - getEnd());
+  return {getBuffer() + getEnd(), static_cast<size_t>(aBufferSize - getEnd())};
 }
 
 void nsHtml5OwningUTF16Buffer::AdvanceEnd(int32_t aNumberOfCodeUnits) {

xpcom/ds/nsAtom.h

@@ -59,8 +59,10 @@ class nsAtom {
   uint32_t GetLength() const { return mLength; }
 
   operator mozilla::Span<const char16_t>() const {
-    return mozilla::MakeSpan(static_cast<const char16_t*>(GetUTF16String()),
-                             GetLength());
+    // Explicitly specify template argument here to avoid instantiating
+    // Span<char16_t> first and then implicitly converting to Span<const
+    // char16_t>
+    return mozilla::Span<const char16_t>{GetUTF16String(), GetLength()};
   }
 
   void ToString(nsAString& aString) const;

xpcom/string/nsTSubstring.h

@@ -138,9 +138,7 @@ class BulkWriteHandle final {
    *  2) RestartBulkWrite() is called
    *  3) BulkWriteHandle goes out of scope
    */
-  mozilla::Span<T> AsSpan() const {
-    return mozilla::MakeSpan(Elements(), Length());
-  }
+  auto AsSpan() const { return mozilla::Span<T>{Elements(), Length()}; }
 
   /**
    * Autoconvert to the buffer as writable Span.
@@ -938,12 +936,12 @@ class nsTSubstring : public mozilla::detail::nsTStringRepr<T> {
    */
 
   operator mozilla::Span<char_type>() {
-    return mozilla::MakeSpan(BeginWriting(), base_string_type::Length());
+    return mozilla::Span{BeginWriting(), base_string_type::Length()};
   }
 
   operator mozilla::Span<const char_type>() const {
-    return mozilla::MakeSpan(base_string_type::BeginReading(),
-                             base_string_type::Length());
+    return mozilla::Span{base_string_type::BeginReading(),
+                         base_string_type::Length()};
   }
 
   void Append(mozilla::Span<const char_type> aSpan) {
@@ -975,15 +973,15 @@ class nsTSubstring : public mozilla::detail::nsTStringRepr<T> {
 
   template <typename Q = T, typename EnableIfChar = mozilla::CharOnlyT<Q>>
   operator mozilla::Span<uint8_t>() {
-    return mozilla::MakeSpan(reinterpret_cast<uint8_t*>(BeginWriting()),
-                             base_string_type::Length());
+    return mozilla::Span{reinterpret_cast<uint8_t*>(BeginWriting()),
+                         base_string_type::Length()};
   }
 
   template <typename Q = T, typename EnableIfChar = mozilla::CharOnlyT<Q>>
   operator mozilla::Span<const uint8_t>() const {
-    return mozilla::MakeSpan(
+    return mozilla::Span{
         reinterpret_cast<const uint8_t*>(base_string_type::BeginReading()),
-        base_string_type::Length());
+        base_string_type::Length()};
   }
 
   template <typename Q = T, typename EnableIfChar = mozilla::CharOnlyT<Q>>