NFC: Rename not_packed to NotPacked for consistency with other enum values (#8332)

stevenfontanella · web-flow · commit 301a90279479 · 2026-02-18T11:38:14.000-08:00
Followup to https://github.com/WebAssembly/binaryen/pull/8323/changes#r2805124301
diff --git a/src/binaryen-c.cpp b/src/binaryen-c.cpp
@@ -252,7 +252,7 @@ WASM_DEPRECATED BinaryenType BinaryenUndefined(void) { return uint32_t(-1); }
 // Packed types
 
 BinaryenPackedType BinaryenPackedTypeNotPacked(void) {
-  return Field::PackedType::not_packed;
+  return Field::PackedType::NotPacked;
 }
 BinaryenPackedType BinaryenPackedTypeInt8(void) {
   return Field::PackedType::i8;
@@ -6581,7 +6581,7 @@ void TypeBuilderSetStructType(TypeBuilderRef builder,
     if (field.type == Type::i32) {
       field.packedType = Field::PackedType(fieldPackedTypes[cur]);
     } else {
-      assert(fieldPackedTypes[cur] == Field::PackedType::not_packed);
+      assert(fieldPackedTypes[cur] == Field::PackedType::NotPacked);
     }
     fields.push_back(field);
   }
@@ -6598,7 +6598,7 @@ void TypeBuilderSetArrayType(TypeBuilderRef builder,
   if (element.type == Type::i32) {
     element.packedType = Field::PackedType(elementPackedType);
   } else {
-    assert(elementPackedType == Field::PackedType::not_packed);
+    assert(elementPackedType == Field::PackedType::NotPacked);
   }
   B->setHeapType(index, Array(element));
 }
diff --git a/src/ir/possible-constant.h b/src/ir/possible-constant.h
@@ -120,7 +120,7 @@ struct PossibleConstantValues {
           value = val.and_(Literal(uint32_t(0xffff)));
         }
         break;
-      case Field::not_packed:
+      case Field::NotPacked:
         WASM_UNREACHABLE("unexpected packed type");
     }
   }
