Add ConstantDecl

lib/rbs/inline/annotation_parser.rb

@@ -170,7 +170,7 @@ class Tokenizer
           "*" => :kSTAR,
           "--" => :kMINUS2,
         } #:: Hash[String, Symbol]
-        PUNCTS_RE = Regexp.union(PUNCTS.keys)
+        PUNCTS_RE = Regexp.union(PUNCTS.keys) #:: Regexp
 
         # @rbs scanner: StringScanner
         # @rbs return: void
@@ -643,13 +643,8 @@ def parse_use_clause(tokenizer)
         if tokenizer.type?(:kAS)
           as_tree = AST::Tree.new(:as)
 
-          as_tree << tokenizer.advance(as_tree)
-
-          if tokenizer.type?(:tLVAR, :tIFIDENT, :tUIDENT)
-            as_tree <<tokenizer.advance(as_tree)
-          else
-            as_tree << nil
-          end
+          tokenizer.consume_token!(:kAS, tree: as_tree)
+          tokenizer.consume_token(:tLVAR, :tIFIDENT, :tUIDENT, tree: as_tree)
 
           tree << as_tree
         else

lib/rbs/inline/ast/declarations.rb

@@ -99,6 +99,62 @@ def module_selfs
             end
           end
         end
+
+        class ConstantDecl < Base
+          include ConstantUtil
+
+          attr_reader :node
+          attr_reader :comments
+          attr_reader :assertion
+
+          def initialize(node, comments, assertion)
+            @node = node
+            @comments = comments
+            @assertion = assertion
+          end
+
+          def type
+            if assertion
+              case assertion.type
+              when MethodType, nil
+                # skip
+              else
+                return assertion.type
+              end
+            end
+
+            if literal = literal_type
+              return literal
+            end
+
+            Types::Bases::Any.new(location: nil)
+          end
+
+          def literal_type
+            case node.value
+            when Prism::StringNode, Prism::InterpolatedStringNode
+              BuiltinNames::String.instance_type
+            when Prism::SymbolNode, Prism::InterpolatedSymbolNode
+              BuiltinNames::Symbol.instance_type
+            when Prism::RegularExpressionNode, Prism::InterpolatedRegularExpressionNode
+              BuiltinNames::Regexp.instance_type
+            when Prism::IntegerNode
+              BuiltinNames::Integer.instance_type
+            when Prism::FloatNode
+              BuiltinNames::Float.instance_type
+            when Prism::ArrayNode
+              BuiltinNames::Array.instance_type
+            when Prism::HashNode
+              BuiltinNames::Hash.instance_type
+            when Prism::TrueNode, Prism::FalseNode
+              Types::Bases::Bool.new(location: nil)
+            end
+          end
+
+          def constant_name
+            TypeName.new(name: node.name, namespace: Namespace.empty)
+          end
+        end
       end
     end
   end

lib/rbs/inline/parser.rb

@@ -55,11 +55,13 @@ def push_class_module_decl(decl)
           decls << decl
         end
 
-        surrounding_decls.push(decl)
-        begin
-          yield
-        ensure
-          surrounding_decls.pop()
+        if block_given?
+          surrounding_decls.push(_ = decl)
+          begin
+            yield
+          ensure
+            surrounding_decls.pop()
+          end
         end
       end
 
@@ -224,6 +226,29 @@ def application_annotation(node)
           end #: AST::Annotations::Application?
         end
       end
+
+      def assertion_annotation(node)
+        comment_line, app_comment = comments.find do |_, comment|
+          comment.line_range.begin == node.location.end_line
+        end
+
+        if app_comment && comment_line
+          comments.delete(comment_line)
+          app_comment.annotations.find do |annotation|
+            annotation.is_a?(AST::Annotations::Assertion)
+          end #: AST::Annotations::Assertion?
+        end
+      end
+
+      def visit_constant_write_node(node)
+        return if ignored_node?(node)
+
+        comment = comments.delete(node.location.start_line - 1)
+        assertion = assertion_annotation(node)
+
+        decl = AST::Declarations::ConstantDecl.new(node, comment, assertion)
+        push_class_module_decl(decl)
+      end
     end
   end
 end

lib/rbs/inline/writer.rb

@@ -43,6 +43,8 @@ def translate_decl(decl)
           translate_class_decl(decl)
         when AST::Declarations::ModuleDecl
           translate_module_decl(decl)
+        when AST::Declarations::ConstantDecl
+          translate_constant_decl(decl)
         end
       end
 
@@ -116,6 +118,21 @@ def translate_module_decl(decl)
         )
       end
 
