rbs 3.9.4 → 4.1.1

data/include/rbs/util/rbs_buffer.h

@@ -0,0 +1,83 @@
+#ifndef RBS__RBS_BUFFER_H
+#define RBS__RBS_BUFFER_H
+
+#include "rbs/util/rbs_allocator.h"
+#include "rbs/string.h"
+
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+/**
+ * The default capacity of a rbs_buffer_t.
+ * If the buffer needs to grow beyond this capacity, it will be doubled.
+ */
+#define RBS_BUFFER_DEFAULT_CAPACITY 128
+
+/**
+ * A rbs_buffer_t is a simple memory buffer that stores data in a contiguous block of memory.
+ */
+typedef struct {
+    /** The length of the buffer in bytes. */
+    size_t length;
+
+    /** The capacity of the buffer in bytes that has been allocated. */
+    size_t capacity;
+
+    /** A pointer to the start of the buffer. */
+    char *value;
+} rbs_buffer_t;
+
+/**
+ * Initialize a rbs_buffer_t with its default values.
+ *
+ * @param allocator The allocator to use.
+ * @param buffer The buffer to initialize.
+ * @returns True if the buffer was initialized successfully, false otherwise.
+ */
+bool rbs_buffer_init(rbs_allocator_t *, rbs_buffer_t *buffer);
+
+/**
+ * Return the value of the buffer.
+ *
+ * @param buffer The buffer to get the value of.
+ * @returns The value of the buffer.
+ */
+char *rbs_buffer_value(const rbs_buffer_t *buffer);
+
+/**
+ * Return the length of the buffer.
+ *
+ * @param buffer The buffer to get the length of.
+ * @returns The length of the buffer.
+ */
+size_t rbs_buffer_length(const rbs_buffer_t *buffer);
+
+/**
+ * Append a C string to the buffer.
+ *
+ * @param allocator The allocator to use.
+ * @param buffer The buffer to append to.
+ * @param value The C string to append.
+ */
+void rbs_buffer_append_cstr(rbs_allocator_t *, rbs_buffer_t *buffer, const char *value);
+
+/**
+ * Append a string to the buffer.
+ *
+ * @param allocator The allocator to use.
+ * @param buffer The buffer to append to.
+ * @param value The string to append.
+ * @param length The length of the string to append.
+ */
+void rbs_buffer_append_string(rbs_allocator_t *, rbs_buffer_t *buffer, const char *value, size_t length);
+
+/**
+ * Convert the buffer to a rbs_string_t.
+ *
+ * @param buffer The buffer to convert.
+ * @returns The converted rbs_string_t.
+ */
+rbs_string_t rbs_buffer_to_string(rbs_buffer_t *buffer);
+
+#endif

data/include/rbs/util/rbs_constant_pool.h

@@ -10,6 +10,8 @@
 #ifndef RBS_CONSTANT_POOL_H
 #define RBS_CONSTANT_POOL_H
 
+#include "rbs/util/rbs_encoding.h"
+
 #include <assert.h>
 #include <stdbool.h>
 #include <stdint.h>
@@ -28,70 +30,6 @@
  */
 typedef uint32_t rbs_constant_id_t;
 
