rbs-inline 0.4.0 → 0.5.0

data/lib/rbs/inline/writer.rb

@@ -3,25 +3,33 @@
 module RBS
   module Inline
     class Writer
-      attr_reader :output #:: String
-      attr_reader :writer #:: RBS::Writer
+      # @rbs!
+      #   interface _Content
+      #     def <<: (RBS::AST::Declarations::t | RBS::AST::Members::t) -> void
+      #
+      #     def concat: (Array[RBS::AST::Declarations::t | RBS::AST::Members::t]) -> void
+      #   end
+
+      attr_reader :output #: String
+      attr_reader :writer #: RBS::Writer
 
       # @rbs buffer: String
-      def initialize(buffer = +"")
+      def initialize(buffer = +"") #: void
         @output = buffer
         @writer = RBS::Writer.new(out: StringIO.new(buffer))
       end
 
       # @rbs uses: Array[AST::Annotations::Use]
       # @rbs decls: Array[AST::Declarations::t]
-      def self.write(uses, decls)
+      # @rbs rbs_decls: Array[RBS::AST::Declarations::t]
+      def self.write(uses, decls, rbs_decls) #: void
         writer = Writer.new()
-        writer.write(uses, decls)
+        writer.write(uses, decls, rbs_decls)
         writer.output
       end
 
-      # @rbs lines: Array[String]
-      # @rbs returns void
+      # @rbs *lines: String
+      # @rbs return: void
       def header(*lines)
         lines.each do |line|
           writer.out.puts("# " + line)
@@ -31,8 +39,10 @@ module RBS
 
       # @rbs uses: Array[AST::Annotations::Use]
       # @rbs decls: Array[AST::Declarations::t]
-      # @rbs returns void
-      def write(uses, decls)
+      # @rbs rbs_decls: Array[RBS::AST::Declarations::t] --
+      #    Top level `rbs!` declarations
+      # @rbs return: void
+      def write(uses, decls, rbs_decls)
         use_dirs = uses.map do |use|
           RBS::AST::Directives::Use.new(
             clauses: use.clauses,
@@ -40,54 +50,60 @@ module RBS
           )
         end
 
-        rbs = decls.filter_map do |decl|
-          translate_decl(decl)
+        rbs = [] #: Array[RBS::AST::Declarations::t]
+
+        decls.each do |decl|
+          translate_decl(
+            decl,
+            rbs #: Array[RBS::AST::Declarations::t | RBS::AST::Members::t]
+          )
         end
 
-        writer.write(use_dirs + rbs)
+        rbs.concat(rbs_decls)
+
+        writer.write(
+          use_dirs + rbs
+        )
       end
 
       # @rbs decl: AST::Declarations::t
-      # @rbs returns RBS::AST::Declarations::t?
-      def translate_decl(decl)
+      # @rbs rbs: _Content
+      # @rbs return: void
+      def translate_decl(decl, rbs)
         case decl
         when AST::Declarations::ClassDecl
-          translate_class_decl(decl)
+          translate_class_decl(decl, rbs)
         when AST::Declarations::ModuleDecl
-          translate_module_decl(decl)
+          translate_module_decl(decl, rbs)
         when AST::Declarations::ConstantDecl
-          translate_constant_decl(decl)
+          translate_constant_decl(decl, rbs)
+        when AST::Declarations::BlockDecl
+          if decl.module_class_annotation
+            case decl.module_class_annotation
+            when AST::Annotations::ModuleDecl
+              translate_module_block_decl(decl, rbs)
+            when AST::Annotations::ClassDecl
+              translate_class_block_decl(decl, rbs)
+            end
+          end
         end
       end
 
       # @rbs decl: AST::Declarations::ClassDecl
-      # @rbs returns RBS::AST::Declarations::Class?
-      def translate_class_decl(decl)
+      # @rbs rbs: _Content
+      # @rbs return: void
+      def translate_class_decl(decl, rbs)
         return unless decl.class_name
 
         if decl.comments
-          comment = RBS::AST::Comment.new(string: decl.comments.content, location: nil)
+          comment = RBS::AST::Comment.new(string: decl.comments.content(trim: true), location: nil)
         end
 
         members = [] #: Array[RBS::AST::Members::t | RBS::AST::Declarations::t]
 
