use explicit types in Cursor::write in proxygen/

Summary:
Addresses problems like this:

```
void* buf = /*...*/;
uint16_t word = /*...*/;
cursor.write(word & 0xffff); // oops, 32-bit store due to implicit integer promotion
```

Differential Revision: D94252977

fbshipit-source-id: 3d3645d298662bf7a8e79727b3b84cb35b51ec69

Author: yfeldblum

third-party/proxygen/src/proxygen/httpserver/samples/hq/devious/DeviousBaton.cpp

@@ -17,7 +17,9 @@ namespace {
 std::unique_ptr<folly::IOBuf> makeBatonMessage(uint64_t padLen, uint8_t baton) {
   auto buf = folly::IOBuf::create(padLen + 9);
   folly::io::Appender cursor(buf.get(), 1);
-  (void)quic::encodeQuicInteger(padLen, [&](auto val) { cursor.writeBE(val); });
+  (void)quic::encodeQuicInteger(padLen, [&](auto val) {
+    cursor.writeBE(folly::tag<decltype(val)>, val);
+  });
   memset(buf->writableTail(), 'a', padLen);
   buf->append(padLen);
   buf->writableTail()[0] = baton;

third-party/proxygen/src/proxygen/lib/http/codec/HQFramer.cpp

@@ -199,7 +199,7 @@ WriteResult writeFrameHeader(IOBufQueue& queue,
                              uint64_t length) noexcept {
   QueueAppender appender(&queue, kMaxFrameHeaderSize);
   auto appenderOp = [appender = std::move(appender)](auto val) mutable {
-    appender.writeBE(val);
+    appender.writeBE(folly::tag<decltype(val)>, val);
   };
   auto typeRes =
       quic::encodeQuicInteger(static_cast<uint64_t>(type), appenderOp);
@@ -251,7 +251,7 @@ WriteResult writeCancelPush(folly::IOBufQueue& writeBuf,
   QueueAppender appender(&queue, *pushIdSize);
   auto encodeResult = quic::encodeQuicInteger(
       pushId, [appender = std::move(appender)](auto val) mutable {
-        appender.writeBE(val);
+        appender.writeBE(folly::tag<decltype(val)>, val);
       });
   if (encodeResult.hasError()) {
     return folly::makeUnexpected(quic::QuicError(encodeResult.error()));
@@ -283,7 +283,7 @@ WriteResult writeSettings(IOBufQueue& queue,
   // write the frame payload
   QueueAppender appender(&queue, settingsSize);
   auto appenderOp = [appender = std::move(appender)](auto val) mutable {
-    appender.writeBE(val);
+    appender.writeBE(folly::tag<decltype(val)>, val);
   };
   for (const auto& setting : settings) {
     auto idResult = quic::encodeQuicInteger(
@@ -314,8 +314,9 @@ WriteResult writePushPromise(IOBufQueue& queue,
     return headerSize;
   }
   QueueAppender appender(&queue, payloadSize);
-  auto encodeResult =
-      quic::encodeQuicInteger(pushId, [&](auto val) { appender.writeBE(val); });
+  auto encodeResult = quic::encodeQuicInteger(pushId, [&](auto val) {
+    appender.writeBE(folly::tag<decltype(val)>, val);
+  });
   if (encodeResult.hasError()) {
     return folly::makeUnexpected(quic::QuicError(encodeResult.error()));
   }
@@ -333,7 +334,7 @@ WriteResult writeGoaway(folly::IOBufQueue& writeBuf,
   QueueAppender appender(&queue, *lastStreamIdSize);
   auto encodeResult = quic::encodeQuicInteger(
       lastStreamId, [appender = std::move(appender)](auto val) mutable {
-        appender.writeBE(val);
+        appender.writeBE(folly::tag<decltype(val)>, val);
       });
   if (encodeResult.hasError()) {
     return folly::makeUnexpected(quic::QuicError(encodeResult.error()));
@@ -351,7 +352,7 @@ WriteResult writeMaxPushId(folly::IOBufQueue& writeBuf,
   QueueAppender appender(&queue, *maxPushIdSize);
   auto encodeResult = quic::encodeQuicInteger(
       maxPushId, [appender = std::move(appender)](auto val) mutable {
-        appender.writeBE(val);
+        appender.writeBE(folly::tag<decltype(val)>, val);
       });
   if (encodeResult.hasError()) {
     return folly::makeUnexpected(quic::QuicError(encodeResult.error()));
@@ -369,8 +370,9 @@ WriteResult writePriorityUpdate(folly::IOBufQueue& writeBuf,
   }
   IOBufQueue queue(IOBufQueue::cacheChainLength());
   QueueAppender appender(&queue, *streamIdSize);
-  auto encodeResult = quic::encodeQuicInteger(
-      streamId, [&appender](auto val) { appender.writeBE(val); });
+  auto encodeResult = quic::encodeQuicInteger(streamId, [&appender](auto val) {
+    appender.writeBE(folly::tag<decltype(val)>, val);
+  });
   if (encodeResult.hasError()) {
     return folly::makeUnexpected(quic::QuicError(encodeResult.error()));
   }
@@ -390,8 +392,9 @@ WriteResult writePushPriorityUpdate(
   }
   IOBufQueue queue(IOBufQueue::cacheChainLength());
   QueueAppender appender(&queue, *streamIdSize);
-  auto encodeResult = quic::encodeQuicInteger(
-      pushId, [&appender](auto val) { appender.writeBE(val); });
+  auto encodeResult = quic::encodeQuicInteger(pushId, [&appender](auto val) {
+    appender.writeBE(folly::tag<decltype(val)>, val);
+  });
   if (encodeResult.hasError()) {
     return folly::makeUnexpected(quic::QuicError(encodeResult.error()));
   }
@@ -407,8 +410,10 @@ WriteResult writeStreamPreface(folly::IOBufQueue& writeBuf,
     return folly::makeUnexpected(streamPrefaceSize.error());
   }
   QueueAppender appender(&writeBuf, *streamPrefaceSize);
-  auto encodeResult = quic::encodeQuicInteger(
-      streamPreface, [&appender](auto val) { appender.writeBE(val); });
+  auto encodeResult =
+      quic::encodeQuicInteger(streamPreface, [&appender](auto val) {
+        appender.writeBE(folly::tag<decltype(val)>, val);
+      });
   if (encodeResult.hasError()) {
     return folly::makeUnexpected(quic::QuicError(encodeResult.error()));
   }
@@ -477,14 +482,16 @@ WriteResult writeWTStreamPreface(folly::IOBufQueue& writeBuf,
   CHECK_LT(idx, streamTypes.size());
   QueueAppender appender(&writeBuf, 64);
   size_t prefaceSize = 0;
-  auto res = quic::encodeQuicInteger(
-      streamTypes[idx], [&appender](auto val) { appender.writeBE(val); });
+  auto res = quic::encodeQuicInteger(streamTypes[idx], [&appender](auto val) {
+    appender.writeBE(folly::tag<decltype(val)>, val);
+  });
   if (!res) {
     return folly::makeUnexpected(quic::QuicError(res.error()));
   }
   prefaceSize += res.value();
-  res = quic::encodeQuicInteger(
-      wtSessionId, [&appender](auto val) { appender.writeBE(val); });
+  res = quic::encodeQuicInteger(wtSessionId, [&appender](auto val) {
+    appender.writeBE(folly::tag<decltype(val)>, val);
+  });
   if (!res) {
     return folly::makeUnexpected(quic::QuicError(res.error()));
   }

third-party/proxygen/src/proxygen/lib/http/codec/HTTP2Framer.cpp

@@ -822,9 +822,9 @@ size_t writeAltSvc(IOBufQueue& queue,
   QueueAppender appender(&queue, frameLen);
   appender.writeBE<uint32_t>(maxAge);
   appender.writeBE<uint16_t>(port);
-  appender.writeBE<uint8_t>(protoLen);
+  appender.writeBE<uint8_t>(static_cast<uint8_t>(protoLen));
   appender.push(reinterpret_cast<const uint8_t*>(protocol.data()), protoLen);
-  appender.writeBE<uint8_t>(hostLen);
+  appender.writeBE<uint8_t>(static_cast<uint8_t>(hostLen));
   appender.push(reinterpret_cast<const uint8_t*>(host.data()), hostLen);
   appender.push(reinterpret_cast<const uint8_t*>(origin.data()), originLen);
   return kFrameHeaderSize + frameLen;

third-party/proxygen/src/proxygen/lib/http/codec/HTTPBinaryCodec.cpp

@@ -27,8 +27,8 @@ namespace proxygen {
 namespace {
 folly::Expected<size_t, quic::TransportErrorCode> encodeInteger(
     uint64_t i, folly::io::QueueAppender& appender) {
-  auto result =
-      quic::encodeQuicInteger(i, [&](auto val) { appender.writeBE(val); });
+  auto result = quic::encodeQuicInteger(
+      i, [&](auto val) { appender.writeBE(folly::tag<decltype(val)>, val); });
   if (result.has_value()) {
     return result.value();
   } else {

third-party/proxygen/src/proxygen/lib/http/codec/compress/experimental/interop/QPACKInterop.cpp

@@ -37,7 +37,8 @@ void writeFrame(folly::io::QueueAppender& appender,
                 uint64_t streamId,
                 std::unique_ptr<folly::IOBuf> buf) {
   appender.writeBE<uint64_t>(streamId);
-  appender.writeBE<uint32_t>(buf->computeChainDataLength());
+  appender.writeBE<uint32_t>(
+      static_cast<uint32_t>(buf->computeChainDataLength()));
   appender.insert(std::move(buf));
 }
 

third-party/proxygen/src/proxygen/lib/http/codec/compress/experimental/simulator/HPACKScheme.h

@@ -48,7 +48,7 @@ class HPACKScheme : public CompressionScheme {
     auto block = client_.encode(allHeaders);
     block->prepend(sizeof(uint16_t));
     folly::io::RWPrivateCursor c(block.get());
-    c.writeBE<uint16_t>(index++);
+    c.writeBE<uint16_t>(static_cast<uint16_t>(index++));
     stats.uncompressed += client_.getEncodedSize().uncompressed;
     stats.compressed += client_.getEncodedSize().compressed;
     // OOO is allowed with 0 table size

third-party/proxygen/src/proxygen/lib/http/codec/compress/experimental/simulator/QPACKScheme.h

@@ -98,12 +98,12 @@ class QPACKScheme : public CompressionScheme {
       // Don't count the framing against the compression ratio, for now
       // stats.compressed += 3 * sizeof(uint16_t);
     } else {
-      cursor.writeBE<uint16_t>(0);
+      cursor.writeBE<uint16_t>(static_cast<uint16_t>(0));
     }
     if (result.stream) {
       len = result.stream->computeChainDataLength();
     }
-    cursor.writeBE<uint16_t>(index);
+    cursor.writeBE<uint16_t>(static_cast<uint16_t>(index));
     cursor.writeBE<uint16_t>(len);
     cursor.insert(std::move(result.stream));
     stats.uncompressed += client_.getEncodedSize().uncompressed;

third-party/proxygen/src/proxygen/lib/http/codec/test/HQFramerTest.cpp

@@ -262,7 +262,8 @@ TEST_P(HQFramerTestIdOnlyFrames, TestIdOnlyFrame) {
     RWPrivateCursor wcursor(buf.get());
     // 2 bytes frame header (payload length is just 1)
     wcursor.skip(2);
-    wcursor.writeBE<uint8_t>(0x42); // this varint requires two bytes
+    wcursor.writeBE<uint8_t>( // this varint requires two bytes
+        static_cast<uint8_t>(0x42));
     queue_.append(std::move(buf));
 
     FrameHeader header;

third-party/proxygen/src/proxygen/lib/http/codec/test/HTTP2CodecTest.cpp

@@ -1267,7 +1267,7 @@ TEST_F(HTTP2CodecTest, ZeroWindow) {
   upstreamCodec_.generateWindowUpdate(output_, streamID, 1);
   output_.trimEnd(http2::kFrameWindowUpdateSize);
   QueueAppender appender(&output_, http2::kFrameWindowUpdateSize);
-  appender.writeBE<uint32_t>(0);
+  appender.writeBE<uint32_t>(static_cast<uint32_t>(0));
 
   parse();
   // This test doesn't ensure that RST_STREAM is generated
@@ -1677,7 +1677,7 @@ TEST_F(HTTP2CodecTest, BadRFC9218Priority) {
   EXPECT_TRUE(parse([&](IOBuf* ingress) {
     folly::io::RWPrivateCursor c(ingress);
     c.skip(http2::kFrameHeaderSize + sizeof(uint32_t));
-    c.writeBE<uint32_t>(1);
+    c.writeBE<uint32_t>(static_cast<uint32_t>(1));
   }));
 
   // ill-formatted priority, so returns default priority

third-party/proxygen/src/proxygen/lib/http/codec/test/HTTP2FramerTest.cpp

@@ -260,7 +260,7 @@ TEST_F(HTTP2FramerTest, GoawayDoubleRead) {
       queue_, kFrameGoawaySize, static_cast<uint8_t>(FrameType::GOAWAY), 0, 0);
 
   QueueAppender appender(&queue_, kFrameGoawaySize);
-  appender.writeBE<uint32_t>(0);
+  appender.writeBE<uint32_t>(static_cast<uint32_t>(0));
   // Here's the invalid value:
   appender.writeBE<uint32_t>(static_cast<uint32_t>(0xffffffff));
 
@@ -413,7 +413,7 @@ TEST_F(HTTP2FramerTest, ShortCertificateRequest) {
   writeFrameHeaderManual(
       queue_, 1, static_cast<uint8_t>(FrameType::CERTIFICATE_REQUEST), 0, 0);
   QueueAppender appender(&queue_, 1);
-  appender.writeBE<uint8_t>(1);
+  appender.writeBE<uint8_t>(static_cast<uint8_t>(1));
 
   Cursor cursor(queue_.front());
   FrameHeader header;
@@ -430,7 +430,7 @@ TEST_F(HTTP2FramerTest, CertificateRequestOnNonzeroStream) {
   writeFrameHeaderManual(
       queue_, 2, static_cast<uint8_t>(FrameType::CERTIFICATE_REQUEST), 0, 1);
   QueueAppender appender(&queue_, 1);
-  appender.writeBE<uint16_t>(1);
+  appender.writeBE<uint16_t>(static_cast<uint16_t>(1));
 
   Cursor cursor(queue_.front());
   FrameHeader header;
@@ -509,7 +509,7 @@ TEST_F(HTTP2FramerTest, ShortCertificate) {
   writeFrameHeaderManual(
       queue_, 1, static_cast<uint8_t>(FrameType::CERTIFICATE), 0, 0);
   QueueAppender appender(&queue_, 1);
-  appender.writeBE<uint8_t>(1);
+  appender.writeBE<uint8_t>(static_cast<uint8_t>(1));
 
   Cursor cursor(queue_.front());
   FrameHeader header;
@@ -525,7 +525,7 @@ TEST_F(HTTP2FramerTest, CertificateOnNonzeroStream) {
   writeFrameHeaderManual(
       queue_, 2, static_cast<uint8_t>(FrameType::CERTIFICATE), 0, 1);
   QueueAppender appender(&queue_, 1);
-  appender.writeBE<uint16_t>(1);
+  appender.writeBE<uint16_t>(static_cast<uint16_t>(1));
 
   Cursor cursor(queue_.front());
   FrameHeader header;