+      def translate_constant_decl(decl)
+        return unless decl.constant_name
+
+        if decl.comments
+          comment = RBS::AST::Comment.new(string: decl.comments.content, location: nil)
+        end
+
+        RBS::AST::Declarations::Constant.new(
+          name: decl.constant_name,
+          type: decl.type,
+          comment: comment,
+          location: nil
+        )
+      end
+
       def translate_member(member)
         case member
         when AST::Members::RubyDef

sig/generated/rbs/inline/annotation_parser.rbs

@@ -54,6 +54,14 @@ module RBS
 
         attr_reader current_token: token?
 
+        KEYWORDS: Hash[String, Symbol]
+
+        KW_RE: ::Regexp
+
+        PUNCTS: Hash[String, Symbol]
+
+        PUNCTS_RE: Regexp
+
         # @rbs scanner: StringScanner
         # @rbs return: void
         def initialize: (StringScanner scanner) -> void

sig/rbs/inline/ast/declarations.rbs

@@ -2,7 +2,7 @@ module RBS
   module Inline
     module AST
       module Declarations
-        type t = ClassDecl | ModuleDecl
+        type t = ClassDecl | ModuleDecl | ConstantDecl
 
         module ConstantUtil
           def type_name: (Prism::Node) -> TypeName?
@@ -46,6 +46,24 @@ module RBS
 
           %a{pure} def module_selfs: () -> Array[Annotations::ModuleSelf]
         end
+
+        class ConstantDecl < Base
+          include ConstantUtil
+
+          attr_reader node: Prism::ConstantWriteNode
+
+          attr_reader comments: AnnotationParser::ParsingResult?
+
+          attr_reader assertion: Annotations::Assertion?
+
+          def initialize: (Prism::ConstantWriteNode, AnnotationParser::ParsingResult?, Annotations::Assertion?) -> void
+
+          %a{pure} def type: () -> Types::t
+
+          %a{pure} def literal_type: () -> Types::t?
+
+          %a{pure} def constant_name: () -> TypeName?
+        end
       end
     end
   end

sig/rbs/inline/parser.rbs

@@ -11,26 +11,29 @@ module RBS
 
       attr_reader decls: Array[AST::Declarations::t]
 
-      attr_reader surrounding_decls: Array[AST::Declarations::t]
+      attr_reader surrounding_decls: Array[AST::Declarations::ModuleDecl | AST::Declarations::ClassDecl]
 
       attr_reader current_visibility: RBS::AST::Members::visibility?
 
       def initialize: () -> void
 
       def self.parse: (ParseResult[ProgramNode]) -> [Array[AST::Annotations::Use], Array[AST::Declarations::t]]?
 
-      def current_class_module_decl: () -> AST::Declarations::t?
+      def current_class_module_decl: () -> (AST::Declarations::ModuleDecl | AST::Declarations::ClassDecl | nil)
 
-      def current_class_module_decl!: () -> AST::Declarations::t
+      def current_class_module_decl!: () -> (AST::Declarations::ModuleDecl | AST::Declarations::ClassDecl)
 
-      def push_class_module_decl: (AST::Declarations::t) { () -> void } -> void
+      def push_class_module_decl: (AST::Declarations::ModuleDecl | AST::Declarations::ClassDecl) { () -> void } -> void
+                                | (AST::Declarations::ConstantDecl) -> void
 
       def ignored_node?: (Node) -> bool
 
       def visit_class_node: (ClassNode node) -> void
 
       def application_annotation: (Node node) -> AST::Annotations::Application?
 
+      def assertion_annotation: (Node node) -> AST::Annotations::Assertion?
+
       def push_visibility: (RBS::AST::Members::visibility | nil) { () -> void } -> void
     end
   end

sig/rbs/inline/writer.rbs

@@ -19,6 +19,8 @@ module RBS
 
       def translate_module_decl: (AST::Declarations::ModuleDecl) -> RBS::AST::Declarations::Module?
 
+      def translate_constant_decl: (AST::Declarations::ConstantDecl) -> RBS::AST::Declarations::Constant?
+
       def translate_member: (AST::Members::t) -> Array[RBS::AST::Members::t]?
     end
   end

test/rbs/inline/writer_test.rb

@@ -366,4 +366,25 @@ def foo: () -> untyped
       end
     RBS
   end
+
+  def test_constant_decl
+    output = translate(<<~RUBY)
+      VERSION = "hogehoge"
+
+      SIZE = [123] #:: Array[Integer]
+
+      NAMES = __dir__
+
+      # @rbs skip
+      SKIP = 123
+    RUBY
+
+    assert_equal <<~RBS, output
+      VERSION: ::String
+
+      SIZE: Array[Integer]
+
+      NAMES: untyped
+    RBS
+  end
 end