rbs-inline-annotator 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b957db6fbd29cfa5e3b4b5613386beeeb3aebf40f7a576e01a95e31fa88267b3
-  data.tar.gz: 7d6a684f4c95daec4926e3f2500d55b294d33b423cda307c1af0276db2400390
+  metadata.gz: d398c9f6b34b3f6ac6d807527341b09c180dde4f3bb75962c6fbc0f36cccd791
+  data.tar.gz: 34af7fd6c55711068669e67924403fd937a1301c4cede7e8e7fee4cf485ed320
 SHA512:
-  metadata.gz: 6bd9cabe241ca29a157fc3bf91cbe962fe182d629d9417c571a98db6117f61f331327bd4d713340272a63d0d228aa467596da3d9a5478c2e24ad09910d46d1ed
-  data.tar.gz: 0a432b269bb9d2ce12618bfa5eb766db14ea987b68135115f7c636c6d4cba2390b04707c1edbac6df96ad2f270e979d9b21c831e2965ac8208d419d46036c0f1
+  metadata.gz: e9096854e21fbc7e4ed5b982a6b7c0969438f475456b8b84256fba394c8114486a0f7a81d908014109e039ba945e02923805677d3d8513352d05404fae45128d
+  data.tar.gz: 61c6fcf5e3a26f81792ea91298e29433ef319482e92349864140bb1a2a22913430b6071ecbc017bd0731dcb633c39d0e992232f87dba5a5148d4da417c48302c

data/README.md

@@ -35,18 +35,16 @@ end
 
 ## Installation
 
-TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
-
 Install the gem and add to the application's Gemfile by executing:
 
 ```bash
-bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+bundle add rbs-inline-annotator
 ```
 
 If bundler is not being used to manage dependencies, install the gem by executing:
 
 ```bash
-gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+gem install rbs-inline-annotator
 ```
 
 ## Usage

data/lib/rbs/inline/annotator/cli.rb

@@ -52,10 +52,10 @@ module RBS::Inline::Annotator
       Spinner.new.tap do |spinner|
         print "\e[?25l" if @options.mode == 'write'
         targets.each do |target|
-          annotated_code = Processor.new(target:, env:).process
+          annotated_code, changed = Processor.new(target:, env:).process
           case @options.mode
           when 'write'
-            File.write(target, annotated_code)
+            File.write(target, annotated_code) if changed
           when 'print-only'
             puts annotated_code
           when 'quiet'

data/lib/rbs/inline/annotator/processor.rb

@@ -17,15 +17,18 @@ module RBS::Inline::Annotator
       @env = env
     end
 
+    # @rbs return: [String, bool] -- [code string, changed flag]
     def process
       absolute_path = Pathname.pwd + target
       source = absolute_path.read
       writer = Writer.new(source)
       result = Result.new(writer:, prism_result: Prism.parse_file(absolute_path.to_s))
       result.prism_result.value.accept(Visitor.new(env:, result:))
-      return if result.writer.actions.empty?
-
-      writer.process
+      if result.writer.actions.empty?
+        [source, false]
+      else
+        [writer.process, true]
+      end
     end
   end
 end

data/lib/rbs/inline/annotator/version.rb

@@ -3,7 +3,7 @@
 module RBS
   module Inline
     module Annotator
-      VERSION = "0.1.0"
+      VERSION = "0.2.0"
     end
   end
 end

data/lib/rbs/inline/annotator/visitor.rb

@@ -26,8 +26,8 @@ module RBS::Inline::Annotator
 
     def node_range(node)
       Range.new(
-        node.location.start_offset,
-        node.location.end_offset,
+        node.location.start_character_offset,
+        node.location.end_character_offset,
       )
     end
 
@@ -49,6 +49,7 @@ module RBS::Inline::Annotator
 
     def visit_class_node(node)
       push_type_name(node) do
+        with_generics(node)
         with_superclass(node.superclass)
         # TODO: Which file should we write to?
         # with_embedding_rbs(header_node(node), node)
@@ -59,6 +60,7 @@ module RBS::Inline::Annotator
 
     def visit_module_node(node)
       push_type_name(node) do
+        with_generics(node)
         with_module_self(node)
         # TODO: Which file should we write to?
         # with_embedding_rbs(header_node(node), node)
@@ -67,6 +69,14 @@ module RBS::Inline::Annotator
       end
     end
 
+    def with_generics(node)
+      entry = module_class_entry or return
+      indent = " " * node.location.start_column
+      entry.primary_decl.type_params.each do |type_param|
+        insert_before(node_range(node), "# @rbs generic #{type_param}\n#{indent}")
+      end
+    end
+
     def header_node(node)
       case node
       when Prism::ClassNode
@@ -252,13 +262,18 @@ module RBS::Inline::Annotator
           new_annotation.call("return", return_type)
         }
         if node.parameters