diff --git a/src/parser/contexts.h b/src/parser/contexts.h
@@ -311,7 +311,7 @@ template<typename Ctx> struct TypeParserCtx {
   StorageT makeStorageType(TypeT type) { return Field(type, Immutable); }
 
   FieldT makeFieldType(FieldT field, Mutability mutability) {
-    if (field.packedType == Field::not_packed) {
+    if (field.packedType == Field::NotPacked) {
       return Field(field.type, mutability);
     }
     return Field(field.packedType, mutability);
diff --git a/src/passes/Print.cpp b/src/passes/Print.cpp
@@ -2351,7 +2351,7 @@ struct PrintExpressionContents
     if (curr->order != MemoryOrder::Unordered) {
       printMedium(o, ".atomic");
     }
-    if (field.type == Type::i32 && field.packedType != Field::not_packed) {
+    if (field.type == Type::i32 && field.packedType != Field::NotPacked) {
       if (curr->signed_) {
         printMedium(o, ".get_s");
       } else {
@@ -2439,7 +2439,7 @@ struct PrintExpressionContents
     if (curr->order != MemoryOrder::Unordered) {
       printMedium(o, ".atomic");
     }
-    if (element.type == Type::i32 && element.packedType != Field::not_packed) {
+    if (element.type == Type::i32 && element.packedType != Field::NotPacked) {
       if (curr->signed_) {
         printMedium(o, ".get_s");
       } else {
diff --git a/src/wasm-interpreter.h b/src/wasm-interpreter.h
@@ -2740,7 +2740,7 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
 
   Literal makeFromMemory(void* p, Field field) {
     switch (field.packedType) {
-      case Field::not_packed:
+      case Field::NotPacked:
         return Literal::makeFromMemory(p, field.type);
       case Field::i8: {
         int8_t i;
diff --git a/src/wasm-type.h b/src/wasm-type.h
@@ -698,22 +698,22 @@ struct Continuation {
 struct Field {
   Type type;
   enum PackedType {
-    not_packed,
+    NotPacked,
     i8,
     i16,
   } packedType; // applicable iff type=i32
   Mutability mutable_;
 
   // Arbitrary defaults for convenience.
   constexpr Field()
-    : type(Type::i32), packedType(not_packed), mutable_(Mutable) {}
+    : type(Type::i32), packedType(NotPacked), mutable_(Mutable) {}
   constexpr Field(Type type, Mutability mutable_)
-    : type(type), packedType(not_packed), mutable_(mutable_) {}
+    : type(type), packedType(NotPacked), mutable_(mutable_) {}
   constexpr Field(PackedType packedType, Mutability mutable_)
     : type(Type::i32), packedType(packedType), mutable_(mutable_) {}
 
   constexpr bool isPacked() const {
-    if (packedType != not_packed) {
+    if (packedType != NotPacked) {
       assert(type == Type::i32 && "unexpected type");
       return true;
     }
diff --git a/src/wasm/wasm-binary.cpp b/src/wasm/wasm-binary.cpp
@@ -2003,7 +2003,7 @@ void WasmBinaryWriter::writeIndexedHeapType(HeapType type) {
 }
 
 void WasmBinaryWriter::writeField(const Field& field) {
-  if (field.type == Type::i32 && field.packedType != Field::not_packed) {
+  if (field.type == Type::i32 && field.packedType != Field::NotPacked) {
     if (field.packedType == Field::i8) {
       o << S32LEB(BinaryConsts::EncodedType::i8);
     } else if (field.packedType == Field::i16) {
diff --git a/src/wasm/wasm-stack.cpp b/src/wasm/wasm-stack.cpp
@@ -2441,7 +2441,7 @@ void BinaryInstWriter::visitStructGet(StructGet* curr) {
   const auto& field = heapType.getStruct().fields[curr->index];
   bool atomic = curr->order != MemoryOrder::Unordered;
   int8_t op;
-  if (field.type != Type::i32 || field.packedType == Field::not_packed) {
+  if (field.type != Type::i32 || field.packedType == Field::NotPacked) {
     op = atomic ? BinaryConsts::StructAtomicGet : BinaryConsts::StructGet;
   } else if (curr->signed_) {
     op = atomic ? BinaryConsts::StructAtomicGetS : BinaryConsts::StructGetS;
@@ -2556,7 +2556,7 @@ void BinaryInstWriter::visitArrayGet(ArrayGet* curr) {
   const auto& field = heapType.getArray().element;
   bool atomic = curr->order != MemoryOrder::Unordered;
   int8_t op;
-  if (field.type != Type::i32 || field.packedType == Field::not_packed) {
+  if (field.type != Type::i32 || field.packedType == Field::NotPacked) {
     op = atomic ? BinaryConsts::ArrayAtomicGet : BinaryConsts::ArrayGet;
   } else if (curr->signed_) {
     op = atomic ? BinaryConsts::ArrayAtomicGetS : BinaryConsts::ArrayGetS;
diff --git a/src/wasm/wasm-type.cpp b/src/wasm/wasm-type.cpp
@@ -1483,7 +1483,7 @@ unsigned Field::getByteSize() const {
       return 1;
     case Field::PackedType::i16:
       return 2;
-    case Field::PackedType::not_packed:
+    case Field::PackedType::NotPacked:
       return 4;
   }
   WASM_UNREACHABLE("impossible packed type");
diff --git a/src/wasm/wasm-validator.cpp b/src/wasm/wasm-validator.cpp
@@ -3306,7 +3306,7 @@ void FunctionValidator::visitStructGet(StructGet* curr) {
   auto field = fields[curr->index];
   // If the type is not packed, it must be marked internally as unsigned, by
   // convention.
-  if (field.type != Type::i32 || field.packedType == Field::not_packed) {
+  if (field.type != Type::i32 || field.packedType == Field::NotPacked) {
     shouldBeFalse(curr->signed_, curr, "non-packed get cannot be signed");
   }
   if (curr->ref->type == Type::unreachable) {
@@ -3626,7 +3626,7 @@ void FunctionValidator::visitArrayGet(ArrayGet* curr) {
   const auto& element = heapType.getArray().element;
   // If the type is not packed, it must be marked internally as unsigned, by
   // convention.
-  if (element.type != Type::i32 || element.packedType == Field::not_packed) {
+  if (element.type != Type::i32 || element.packedType == Field::NotPacked) {
     shouldBeFalse(curr->signed_, curr, "non-packed get cannot be signed");
   }
   shouldBeEqual(
diff --git a/test/example/cpp-unit.cpp b/test/example/cpp-unit.cpp
@@ -660,8 +660,7 @@ void test_field() {
   // Packed types
   assert_equal(Field(Field::PackedType::i8, Immutable).getByteSize(), 1);
   assert_equal(Field(Field::PackedType::i16, Immutable).getByteSize(), 2);
-  assert_equal(Field(Field::PackedType::not_packed, Immutable).getByteSize(),
-               4);
+  assert_equal(Field(Field::PackedType::NotPacked, Immutable).getByteSize(), 4);
 }
 
 void test_queue() {

Original file line number	Diff line number	Diff line change
`@@ -252,7 +252,7 @@ WASM_DEPRECATED BinaryenType BinaryenUndefined(void) { return uint32_t(-1); }`
`252`	`252`	`// Packed types`
`253`	`253`
`254`	`254`	`BinaryenPackedType BinaryenPackedTypeNotPacked(void) {`
`255`		`- return Field::PackedType::not_packed;`
	`255`	`+ return Field::PackedType::NotPacked;`
`256`	`256`	`}`
`257`	`257`	`BinaryenPackedType BinaryenPackedTypeInt8(void) {`
`258`	`258`	`return Field::PackedType::i8;`
`@@ -6581,7 +6581,7 @@ void TypeBuilderSetStructType(TypeBuilderRef builder,`
`6581`	`6581`	`if (field.type == Type::i32) {`
`6582`	`6582`	`field.packedType = Field::PackedType(fieldPackedTypes[cur]);`
`6583`	`6583`	`} else {`
`6584`		`- assert(fieldPackedTypes[cur] == Field::PackedType::not_packed);`
	`6584`	`+ assert(fieldPackedTypes[cur] == Field::PackedType::NotPacked);`
`6585`	`6585`	`}`
`6586`	`6586`	`fields.push_back(field);`
`6587`	`6587`	`}`
`@@ -6598,7 +6598,7 @@ void TypeBuilderSetArrayType(TypeBuilderRef builder,`
`6598`	`6598`	`if (element.type == Type::i32) {`
`6599`	`6599`	`element.packedType = Field::PackedType(elementPackedType);`
`6600`	`6600`	`} else {`
`6601`		`- assert(elementPackedType == Field::PackedType::not_packed);`
	`6601`	`+ assert(elementPackedType == Field::PackedType::NotPacked);`
`6602`	`6602`	`}`
`6603`	`6603`	`B->setHeapType(index, Array(element));`
`6604`	`6604`	`}`
Original file line number	Diff line number	Diff line change
`@@ -120,7 +120,7 @@ struct PossibleConstantValues {`
`120`	`120`	`value = val.and_(Literal(uint32_t(0xffff)));`
`121`	`121`	`}`
`122`	`122`	`break;`
`123`		`- case Field::not_packed:`
	`123`	`+ case Field::NotPacked:`
`124`	`124`	`WASM_UNREACHABLE("unexpected packed type");`
`125`	`125`	`}`
`126`	`126`	`}`
Original file line number	Diff line number	Diff line change
`@@ -311,7 +311,7 @@ template<typename Ctx> struct TypeParserCtx {`
`311`	`311`	`StorageT makeStorageType(TypeT type) { return Field(type, Immutable); }`
`312`	`312`
`313`	`313`	`FieldT makeFieldType(FieldT field, Mutability mutability) {`
`314`		`- if (field.packedType == Field::not_packed) {`
	`314`	`+ if (field.packedType == Field::NotPacked) {`
`315`	`315`	`return Field(field.type, mutability);`
`316`	`316`	`}`
`317`	`317`	`return Field(field.packedType, mutability);`
Original file line number	Diff line number	Diff line change
`@@ -2003,7 +2003,7 @@ void WasmBinaryWriter::writeIndexedHeapType(HeapType type) {`
`2003`	`2003`	`}`
`2004`	`2004`
`2005`	`2005`	`void WasmBinaryWriter::writeField(const Field& field) {`
`2006`		`- if (field.type == Type::i32 && field.packedType != Field::not_packed) {`
	`2006`	`+ if (field.type == Type::i32 && field.packedType != Field::NotPacked) {`
`2007`	`2007`	`if (field.packedType == Field::i8) {`
`2008`	`2008`	`o << S32LEB(BinaryConsts::EncodedType::i8);`
`2009`	`2009`	`} else if (field.packedType == Field::i16) {`
Original file line number	Diff line number	Diff line change
`@@ -1483,7 +1483,7 @@ unsigned Field::getByteSize() const {`
`1483`	`1483`	`return 1;`
`1484`	`1484`	`case Field::PackedType::i16:`
`1485`	`1485`	`return 2;`
`1486`		`- case Field::PackedType::not_packed:`
	`1486`	`+ case Field::PackedType::NotPacked:`
`1487`	`1487`	`return 4;`
`1488`	`1488`	`}`
`1489`	`1489`	`WASM_UNREACHABLE("impossible packed type");`