feat: Apply suggestions from code review

Author: spotandjake

CHANGELOG.md

@@ -15,11 +15,11 @@ full changeset diff at the end of each section.
 Current Trunk
 -------------
  - Add a `BinaryenDataSegmentRef` type to the C API. (#8286)
-   - Add `BinaryenGetMemorySegment` and `BinaryenGetMemorySegmentByIndex` to the C API, which allow looking up a memory segment by name or index.
-   - Add `BinaryenGetMemorySegmentName` to the C API, which allows looking up a memory segment's name.
+   - Add `BinaryenGetDataSegment` and `BinaryenGetDataSegmentByIndex` to the C API, which allow looking up a data segment by name or index.
+   - Add `BinaryenDataSegmentGetName` to the C API, which allows looking up a data segment's name.
    - Convert `BinaryenGetMemorySegmentByteOffset`, `BinaryenGetMemorySegmentByteLength`, `BinaryenGetMemorySegmentPassive` and `BinaryenCopyMemorySegmentData` to take a `BinaryenDataSegmentRef` instead of a name.
-   - Add `module.getMemorySegment`, `module.getMemorySegmentByIndex` to the JS API, which allows looking up a memory segment by name or index.
-   - Convert `module.getMemorySegmentInfo` to take a memory segment reference instead of a name, and return the name as part of the info.
+   - Add `module.getDataSegment`, `module.getDataSegmentByIndex` to the JS API, which allows looking up a data segment by name or index.
+   - Convert `module.getMemorySegmentInfo` to take a data segment reference instead of a name, and return the name as part of the info.
 
 - Add support for non-nullable table types and initialization expressions for
    tables. This comes with a breaking change to C API: `BinaryenAddTable` takes

src/binaryen-c.cpp

@@ -5492,19 +5492,19 @@ void BinaryenSetMemory(BinaryenModuleRef module,
 uint32_t BinaryenGetNumMemorySegments(BinaryenModuleRef module) {
   return ((Module*)module)->dataSegments.size();
 }
-BinaryenDataSegmentRef BinaryenGetMemorySegment(BinaryenModuleRef module,
+BinaryenDataSegmentRef BinaryenGetDataSegment(BinaryenModuleRef module,
                                                 const char* segmentName) {
   return ((Module*)module)->getDataSegmentOrNull(Name(segmentName));
 }
-BinaryenDataSegmentRef BinaryenGetMemorySegmentByIndex(BinaryenModuleRef module,
+BinaryenDataSegmentRef BinaryenGetDataSegmentByIndex(BinaryenModuleRef module,
                                                        BinaryenIndex index) {
   const auto& dataSegments = ((Module*)module)->dataSegments;
   if (dataSegments.size() <= index) {
     Fatal() << "invalid memory segment index.";
   }
   return dataSegments[index].get();
 }
-const char* BinaryenGetMemorySegmentName(BinaryenDataSegmentRef segment) {
+const char* BinaryenDataSegmentGetName(BinaryenDataSegmentRef segment) {
   return ((DataSegment*)segment)->name.str.data();
 }
 uint32_t BinaryenGetMemorySegmentByteOffset(BinaryenModuleRef module,

src/binaryen-c.h

@@ -3009,11 +3009,11 @@ BINARYEN_REF(DataSegment);
 
 BINARYEN_API uint32_t BinaryenGetNumMemorySegments(BinaryenModuleRef module);
 BINARYEN_API BinaryenDataSegmentRef
-BinaryenGetMemorySegment(BinaryenModuleRef module, const char* segmentName);
+BinaryenGetDataSegment(BinaryenModuleRef module, const char* segmentName);
 BINARYEN_API BinaryenDataSegmentRef
-BinaryenGetMemorySegmentByIndex(BinaryenModuleRef module, BinaryenIndex index);
+BinaryenGetDataSegmentByIndex(BinaryenModuleRef module, BinaryenIndex index);
 BINARYEN_API const char*
-BinaryenGetMemorySegmentName(BinaryenDataSegmentRef segment);
+BinaryenDataSegmentGetName(BinaryenDataSegmentRef segment);
 BINARYEN_API uint32_t BinaryenGetMemorySegmentByteOffset(
   BinaryenModuleRef module, BinaryenDataSegmentRef segment);
 BINARYEN_API size_t

src/js/binaryen.js-post.js

@@ -2773,26 +2773,26 @@ function wrapModule(module, self = {}) {
     return Module['_BinaryenGetNumMemorySegments'](module);
   };
   /**
-   * Gets the memory segment with the given name.
+   * Gets the data segment with the given name.
    * 
-   * @param {string} name - The name of the memory segment to get.
-   * @returns {number} A MemorySegmentRef referring to the memory segment with the given name, or `0` if no such segment exists.
+   * @param {string} name - The name of the data segment to get.
+   * @returns {number} A DataSegmentRef referring to the data segment with the given name, or `0` if no such segment exists.
    */
-  self['getMemorySegment'] = function(name) {
+  self['getDataSegment'] = function(name) {
     return preserveStack(() => {
-      return Module['_BinaryenGetMemorySegment'](module, strToStack(name));
+      return Module['_BinaryenGetDataSegment'](module, strToStack(name));
     });
   };
   /**
-   * Gets the memory segment at the given index.
+   * Gets the data segment at the given index.
    * 
-   * @param {number} index - The index of the memory segment to get.
-   * @returns {number} A MemorySegmentRef referring to the memory segment at the given index.
+   * @param {number} index - The index of the data segment to get.
+   * @returns {number} A DataSegmentRef referring to the data segment at the given index.
    * 
-   * @throws If no memory segment exists at the given index.
+   * @throws If no data segment exists at the given index.
    */
-  self['getMemorySegmentByIndex'] = function(index) {
-    return Module['_BinaryenGetMemorySegmentByIndex'](module, index);
+  self['getDataSegmentByIndex'] = function(index) {
+    return Module['_BinaryenGetDataSegmentByIndex'](module, index);
   };
   /**
    * Queries information about a memory segment.
@@ -2813,7 +2813,7 @@ function wrapModule(module, self = {}) {
       offset = Module['_BinaryenGetMemorySegmentByteOffset'](module, segment);
     }
     return {
-      'name': UTF8ToString(Module['_BinaryenGetMemorySegmentName'](segment)),
+      'name': UTF8ToString(Module['_BinaryenDataSegmentGetName'](segment)),
       'offset': offset,
       'data': (function(){
         const size = Module['_BinaryenGetMemorySegmentByteLength'](segment);

test/binaryen.js/kitchen-sink.js

@@ -1144,10 +1144,10 @@ function test_for_each() {
       data: expected_data[2].split('').map(function(x) { return x.charCodeAt(0) })
     }
   ], false);
-  assert(module.getMemorySegment(expected_names[0]) !== 0);
-  assert(module.getMemorySegment("NonExistantSegment") === 0);
+  assert(module.getDataSegment(expected_names[0]) !== 0);
+  assert(module.getDataSegment("NonExistantSegment") === 0);
   for (i = 0; i < module.getNumMemorySegments(); i++) {
-    var segment = module.getMemorySegmentByIndex(i);
+    var segment = module.getDataSegmentByIndex(i);
     var info = module.getMemorySegmentInfo(segment);
     assert(expected_names[i] === info.name);
     assert(expected_offsets[i] === info.offset);

test/example/c-api-kitchen-sink.c

@@ -2019,14 +2019,14 @@ void test_for_each() {
                       BinaryenTypeInt32(),
                       0,
                       makeInt32(module, expected_offsets[1]));
-    assert(BinaryenGetMemorySegment(module, segmentNames[0]) != NULL);
-    assert(BinaryenGetMemorySegment(module, "NonExistantSegment") == NULL);
+    assert(BinaryenGetDataSegment(module, segmentNames[0]) != NULL);
+    assert(BinaryenGetDataSegment(module, "NonExistantSegment") == NULL);
     for (i = 0; i < BinaryenGetNumMemorySegments(module); i++) {
       char out[15] = {};
       BinaryenDataSegmentRef segment =
-        BinaryenGetMemorySegmentByIndex(module, i);
+        BinaryenGetDataSegmentByIndex(module, i);
       assert(segment != NULL);
-      assert(BinaryenGetMemorySegmentName(segment) != NULL);
+      assert(BinaryenDataSegmentGetName(segment) != NULL);
       assert(BinaryenGetMemorySegmentByteOffset(module, segment) ==
              expected_offsets[i]);
       assert(BinaryenGetMemorySegmentByteLength(segment) == segmentSizes[i]);