-/**
- * A list of constant IDs. Usually used to represent a set of locals.
- */
-typedef struct {
-    /** The number of constant ids in the list. */
-    size_t size;
-
-    /** The number of constant ids that have been allocated in the list. */
-    size_t capacity;
-
-    /** The constant ids in the list. */
-    rbs_constant_id_t *ids;
-} rbs_constant_id_list_t;
-
-/**
- * Initialize a list of constant ids.
- *
- * @param list The list to initialize.
- */
-void rbs_constant_id_list_init(rbs_constant_id_list_t *list);
-
-/**
- * Initialize a list of constant ids with a given capacity.
- *
- * @param list The list to initialize.
- * @param capacity The initial capacity of the list.
- */
-void rbs_constant_id_list_init_capacity(rbs_constant_id_list_t *list, size_t capacity);
-
-/**
- * Append a constant id to a list of constant ids. Returns false if any
- * potential reallocations fail.
- *
- * @param list The list to append to.
- * @param id The id to append.
- * @return Whether the append succeeded.
- */
-bool rbs_constant_id_list_append(rbs_constant_id_list_t *list, rbs_constant_id_t id);
-
-/**
- * Insert a constant id into a list of constant ids at the specified index.
- *
- * @param list The list to insert into.
- * @param index The index at which to insert.
- * @param id The id to insert.
- */
-void rbs_constant_id_list_insert(rbs_constant_id_list_t *list, size_t index, rbs_constant_id_t id);
-
-/**
- * Checks if the current constant id list includes the given constant id.
- *
- * @param list The list to check.
- * @param id The id to check for.
- * @return Whether the list includes the given id.
- */
-bool rbs_constant_id_list_includes(rbs_constant_id_list_t *list, rbs_constant_id_t id);
-
-/**
- * Free the memory associated with a list of constant ids.
- *
- * @param list The list to free.
- */
-void rbs_constant_id_list_free(rbs_constant_id_list_t *list);
-
 /**
  * The type of bucket in the constant pool hash map. This determines how the
  * bucket should be freed.
@@ -110,10 +48,10 @@ static const rbs_constant_pool_bucket_type_t RBS_CONSTANT_POOL_BUCKET_CONSTANT =
 /** A bucket in the hash map. */
 typedef struct {
     /** The incremental ID used for indexing back into the pool. */
-    unsigned int id: 30;
+    unsigned int id : 30;
 
     /** The type of the bucket, which determines how to free it. */
-    rbs_constant_pool_bucket_type_t type: 2;
+    rbs_constant_pool_bucket_type_t type : 2;
 
     /** The hash of the bucket. */
     uint32_t hash;
@@ -143,9 +81,6 @@ typedef struct {
     uint32_t capacity;
 } rbs_constant_pool_t;
 
-// A global constant pool for storing permenant keywords, such as the names of location children in `parser.c`.
-extern rbs_constant_pool_t *RBS_GLOBAL_CONSTANT_POOL;
-
 /**
  * Initialize a new constant pool with a given capacity.
  *
@@ -162,7 +97,7 @@ bool rbs_constant_pool_init(rbs_constant_pool_t *pool, uint32_t capacity);
  * @param constant_id The id of the constant to get.
  * @return A pointer to the constant.
  */
-rbs_constant_t * rbs_constant_pool_id_to_constant(const rbs_constant_pool_t *pool, rbs_constant_id_t constant_id);
+rbs_constant_t *rbs_constant_pool_id_to_constant(const rbs_constant_pool_t *pool, rbs_constant_id_t constant_id);
 
 /**
  * Find a constant in a constant pool. Returns the id of the constant, or 0 if
@@ -185,6 +120,7 @@ rbs_constant_id_t rbs_constant_pool_find(const rbs_constant_pool_t *pool, const
  * @return The id of the constant.
  */
 rbs_constant_id_t rbs_constant_pool_insert_shared(rbs_constant_pool_t *pool, const uint8_t *start, size_t length);
+rbs_constant_id_t rbs_constant_pool_insert_shared_with_encoding(rbs_constant_pool_t *pool, const uint8_t *start, size_t length, const rbs_encoding_t *encoding);
 
 /**
  * Insert a constant into a constant pool from memory that is now owned by the

data/include/rbs/util/rbs_encoding.h

@@ -0,0 +1,282 @@
+/**
+ * @file encoding.h
+ *
+ * The encoding interface and implementations used by the parser.
+ */
+#ifndef RBS_RBS_ENCODING_H
+#define RBS_RBS_ENCODING_H
+
+#include "rbs/defines.h"
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+/**
+ * This struct defines the functions necessary to implement the encoding
+ * interface so we can determine how many bytes the subsequent character takes.
+ * Each callback should return the number of bytes, or 0 if the next bytes are
+ * invalid for the encoding and type.
+ */
+typedef struct {
+    /**
+     * Return the number of bytes that the next character takes if it is valid
+     * in the encoding. Does not read more than n bytes. It is assumed that n is
+     * at least 1.
+     */
+    size_t (*char_width)(const uint8_t *b, ptrdiff_t n);
+
+    /**
+     * Return the number of bytes that the next character takes if it is valid
+     * in the encoding and is alphabetical. Does not read more than n bytes. It
+     * is assumed that n is at least 1.
+     */
+    size_t (*alpha_char)(const uint8_t *b, ptrdiff_t n);
+
+    /**
+     * Return the number of bytes that the next character takes if it is valid
+     * in the encoding and is alphanumeric. Does not read more than n bytes. It
+     * is assumed that n is at least 1.
+     */
+    size_t (*alnum_char)(const uint8_t *b, ptrdiff_t n);
+
+    /**
+     * Return true if the next character is valid in the encoding and is an
+     * uppercase character. Does not read more than n bytes. It is assumed that
+     * n is at least 1.
+     */
+    bool (*isupper_char)(const uint8_t *b, ptrdiff_t n);
+
+    /**
+     * The name of the encoding. This should correspond to a value that can be
+     * passed to Encoding.find in Ruby.
+     */
+    const char *name;
+
+    /**
+     * Return true if the encoding is a multibyte encoding.
+     */
+    bool multibyte;
+} rbs_encoding_t;
+
+/**
+ * All of the lookup tables use the first bit of each embedded byte to indicate
+ * whether the codepoint is alphabetical.
+ */
+#define RBS_ENCODING_ALPHABETIC_BIT 1 << 0
+
+/**
+ * All of the lookup tables use the second bit of each embedded byte to indicate
+ * whether the codepoint is alphanumeric.
+ */
+#define RBS_ENCODING_ALPHANUMERIC_BIT 1 << 1
+
+/**
+ * All of the lookup tables use the third bit of each embedded byte to indicate
+ * whether the codepoint is uppercase.
+ */
+#define RBS_ENCODING_UPPERCASE_BIT 1 << 2
+
+/**
+ * Return the size of the next character in the UTF-8 encoding.
+ *
+ * @param b The bytes to read.
+ * @param n The number of bytes that can be read.
+ * @returns The number of bytes that the next character takes if it is valid in
+ *     the encoding, or 0 if it is not.
+ */
+size_t rbs_encoding_utf_8_char_width(const uint8_t *b, ptrdiff_t n);
+
+/**
+ * Return the size of the next character in the UTF-8 encoding if it is an
+ * alphabetical character.
+ *
+ * @param b The bytes to read.
+ * @param n The number of bytes that can be read.
+ * @returns The number of bytes that the next character takes if it is valid in
+ *     the encoding, or 0 if it is not.
+ */
+size_t rbs_encoding_utf_8_alpha_char(const uint8_t *b, ptrdiff_t n);
+
+/**
+ * Return the size of the next character in the UTF-8 encoding if it is an
+ * alphanumeric character.
+ *
+ * @param b The bytes to read.
+ * @param n The number of bytes that can be read.
+ * @returns The number of bytes that the next character takes if it is valid in
+ *     the encoding, or 0 if it is not.
+ */
+size_t rbs_encoding_utf_8_alnum_char(const uint8_t *b, ptrdiff_t n);
+
+/**
+ * Return true if the next character in the UTF-8 encoding if it is an uppercase
+ * character.
+ *
+ * @param b The bytes to read.
+ * @param n The number of bytes that can be read.
+ * @returns True if the next character is valid in the encoding and is an
+ *     uppercase character, or false if it is not.
+ */
+bool rbs_encoding_utf_8_isupper_char(const uint8_t *b, ptrdiff_t n);
+
+/**
+ * This lookup table is referenced in both the UTF-8 encoding file and the
+ * parser directly in order to speed up the default encoding processing. It is
+ * used to indicate whether a character is alphabetical, alphanumeric, or
+ * uppercase in unicode mappings.
+ */
+extern const uint8_t rbs_encoding_unicode_table[256];
+
+/**
+ * These are all of the encodings that prism supports.
+ */
+typedef enum {
+    RBS_ENCODING_UTF_8 = 0,
+    RBS_ENCODING_US_ASCII,
+    RBS_ENCODING_ASCII_8BIT,
+    RBS_ENCODING_EUC_JP,
+    RBS_ENCODING_WINDOWS_31J,
+
+// We optionally support excluding the full set of encodings to only support the
+// minimum necessary to process Ruby code without encoding comments.
+#ifndef RBS_ENCODING_EXCLUDE_FULL
+    RBS_ENCODING_BIG5,
+    RBS_ENCODING_BIG5_HKSCS,
+    RBS_ENCODING_BIG5_UAO,
+    RBS_ENCODING_CESU_8,
+    RBS_ENCODING_CP51932,
+    RBS_ENCODING_CP850,
+    RBS_ENCODING_CP852,
+    RBS_ENCODING_CP855,
+    RBS_ENCODING_CP949,
+    RBS_ENCODING_CP950,
+    RBS_ENCODING_CP951,
+    RBS_ENCODING_EMACS_MULE,
+    RBS_ENCODING_EUC_JP_MS,
+    RBS_ENCODING_EUC_JIS_2004,
+    RBS_ENCODING_EUC_KR,
+    RBS_ENCODING_EUC_TW,
+    RBS_ENCODING_GB12345,
+    RBS_ENCODING_GB18030,
+    RBS_ENCODING_GB1988,
+    RBS_ENCODING_GB2312,
+    RBS_ENCODING_GBK,
+    RBS_ENCODING_IBM437,
+    RBS_ENCODING_IBM720,
+    RBS_ENCODING_IBM737,
+    RBS_ENCODING_IBM775,
+    RBS_ENCODING_IBM852,
+    RBS_ENCODING_IBM855,
+    RBS_ENCODING_IBM857,
+    RBS_ENCODING_IBM860,
+    RBS_ENCODING_IBM861,
+    RBS_ENCODING_IBM862,
+    RBS_ENCODING_IBM863,
+    RBS_ENCODING_IBM864,
+    RBS_ENCODING_IBM865,
+    RBS_ENCODING_IBM866,
+    RBS_ENCODING_IBM869,
+    RBS_ENCODING_ISO_8859_1,
+    RBS_ENCODING_ISO_8859_2,
+    RBS_ENCODING_ISO_8859_3,
+    RBS_ENCODING_ISO_8859_4,
+    RBS_ENCODING_ISO_8859_5,
+    RBS_ENCODING_ISO_8859_6,
+    RBS_ENCODING_ISO_8859_7,
+    RBS_ENCODING_ISO_8859_8,
+    RBS_ENCODING_ISO_8859_9,
+    RBS_ENCODING_ISO_8859_10,
+    RBS_ENCODING_ISO_8859_11,
+    RBS_ENCODING_ISO_8859_13,
+    RBS_ENCODING_ISO_8859_14,
+    RBS_ENCODING_ISO_8859_15,
+    RBS_ENCODING_ISO_8859_16,
+    RBS_ENCODING_KOI8_R,
+    RBS_ENCODING_KOI8_U,
+    RBS_ENCODING_MAC_CENT_EURO,
+    RBS_ENCODING_MAC_CROATIAN,
+    RBS_ENCODING_MAC_CYRILLIC,
+    RBS_ENCODING_MAC_GREEK,
+    RBS_ENCODING_MAC_ICELAND,
+    RBS_ENCODING_MAC_JAPANESE,
+    RBS_ENCODING_MAC_ROMAN,
+    RBS_ENCODING_MAC_ROMANIA,
+    RBS_ENCODING_MAC_THAI,
+    RBS_ENCODING_MAC_TURKISH,
+    RBS_ENCODING_MAC_UKRAINE,
+    RBS_ENCODING_SHIFT_JIS,
+    RBS_ENCODING_SJIS_DOCOMO,
+    RBS_ENCODING_SJIS_KDDI,
+    RBS_ENCODING_SJIS_SOFTBANK,
+    RBS_ENCODING_STATELESS_ISO_2022_JP,
+    RBS_ENCODING_STATELESS_ISO_2022_JP_KDDI,
+    RBS_ENCODING_TIS_620,
+    RBS_ENCODING_UTF8_MAC,
+    RBS_ENCODING_UTF8_DOCOMO,
+    RBS_ENCODING_UTF8_KDDI,
+    RBS_ENCODING_UTF8_SOFTBANK,
+    RBS_ENCODING_WINDOWS_1250,
+    RBS_ENCODING_WINDOWS_1251,
+    RBS_ENCODING_WINDOWS_1252,
+    RBS_ENCODING_WINDOWS_1253,
+    RBS_ENCODING_WINDOWS_1254,
+    RBS_ENCODING_WINDOWS_1255,
+    RBS_ENCODING_WINDOWS_1256,
+    RBS_ENCODING_WINDOWS_1257,
+    RBS_ENCODING_WINDOWS_1258,
+    RBS_ENCODING_WINDOWS_874,
+#endif
+
+    RBS_ENCODING_MAXIMUM
+} rbs_encoding_type_t;
+
+/**
+ * This is the table of all of the encodings that prism supports.
+ */
+extern const rbs_encoding_t rbs_encodings[RBS_ENCODING_MAXIMUM];
+
+/**
+ * This is the default UTF-8 encoding. We need a reference to it to quickly
+ * create parsers.
+ */
+#define RBS_ENCODING_UTF_8_ENTRY (&rbs_encodings[RBS_ENCODING_UTF_8])
+
+/**
+ * This is the US-ASCII encoding. We need a reference to it to be able to
+ * compare against it when a string is being created because it could possibly
+ * need to fall back to ASCII-8BIT.
+ */
+#define RBS_ENCODING_US_ASCII_ENTRY (&rbs_encodings[RBS_ENCODING_US_ASCII])
+
+/**
+ * This is the ASCII-8BIT encoding. We need a reference to it so that rbs_strpbrk
+ * can compare against it because invalid multibyte characters are not a thing
+ * in this encoding. It is also needed for handling Regexp encoding flags.
+ */
+#define RBS_ENCODING_ASCII_8BIT_ENTRY (&rbs_encodings[RBS_ENCODING_ASCII_8BIT])
+
+/**
+ * This is the EUC-JP encoding. We need a reference to it to quickly process
+ * regular expression modifiers.
+ */
+#define RBS_ENCODING_EUC_JP_ENTRY (&rbs_encodings[RBS_ENCODING_EUC_JP])
+
+/**
+ * This is the Windows-31J encoding. We need a reference to it to quickly
+ * process regular expression modifiers.
+ */
+#define RBS_ENCODING_WINDOWS_31J_ENTRY (&rbs_encodings[RBS_ENCODING_WINDOWS_31J])
+
+/**
+ * Parse the given name of an encoding and return a pointer to the corresponding
+ * encoding struct if one can be found, otherwise return NULL.
+ *
+ * @param start A pointer to the first byte of the name.
+ * @param end A pointer to the last byte of the name.
+ * @returns A pointer to the encoding struct if one is found, otherwise NULL.
+ */
+const rbs_encoding_t *rbs_encoding_find(const uint8_t *start, const uint8_t *end);
+
+#endif

data/include/rbs/util/rbs_unescape.h

@@ -0,0 +1,24 @@
+#ifndef RBS_RBS_UNESCAPE_H
+#define RBS_RBS_UNESCAPE_H
+
+#include <stddef.h>
+#include "rbs/util/rbs_allocator.h"
+#include "rbs/string.h"
+#include "rbs/util/rbs_encoding.h"
+
+/**
+ * Receives `rbs_parser_t` and `range`, which represents a string token or symbol token, and returns a string VALUE.
+ *
+ *    Input token | Output string
+ *    ------------+-------------
+ *    "foo\\n"    | foo\n
+ *    'foo'       | foo
+ *    `bar`       | bar
+ *    :"baz\\t"   | baz\t
+ *    :'baz'      | baz
+ *
+ * @returns A new owned string that will be freed when the allocator is freed.
+ * */
+rbs_string_t rbs_unquote_string(rbs_allocator_t *, const rbs_string_t input, const rbs_encoding_t *encoding);
+
+#endif // RBS_RBS_UNESCAPE_H

data/include/rbs.h

@@ -1,7 +1,14 @@
 #ifndef RBS_H
 #define RBS_H
 
-#include "rbs/constants.h"
-#include "rbs/ruby_objs.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "rbs/parser.h"
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif

data/lib/rbs/annotate/formatter.rb

@@ -59,20 +59,10 @@ module RBS
 
       def self.each_part(doc, &block)
         if block
-          document =
-            case doc
-            when String
-              raise
-            when RDoc::Comment
-              document = doc.parse
-            when RDoc::Markup::Document
-              document = doc
-            end
-
-          if document.file
-            yield document
+          if doc.file
+            yield doc
           else
-            document.each do |d|
+            doc.each do |d|
               each_part(d, &block)
             end
           end

data/lib/rbs/annotate/rdoc_annotator.rb

@@ -13,25 +13,22 @@ module RBS
         @include_filename = true
       end
 
-      def annotate_file(path, preserve:)
-        content = path.read()
+      def annotate_file(path, preserve: true)
+        buffer, _, decls = Parser.parse_signature(path.read())
 
-        _, _, decls = Parser.parse_signature(content)
+        rewriter = Rewriter.new(buffer)
+        annotate_decls(decls, rewriter)
 
-        annotate_decls(decls)
-
-        path.open("w") do |io|
-          Writer.new(out: io).preserve!(preserve: preserve).write(decls)
-        end
+        path.write(rewriter.string)
       end
 
-      def annotate_decls(decls, outer: [])
+      def annotate_decls(decls, rewriter, outer: [])
         decls.each do |decl|
           case decl
           when AST::Declarations::Class, AST::Declarations::Module
-            annotate_class(decl, outer: outer)
+            annotate_class(decl, rewriter, outer: outer)
           when AST::Declarations::Constant
-            annotate_constant(decl, outer: outer)
+            annotate_constant(decl, rewriter, outer: outer)
           end
         end
       end
@@ -39,7 +36,9 @@ module RBS
       def each_part(subjects, tester:)
         if block_given?
           subjects.each do |subject, docs|
-            Formatter.each_part(subject.comment) do |doc|
+            comment = subject.comment
+            raise if comment.is_a?(String)
+            Formatter.each_part(comment.parse) do |doc|
               if tester.test_path(doc.file || raise)
                 yield [doc, subject]
               end
@@ -242,7 +241,7 @@ module RBS
         end
       end
 
-      def annotate_class(decl, outer:)
+      def annotate_class(decl, rewriter, outer:)
         annots = annotations(decl)
 
         full_name = resolve_name(decl.name, outer: outer)
@@ -250,7 +249,7 @@ module RBS
           text = resolve_doc_source(annots.copy_annotation, tester: annots) { doc_for_class(full_name, tester: annots) }
         end
 
-        replace_comment(decl, text)
+        replace_comment(decl, text, rewriter)
 
         unless annots.skip_all?
           outer_ = outer + [decl.name.to_namespace]
@@ -258,28 +257,28 @@ module RBS
           decl.each_member do |member|
             case member
             when AST::Members::MethodDefinition
-              annotate_method(full_name, member)
+              annotate_method(full_name, member, rewriter)
             when AST::Members::Alias
-              annotate_alias(full_name, member)
+              annotate_alias(full_name, member, rewriter)
             when AST::Members::AttrReader, AST::Members::AttrAccessor, AST::Members::AttrWriter
-              annotate_attribute(full_name, member)
+              annotate_attribute(full_name, member, rewriter)
             end
           end
 
-          annotate_decls(decl.each_decl.to_a, outer: outer_)
+          annotate_decls(decl.each_decl.to_a, rewriter, outer: outer_)
         end
       end
 
-      def annotate_constant(const, outer:)
+      def annotate_constant(const, rewriter, outer:)
         annots = Annotations.new([])
 
         full_name = resolve_name(const.name, outer: outer)
         text = doc_for_constant(full_name, tester: annots)
 
-        replace_comment(const, text)
+        replace_comment(const, text, rewriter)
       end
 
-      def annotate_alias(typename, als)
+      def annotate_alias(typename, als, rewriter)
         annots = annotations(als)
 
         unless annots.skip?
@@ -293,7 +292,7 @@ module RBS
           end
         end
 
-        replace_comment(als, text)
+        replace_comment(als, text, rewriter)
       end
 
       def join_docs(docs, separator: "----")
@@ -309,7 +308,7 @@ module RBS
         end
       end
 
-      def annotate_method(typename, method)
+      def annotate_method(typename, method, rewriter)
         annots = annotations(method)
 
         unless annots.skip?
@@ -335,10 +334,10 @@ module RBS
           }
         end
 
-        replace_comment(method, text)
+        replace_comment(method, text, rewriter)
       end
 
-      def annotate_attribute(typename, attr)
+      def annotate_attribute(typename, attr, rewriter)
         annots = annotations(attr)
 
         unless annots.skip?
@@ -366,18 +365,17 @@ module RBS
           end
         end
 
-        replace_comment(attr, text)
+        replace_comment(attr, text, rewriter)
       end
 
-      def replace_comment(commented, string)
+      def replace_comment(commented, string, rewriter)
         if string
           if string.empty?
-            commented.instance_variable_set(:@comment, nil)
+            rewriter.delete_comment(commented.comment) if commented.comment
+          elsif commented.comment
+            rewriter.replace_comment(commented.comment, content: string)
           else
-            commented.instance_variable_set(
-              :@comment,
-              AST::Comment.new(location: nil, string: string)
-            )
+            rewriter.add_comment(commented.location || raise, *commented.annotations.filter_map(&:location), content: string)
           end
         end
       end