-        decl.members.each do |member|
-          if member.is_a?(AST::Members::Base)
-            if rbs_member = translate_member(member, decl)
-              members.concat rbs_member
-            end
-          end
+        translate_members(decl.members, nil, members)
 
-          if member.is_a?(AST::Declarations::SingletonClassDecl)
-            members.concat translate_singleton_decl(member)
-          elsif member.is_a?(AST::Declarations::Base)
-            if rbs = translate_decl(member)
-              members << rbs
-            end
-          end
-        end
-
-        RBS::AST::Declarations::Class.new(
+        rbs << RBS::AST::Declarations::Class.new(
           name: decl.class_name,
           type_params: decl.type_params,
           members: members,
@@ -98,36 +114,46 @@ module RBS
         )
       end
 
+      # @rbs members: Array[AST::Declarations::t | AST::Members::t]
+      # @rbs decl: AST::Declarations::SingletonClassDecl?
+      # @rbs rbs: _Content
+      # @rbs return: void
+      def translate_members(members, decl, rbs)
+        members.each do |member|
+          case member
+          when AST::Members::Base
+            translate_member(member, decl, rbs)
+          when AST::Declarations::SingletonClassDecl
+            translate_singleton_decl(member, rbs)
+          when AST::Declarations::BlockDecl
+            if member.module_class_annotation
+              translate_decl(member, rbs)
+            else
+              translate_members(member.members, decl, rbs)
+            end
+          when AST::Declarations::ClassDecl, AST::Declarations::ModuleDecl, AST::Declarations::ConstantDecl
+            translate_decl(member, rbs)
+          end
+        end
+      end
+
       # @rbs decl: AST::Declarations::ModuleDecl
-      # @rbs returns RBS::AST::Declarations::Module?
-      def translate_module_decl(decl)
+      # @rbs rbs: _Content
+      # @rbs return: void
+      def translate_module_decl(decl, rbs)
         return unless decl.module_name
 
         if decl.comments
-          comment = RBS::AST::Comment.new(string: decl.comments.content, location: nil)
+          comment = RBS::AST::Comment.new(string: decl.comments.content(trim: true), location: nil)
         end
 
         members = [] #: Array[RBS::AST::Members::t | RBS::AST::Declarations::t]
 
-        decl.members.each do |member|
-          if member.is_a?(AST::Members::Base)
-            if rbs_member = translate_member(member, decl)
-              members.concat rbs_member
-            end
-          end
-
-          if member.is_a?(AST::Declarations::SingletonClassDecl)
-            members.concat translate_singleton_decl(member)
-          elsif member.is_a?(AST::Declarations::Base)
-            if rbs = translate_decl(member)
-              members << rbs
-            end
-          end
-        end
+        translate_members(decl.members, nil, members)
 
         self_types = decl.module_selfs.map { _1.constraint }.compact
 
-        RBS::AST::Declarations::Module.new(
+        rbs << RBS::AST::Declarations::Module.new(
           name: decl.module_name,
           type_params: decl.type_params,
           members: members,
@@ -139,15 +165,16 @@ module RBS
       end
 
       # @rbs decl: AST::Declarations::ConstantDecl
-      # @rbs returns RBS::AST::Declarations::Constant?
-      def translate_constant_decl(decl)
+      # @rbs rbs: _Content
+      # @rbs return: void
+      def translate_constant_decl(decl, rbs)
         return unless decl.constant_name
 
         if decl.comments
-          comment = RBS::AST::Comment.new(string: decl.comments.content, location: nil)
+          comment = RBS::AST::Comment.new(string: decl.comments.content(trim: true), location: nil)
         end
 
-        RBS::AST::Declarations::Constant.new(
+        rbs << RBS::AST::Declarations::Constant.new(
           name: decl.constant_name,
           type: decl.type,
           comment: comment,
@@ -156,95 +183,87 @@ module RBS
       end
 
       # @rbs decl: AST::Declarations::SingletonClassDecl
-      # @rbs returns Array[RBS::AST::Members::t]
-      def translate_singleton_decl(decl)
-        members = []
-
+      # @rbs rbs: _Content
+      # @rbs return: void
+      def translate_singleton_decl(decl, rbs)
         decl.members.each do |member|
           if member.is_a?(AST::Members::Base)
-            if rbs_member = translate_member(member, decl)
-              members.concat rbs_member
-            end
+            translate_member(member, decl, rbs)
           end
         end
-
-        members
       end
 
       # @rbs member: AST::Members::t
-      # @rbs decl: AST::Declarations::ClassDecl | AST::Declarations::ModuleDecl | AST::Declarations::SingletonClassDecl
-      # @rbs returns Array[RBS::AST::Members::t | RBS::AST::Declarations::t]?
-      def translate_member(member, decl)
+      # @rbs decl: AST::Declarations::SingletonClassDecl? --
+      #   The surrouding singleton class definition
+      # @rbs rbs: _Content
+      # @rbs return void
+      def translate_member(member, decl, rbs)
         case member
         when AST::Members::RubyDef
           if member.comments
-            comment = RBS::AST::Comment.new(string: member.comments.content, location: nil)
+            comment = RBS::AST::Comment.new(string: member.comments.content(trim: true), location: nil)
           end
 
           kind = method_kind(member, decl)
 
           if member.override_annotation
-            return [
-              RBS::AST::Members::MethodDefinition.new(
-                name: member.method_name,
-                kind: kind,
-                overloads: [],
-                annotations: [],
-                location: nil,
-                comment: comment,
-                overloading: true,
-                visibility: member.visibility
-              )
-            ]
-          end
-
-          [
-            RBS::AST::Members::MethodDefinition.new(
+            rbs << RBS::AST::Members::MethodDefinition.new(
               name: member.method_name,
               kind: kind,
-              overloads: member.method_overloads,
-              annotations: member.method_annotations,
+              overloads: [],
+              annotations: [],
               location: nil,
               comment: comment,
-              overloading: false,
+              overloading: true,
               visibility: member.visibility
             )
-          ]
+            return
+          end
+
+          rbs << RBS::AST::Members::MethodDefinition.new(
+            name: member.method_name,
+            kind: kind,
+            overloads: member.method_overloads,
+            annotations: member.method_annotations,
+            location: nil,
+            comment: comment,
+            overloading: member.overloading?,
+            visibility: member.visibility
+          )
         when AST::Members::RubyAlias
           if member.comments
-            comment = RBS::AST::Comment.new(string: member.comments.content, location: nil)
+            comment = RBS::AST::Comment.new(string: member.comments.content(trim: true), location: nil)
           end
 
-          [
-            RBS::AST::Members::Alias.new(
-              new_name: member.new_name,
-              old_name: member.old_name,
-              kind: :instance,
-              annotations: [],
-              location: nil,
-              comment: comment
-            )
-          ]
+          rbs << RBS::AST::Members::Alias.new(
+            new_name: member.new_name,
+            old_name: member.old_name,
+            kind: :instance,
+            annotations: [],
+            location: nil,
+            comment: comment
+          )
         when AST::Members::RubyMixin
-          [member.rbs].compact
+          if m = member.rbs
+            rbs << m
+          end
         when AST::Members::RubyAttr
-          member.rbs
+          if m = member.rbs
+            rbs.concat m
+          end
         when AST::Members::RubyPrivate
-          [
-            RBS::AST::Members::Private.new(location: nil)
-          ]
+          rbs << RBS::AST::Members::Private.new(location: nil)
         when AST::Members::RubyPublic
-          [
-            RBS::AST::Members::Public.new(location: nil)
-          ]
+          rbs << RBS::AST::Members::Public.new(location: nil)
         when AST::Members::RBSIvar
-          [
-            member.rbs
-          ].compact
+          if m = member.rbs
+            rbs << m
+          end
         when AST::Members::RBSEmbedded
           case members = member.members
           when Array
-            members
+            rbs.concat members
           end
         end
       end
@@ -265,10 +284,10 @@ module RBS
       # ```
       #
       # @rbs member: AST::Members::RubyDef
-      # @rbs decl: AST::Declarations::ClassDecl | AST::Declarations::ModuleDecl | AST::Declarations::SingletonClassDecl
-      # @rbs returns RBS::AST::Members::MethodDefinition::kind
+      # @rbs decl: AST::Declarations::SingletonClassDecl?
+      # @rbs return: RBS::AST::Members::MethodDefinition::kind
       def method_kind(member, decl)
-        return :singleton if decl.is_a?(AST::Declarations::SingletonClassDecl)
+        return :singleton if decl
 
         case member.node.receiver
         when Prism::SelfNode
@@ -277,6 +296,64 @@ module RBS
           :instance
         end
       end
+
+      # @rbs block: AST::Declarations::BlockDecl
+      # @rbs rbs: _Content
+      # @rbs return: void
+      def translate_module_block_decl(block, rbs)
+        annotation = block.module_class_annotation
+        annotation.is_a?(AST::Annotations::ModuleDecl) or raise
+
+        return unless annotation.name
+
+        if block.comments
+          comment = RBS::AST::Comment.new(string: block.comments.content(trim: true), location: nil)
+        end
+
+        members = [] #: Array[RBS::AST::Members::t | RBS::AST::Declarations::t]
+
+        translate_members(block.members, nil, members)
+
+        self_types = annotation.self_types
+
+        rbs << RBS::AST::Declarations::Module.new(
+          name: annotation.name,
+          type_params: annotation.type_params,
+          members: members,
+          self_types: self_types,
+          annotations: [],
+          location: nil,
+          comment: comment
+        )
+      end
+
+      # @rbs block: AST::Declarations::BlockDecl
+      # @rbs rbs: _Content
+      # @rbs return: void
+      def translate_class_block_decl(block, rbs)
+        annotation = block.module_class_annotation
+        annotation.is_a?(AST::Annotations::ClassDecl) or raise
+
+        return unless annotation.name
+
+        if block.comments
+          comment = RBS::AST::Comment.new(string: block.comments.content(trim: true), location: nil)
+        end
+
+        members = [] #: Array[RBS::AST::Members::t | RBS::AST::Declarations::t]
+
+        translate_members(block.members, nil, members)
+
+        rbs << RBS::AST::Declarations::Class.new(
+          name: annotation.name,
+          type_params: annotation.type_params,
+          members: members,
+          super_class: annotation.super_class,
+          annotations: [],
+          location: nil,
+          comment: comment
+        )
+      end
     end
   end
 end

data/lib/rbs/inline.rb

@@ -8,6 +8,7 @@ require "strscan"
 require "rbs"
 
 require "rbs/inline/node_utils"
+require "rbs/inline/annotation_parser/tokenizer"
 require "rbs/inline/annotation_parser"
 require "rbs/inline/ast/annotations"
 require "rbs/inline/ast/comment_lines"

data/sig/generated/rbs/inline/annotation_parser/tokenizer.rbs

@@ -0,0 +1,221 @@
+# Generated from lib/rbs/inline/annotation_parser/tokenizer.rb with RBS::Inline
+
+module RBS
+  module Inline
+    class AnnotationParser
+      module Tokens
+        K_RETURN: ::Symbol
+
+        K_INHERITS: ::Symbol
+
+        K_AS: ::Symbol
+
+        K_OVERRIDE: ::Symbol
+
+        K_USE: ::Symbol
+
+        K_MODULE_SELF: ::Symbol
+
+        K_GENERIC: ::Symbol
+
+        K_IN: ::Symbol
+
+        K_OUT: ::Symbol
+
+        K_UNCHECKED: ::Symbol
+
+        K_SELF: ::Symbol
+
+        K_SKIP: ::Symbol
+
+        K_YIELDS: ::Symbol
+
+        K_MODULE: ::Symbol
+
+        K_CLASS: ::Symbol
+
+        K_COLON2: ::Symbol
+
+        K_COLON: ::Symbol
+
+        K_LBRACKET: ::Symbol
+
+        K_RBRACKET: ::Symbol
+
+        K_COMMA: ::Symbol
+
+        K_STAR2: ::Symbol
+
+        K_STAR: ::Symbol
+
+        K_MINUS2: ::Symbol
+
+        K_LT: ::Symbol
+
+        K_DOT3: ::Symbol
+
+        K_DOT: ::Symbol
+
+        K_ARROW: ::Symbol
+
+        K_LBRACE: ::Symbol
+
+        K_LPAREN: ::Symbol
+
+        K_AMP: ::Symbol
+
+        K_QUESTION: ::Symbol
+
+        K_VBAR: ::Symbol
+
+        K_EOF: ::Symbol
+
+        # `@rbs!`
+        K_RBSE: ::Symbol
+
+        # `@rbs`
+        K_RBS: ::Symbol
+
+        T_UIDENT: ::Symbol
+
+        T_IFIDENT: ::Symbol
+
+        T_LVAR: ::Symbol
+
+        # The body of comment string following `--`
+        T_COMMENT: ::Symbol
+
+        # Type/method type source
+        T_SOURCE: ::Symbol
+
+        # Block type source
+        T_BLOCKSTR: ::Symbol
+
+        # `!` local variable
+        T_ELVAR: ::Symbol
+
+        T_ATIDENT: ::Symbol
+
+        T_ANNOTATION: ::Symbol
+
+        T_WHITESPACE: ::Symbol
+      end
+
+      class Tokenizer
+        include Tokens
+
+        KEYWORDS: Hash[String, Symbol]
+
+        KW_RE: ::Regexp
+
+        PUNCTS: Hash[String, Symbol]
+
+        PUNCTS_RE: Regexp
+
+        attr_reader scanner: StringScanner
+
+        # Tokens that comes after the current position
+        #
+        # This is a four tuple of tokens.
+        #
+        # 1. The first array is a trivia tokens before current position
+        # 2. The second token is the first lookahead token after the current position
+        # 3. The third array is a trivia tokens between the first lookahead and the second lookahead
+        # 4. The fourth token is the second lookahead token
+        attr_reader lookahead_tokens: [ Array[token], token?, Array[token], token? ]
+
+        # Token that comes after the current position
+        # @rbs %a{pure}
+        %a{pure}
+        def lookahead1: () -> token?
+
+        # Token that comes after `lookahead1`
+        # @rbs %a{pure}
+        %a{pure}
+        def lookahead2: () -> token?
+
+        # Returns the current char position of the first lookahead token
+        #
+        # ```
+        # __ foo ___ bar baz
+        # ^^                 Trivia tokens before lookahead1
+        #   ^                #current_position
+        #    ^^^             lookahead1
+        #        ^^^         Trivia tokens between lookahead1 and lookahead2
+        #            ^^^     lookahead2
+        #                ^    <= scanner.charpos
+        # ```
+        def current_position: () -> Integer
+
+        def lookaheads: () -> Array[Symbol?]
+
+        # @rbs scanner: StringScanner
+        # @rbs return: void
+        def initialize: (StringScanner scanner) -> void
+
+        # Advances the scanner
+        #
+        # @rbs tree: AST::Tree -- Tree to insert trivia tokens
+        # @rbs eat: bool -- true to add the current lookahead token into the tree
+        # @rbs return: void
+        def advance: (AST::Tree tree, ?eat: bool) -> void
+
+        # @rbs (AST::Tree?) -> String
+        def consume_trivias: (AST::Tree?) -> String
+
+        # Returns true if the scanner cannot consume next token
+        def stuck?: () -> bool
+
+        # Skips characters
+        #
+        # This method ensures the `current_position` will be the given `position`.
+        #
+        # @rbs position: Integer -- The new position
+        # @rbs tree: AST::Tree -- Tree to insert trivia tokens
+        # @rbs return: void
+        def reset: (Integer position, AST::Tree tree) -> void
+
+        def rest: () -> String
+
+        # Consume given token type and inserts the token to the tree or `nil`
+        #
+        # @rbs *types: Symbol
+        # @rbs tree: AST::Tree
+        # @rbs return: void
+        def consume_token: (*Symbol types, tree: AST::Tree) -> void
+
+        # Consume given token type and inserts the token to the tree or raise
+        #
+        # @rbs *types: Symbol
+        # @rbs tree: AST::Tree
+        # @rbs return: void
+        def consume_token!: (*Symbol types, tree: AST::Tree) -> void
+
+        # Test if current token has specified `type`
+        #
+        # @rbs *types: Symbol
+        # @rbs return: bool
+        def type?: (*Symbol types) -> bool
+
+        # Test if lookahead2 token have specified `type`
+        #
+        # @rbs *types: Symbol -- The type of the lookahead2 token
+        # @rbs return: bool
+        def type2?: (*Symbol types) -> bool
+
+        # Ensure current token is one of the specified in types
+        #
+        # @rbs *types: Symbol
+        # @rbs return: void
+        def type!: (*Symbol types) -> void
+
+        # Reset the current_token to incoming comment `--`
+        #
+        # Reset to the end of the input if `--` token cannot be found.
+        #
+        # @rbs return: String -- String that is skipped
+        def skip_to_comment: () -> String
+      end
+    end
+  end
+end