-          for_positional_params.call(func.required_positionals, node.parameters.requireds)
-          for_positional_params.call(func.optional_positionals, node.parameters.optionals)
-          for_rest_param.call("*", func.rest_positionals, node.parameters.rest) if func.rest_positionals
-          for_positional_params.call(func.trailing_positionals, node.parameters.posts) if func.trailing_positionals
-          for_keyword_params.call(func.required_keywords, node.parameters.keywords.grep(Prism::RequiredKeywordParameterNode))
-          for_keyword_params.call(func.optional_keywords, node.parameters.keywords.grep(Prism::OptionalKeywordParameterNode))
-          for_rest_param.call("**", func.rest_keywords, node.parameters.keyword_rest) if func.rest_keywords
+          case func
+          when RBS::Types::UntypedFunction
+            # do nothing
+          when RBS::Types::Function
+            for_positional_params.call(func.required_positionals, node.parameters.requireds)
+            for_positional_params.call(func.optional_positionals, node.parameters.optionals)
+            for_rest_param.call("*", func.rest_positionals, node.parameters.rest) if func.rest_positionals
+            for_positional_params.call(func.trailing_positionals, node.parameters.posts) if func.trailing_positionals
+            for_keyword_params.call(func.required_keywords, node.parameters.keywords.grep(Prism::RequiredKeywordParameterNode))
+            for_keyword_params.call(func.optional_keywords, node.parameters.keywords.grep(Prism::OptionalKeywordParameterNode))
+            for_rest_param.call("**", func.rest_keywords, node.parameters.keyword_rest) if func.rest_keywords
+          end
         end
         if method_type.block
           name = node.parameters&.block&.name
@@ -297,6 +312,7 @@ module RBS::Inline::Annotator
                           (node.name == :attr_writer && member.is_a?(RBS::AST::Members::AttrWriter)) ||
                           (node.name == :attr_accessor && member.is_a?(RBS::AST::Members::AttrAccessor))
               next unless member.name == value.to_sym
+              next unless member.kind == @kind
 
               type = member.type.to_s
               next if type == "untyped"
@@ -316,6 +332,7 @@ module RBS::Inline::Annotator
                             (node.name == :attr_writer && member.is_a?(RBS::AST::Members::AttrWriter)) ||
                             (node.name == :attr_accessor && member.is_a?(RBS::AST::Members::AttrAccessor))
                 next unless member.name == value.to_sym
+                next unless member.kind == @kind
 
                 indent = replaced_count == 0 ? "" : " " * node.location.start_column
                 insert_before(node_range(node), "#{indent}#{node.name} :#{value} #: #{member.type}\n")
@@ -387,18 +404,61 @@ module RBS::Inline::Annotator
       end
     end
 
+    def visit_constant_path_write_node(node)
+      constant_type_name = RBS::TypeName.parse(node.target.full_name).then do |c|
+        type_name ? type_name + c : c.absolute!
+      end
+      type = constant_type(node, constant_type_name) or return
+      add_rbs_inline_annotation_for_trailing(node:, type:)
+    end
+
     def visit_constant_write_node(node)
+      namespace = type_name ? type_name.to_namespace : RBS::Namespace.root
       constant_type_name = RBS::TypeName.new(
         name: node.name,
-        namespace: type_name.to_namespace
+        namespace:
       )
-      entry = @env.constant_decls[constant_type_name] or return
-      type = entry.decl.type.to_s
-      return if type == "untyped"
-
+      type = constant_type(node, constant_type_name) or return
       add_rbs_inline_annotation_for_trailing(node:, type:)
     end
 
+    def constant_type(node, type_name)
+      entry = @env.constant_entry(type_name) or return
+      case entry
+      when RBS::Environment::ModuleAliasEntry
+        case node.value
+        when Prism::CallNode
+          "module-alias #{entry.decl.old_name}"
+        when Prism::ConstantReadNode, Prism::ConstantPathNode
+          "module-alias"
+        else
+          warn "Unsupported node: #{node.value.class}"
+        end
+      when RBS::Environment::ClassAliasEntry
+        case node.value
+        when Prism::CallNode
+          "class-alias #{entry.decl.old_name}"
+        when Prism::ConstantReadNode, Prism::ConstantPathNode
+          "class-alias"
+        else
+          warn "Unsupported node: #{node.value.class}"
+        end
+      when RBS::Environment::ConstantEntry
+        t = entry.decl.type.to_s
+        if (node.value.is_a?(Prism::IntegerNode) && t == "Integer" ||
+            node.value.is_a?(Prism::FloatNode) && t == "Float" ||
+            node.value.is_a?(Prism::TrueNode) && t == "bool" ||
+            node.value.is_a?(Prism::FalseNode) && t == "bool" ||
+            node.value.is_a?(Prism::StringNode) && t == "String" ||
+            node.value.is_a?(Prism::SymbolNode) && t == ":#{node.value.value}")
+          # The types of constants may be automatically inferred
+          nil
+        else
+          t
+        end
+      end
+    end
+
     def add_rbs_inline_annotation_for_trailing(node:, type:)
       return if type == "untyped"
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rbs-inline-annotator
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - ksss