rbs-inline 0.3.0 → 0.5.0

data/lib/rbs/inline/ast/annotations.rb

@@ -4,13 +4,116 @@ module RBS
   module Inline
     module AST
       module Annotations
+        # @rbs!
+        #   type t = VarType
+        #          | ReturnType
+        #          | Use
+        #          | Inherits
+        #          | Generic
+        #          | ModuleSelf
+        #          | Skip
+        #          | MethodTypeAssertion | TypeAssertion | SyntaxErrorAssertion | Dot3Assertion
+        #          | Application
+        #          | RBSAnnotation
+        #          | Override
+        #          | IvarType
+        #          | Embedded
+        #          | Method
+        #          | SplatParamType
+        #          | DoubleSplatParamType
+        #          | BlockType
+        #          | ModuleDecl
+        #          | ClassDecl
+        #        #  | Def
+        #        #  | AttrReader | AttrWriter | AttrAccessor
+        #        #  | Include | Extend | Prepend
+        #        #  | Alias
+
+        module Utils
+          # @rbs (Tree) -> RBS::AST::TypeParam?
+          def translate_type_param(tree)
+            unchecked = tree.nth_token?(0) != nil
+            inout =
+              case tree.nth_token?(1)&.[](0)
+              when nil
+                :invariant
+              when :kIN
+                :contravariant
+              when :kOUT
+                :covariant
+              end #: RBS::AST::TypeParam::variance
+
+            name = tree.nth_token?(2)&.last
+
+            if bound = tree.nth_tree?(3)
+              if type = bound.nth_type?(1)
+                case type
+                when Types::ClassSingleton, Types::ClassInstance, Types::Interface
+                  upper_bound = type
+                end
+              end
+            end
+
+            if name
+              RBS::AST::TypeParam.new(
+                name: name.to_sym,
+                variance: inout,
+                upper_bound: upper_bound,
+                location: nil
+              ).unchecked!(unchecked)
+            end
+          end
+
+          # @rbs (Types::t) -> RBS::AST::Declarations::Class::Super?
+          def translate_super_class(type)
+            case type
+            when Types::ClassInstance
+              RBS::AST::Declarations::Class::Super.new(
+                name: type.name,
+                args: type.args,
+                location: nil
+              )
+            end
+          end
+
+          # Assumes the tree is generated through `#parse_module_name`
+          #
+          # Returns a type name, or `nil` if the tree is something invalid.
+          #
+          # @param tree -- A tree object that is generated through `#parse_module_name`
+          #
+          # @rbs (AST::Tree) -> TypeName?
+          def translate_type_name(tree)
+            tokens = tree.non_trivia_trees
+
+            absolute = tokens.shift
+            path = [] #: Array[Symbol]
+
+            tokens.each_slice(2) do |name, colon2|
+              if colon2
+                name or return nil
+                name.is_a?(Array) or return nil
+
+                path << name[1].to_sym
+              end
+            end
+
+            last_token = tokens.pop
+            last_token.is_a?(Array) or return nil
+            name = last_token[1].to_sym
+
+            namespace = Namespace.new(path: path, absolute: absolute ? true : false)
+            TypeName.new(namespace: namespace, name: name)
+          end
+        end
+
         class Base
-          attr_reader :source #:: CommentLines
-          attr_reader :tree #:: Tree
+          attr_reader :source #: CommentLines
+          attr_reader :tree #: Tree
 
           # @rbs tree: Tree
           # @rbs source: CommentLines
-          # @rbs returns void
+          # @rbs return: void
           def initialize(tree, source)
             @tree = tree
             @source = source
@@ -18,11 +121,11 @@ module RBS
         end
 
         class VarType < Base
-          attr_reader :name #:: Symbol
+          attr_reader :name #: Symbol
 
-          attr_reader :type #:: Types::t?
+          attr_reader :type #: Types::t?
 
-          attr_reader :comment #:: String?
+          attr_reader :comment #: String?
 
           # @rbs override
           def initialize(tree, source)
@@ -44,7 +147,7 @@ module RBS
             end
           end
 
-          #:: () -> bool
+          #: () -> bool
           def complete?
             if name && type
               true
@@ -54,11 +157,100 @@ module RBS
           end
         end
 
-        # `@rbs returns T`
+        class SpecialVarTypeAnnotation < Base
+          attr_reader :name #: Symbol?
+
+          attr_reader :type #: Types::t?
+
+          attr_reader :comment #: String?
+
+          attr_reader :type_source #: String
+
+          # @rbs override
+          def initialize(tree, source)
+            @tree = tree
+            @source = source
+
+            annotation = tree.nth_tree!(1)
+
+            if name = annotation.nth_token?(1)
+              @name = name[1].to_sym
+            end
+
+            if type = annotation.nth_type?(3)
+              @type = type
+              @type_source = type.location&.source || raise
+            else
+              @type = nil
+              @type_source = annotation.nth_tree!(3)&.to_s || raise
+            end
+
+            if comment = annotation.nth_tree(4)
+              @comment = comment.to_s
+            end
+          end
+        end
+
+        # `@rbs *x: T`
+        class SplatParamType < SpecialVarTypeAnnotation
+        end
+
+        # `@rbs` **x: T
+        class DoubleSplatParamType < SpecialVarTypeAnnotation
+        end
+
+        # `@rbs &block: METHOD-TYPE` or `@rbs &block: ? METHOD-TYPE`
+        class BlockType < Base
+          attr_reader :name #: Symbol?
+
+          attr_reader :type #: Types::Block?
+
+          attr_reader :comment #: String?
+
+          attr_reader :type_source #: String
+
+          # @rbs override
+          def initialize(tree, source)
+            @tree = tree
+            @source = source
+
+            annotation = tree.nth_tree!(1)
+
+            if name = annotation.nth_token?(1)
+              @name = name[1].to_sym
+            end
+
+            optional = annotation.nth_token?(3)
+
+            if type_token = annotation.nth_token?(4)
+              block_src = type_token[1]
+
+              proc_type = ::RBS::Parser.parse_type("^" + block_src, require_eof: true) rescue RBS::ParsingError
+              if proc_type.is_a?(Types::Proc)
+                @type = Types::Block.new(
+                  type: proc_type.type,
+                  required: !optional,
+                  self_type: proc_type.self_type
+                )
+              end
+
+              @type_source = block_src
+            else
+              @type = nil
+              @type_source = ""
+            end
+
+            if comment = annotation.nth_tree(5)
+              @comment = comment.to_s
+            end
+          end
+        end
+
+        # `@rbs return: T`
         class ReturnType < Base
-          attr_reader :type #:: Types::t?
+          attr_reader :type #: Types::t?
 
-          attr_reader :comment #:: String?
+          attr_reader :comment #: String?
 
           # @rbs override
           def initialize(tree, source)
@@ -67,16 +259,16 @@ module RBS
 
             return_type_decl = tree.nth_tree!(1)
 
-            if type = return_type_decl.nth_type?(1)
+            if type = return_type_decl.nth_type?(2)
               @type = type
             end
 
-            if comment = return_type_decl.nth_tree(2)
+            if comment = return_type_decl.nth_tree(3)
               @comment = comment.to_s
             end
           end
 
-          # @rbs returns bool
+          # @rbs return: bool
           def complete?
             if type
               true
@@ -89,13 +281,13 @@ module RBS
         # `@rbs @foo: T` or `@rbs self.@foo: T`
         #
         class IvarType < Base
-          attr_reader :name #:: Symbol
+          attr_reader :name #: Symbol
 
-          attr_reader :type #:: Types::t?
+          attr_reader :type #: Types::t?
 
-          attr_reader :class_instance #:: bool
+          attr_reader :class_instance #: bool
 
-          attr_reader :comment #:: String?
+          attr_reader :comment #: String?
 
           # @rbs override
           def initialize(tree, source)
@@ -113,54 +305,62 @@ module RBS
           end
         end
 
-        # `#:: TYPE`
-        #
-        class Assertion < Base
-          attr_reader :type #:: Types::t | MethodType | nil
+        class MethodTypeAssertion < Base
+          attr_reader :method_type #: MethodType
 
+          # @rbs override
           def initialize(tree, source)
             @source = source
             @tree = tree
 
-            @type = tree.nth_method_type?(1) || tree.nth_type?(1)
+            @method_type = tree.nth_method_type!(1)
           end
 
-          # @rbs returns bool
-          def complete?
-            if type
-              true
-            else
-              false
-            end
+          def type_source #: String
+            method_type.location&.source || raise
           end
+        end
 
-          # Returns a type if it's type
-          #
-          def type? #:: Types::t?
-            case type
-            when MethodType, nil
-              nil
-            else
-              type
-            end
+        class TypeAssertion < Base
+          attr_reader :type #: Types::t
+
+          # @rbs override
+          def initialize(tree, source)
+            @source = source
+            @tree = tree
+
+            @type = tree.nth_type!(1)
           end
 
-          # Returns a method type if it's a method type
-          #
-          def method_type? #:: MethodType?
-            case type
-            when MethodType
-              type
-            else
-              nil
-            end
+          def type_source #: String
+            type.location&.source || raise
+          end
+        end
+
+        class SyntaxErrorAssertion < Base
+          attr_reader :error_string #: String
+
+          # @rbs override
+          def initialize(tree, source)
+            @tree = tree
+            @source = source
+
+            @error_string = tree.nth_tree(1).to_s
+          end
+        end
+
+        class Dot3Assertion < Base
+          # @rbs override
+          def initialize(tree, source)
+            @tree = tree
+            @source = source
           end
         end
 
         # `#[TYPE, ..., TYPE]`
         #
         class Application < Base
-          attr_reader :types #:: Array[Types::t]?
+          attr_reader :types #: Array[Types::t]?
 
           # @rbs override
           def initialize(tree, source)
@@ -183,63 +383,15 @@ module RBS
             end
           end
 
-          # @rbs returns bool
+          # @rbs return: bool
           def complete?
             types ? true : false
           end
         end
 
-        # `# @rbs yields () -> void -- Comment`
-        #
-        class Yields < Base
-          # The type of block
-          #
-          # * Types::Block when syntactically correct input is given
-          # * String when syntax error is reported
-          # * `nil` when nothing is given
-          #
-          attr_reader :block_type #:: Types::Block | String | nil
-
-          # The content of the comment or `nil`
-          #
-          attr_reader :comment #:: String?
-
-          # If `[optional]` token is inserted just after `yields` token
-          #
-          # The Types::Block instance has correct `required` attribute based on the `[optional]` token.
-          # This is for the other cases, syntax error or omitted.
-          #
-          attr_reader :optional #:: bool
-
-          # @rbs override
-          def initialize(tree, comments)
-            @tree = tree
-            @source = comments
-
-            yields_tree = tree.nth_tree!(1)
-            @optional = yields_tree.nth_token?(1).is_a?(Array)
-            if block_token = yields_tree.nth_token(2)
-              block_src = block_token[1]
-              proc_src = "^" + block_src
-              proc_type = ::RBS::Parser.parse_type(proc_src, require_eof: true) rescue RBS::ParsingError
-              if proc_type.is_a?(Types::Proc)
-                @block_type = Types::Block.new(
-                  type: proc_type.type,
-                  required: !optional,
-                  self_type: proc_type.self_type
-                )
-              else
-                @block_type = block_src
-              end
-            end
-
-            @comment = yields_tree.nth_tree?(3)&.to_s
-          end
-        end
-
         # `# @rbs %a{a} %a{a} ...`
         class RBSAnnotation < Base
-          attr_reader :contents #:: Array[String]
+          attr_reader :contents #: Array[String]
 
           # @rbs override
           def initialize(tree, comments)
@@ -267,8 +419,8 @@ module RBS
         # `# @rbs inherits T`
         #
         class Inherits < Base
-          attr_reader :super_name #:: TypeName?
-          attr_reader :args #:: Array[Types::t]?
+          attr_reader :super_name #: TypeName?
+          attr_reader :args #: Array[Types::t]?
 
           # @rbs override
           def initialize(tree, source)
@@ -299,7 +451,7 @@ module RBS
 
         # `# @rbs use [USES]`
         class Use < Base
-          attr_reader :clauses #:: Array[RBS::AST::Directives::Use::clause]
+          attr_reader :clauses #: Array[RBS::AST::Directives::Use::clause]
 
           # @rbs override
           def initialize(tree, source)
@@ -351,9 +503,9 @@ module RBS
 
         # `# @rbs module-self [MODULE_SELF]`
         class ModuleSelf < Base
-          attr_reader :constraint #:: RBS::AST::Declarations::Module::Self?
+          attr_reader :constraint #: RBS::AST::Declarations::Module::Self?
 
-          attr_reader :comment #:: String?
+          attr_reader :comment #: String?
 
           # @rbs override
           def initialize(tree, source)
@@ -389,9 +541,11 @@ module RBS
         class Generic < Base
           # TypeParam object or `nil` if syntax error
           #
-          attr_reader :type_param #:: RBS::AST::TypeParam?
+          attr_reader :type_param #: RBS::AST::TypeParam?
+
+          attr_reader :comment #: String?
 
-          attr_reader :comment #:: String?
+          include Utils
 
           # @rbs override
           def initialize(tree, source)
@@ -399,38 +553,10 @@ module RBS
             @source = source
 
             generic_tree = tree.nth_tree!(1)
-            unchecked = generic_tree.nth_token?(1) != nil
-            inout =
-              case generic_tree.nth_token?(2)&.[](0)
-              when nil
-                :invariant
-              when :kIN
-                :contravariant
-              when :kOUT
-                :covariant
-              end #: RBS::AST::TypeParam::variance
-
-            name = generic_tree.nth_token?(3)&.last
 
-            if bound = generic_tree.nth_tree?(4)
-              if type = bound.nth_type?(1)
-                case type
-                when Types::ClassSingleton, Types::ClassInstance, Types::Interface
-                  upper_bound = type
-                end
-              end
-            end
+            @type_param = translate_type_param(generic_tree.nth_tree!(1))
 
-            if name
-              @type_param = RBS::AST::TypeParam.new(
-                name: name.to_sym,
-                variance: inout,
-                upper_bound: upper_bound,
-                location: nil
-              ).unchecked!(unchecked)
-            end
-
-            if comment = generic_tree.nth_tree?(5)
+            if comment = generic_tree.nth_tree?(2)
               @comment = comment.to_s
             end
           end
@@ -438,7 +564,7 @@ module RBS
 
         # `# @rbs!` annotation
         class Embedded < Base
-          attr_reader :content #:: String
+          attr_reader :content #: String
 
           # @rbs override
           def initialize(tree, source)
@@ -448,6 +574,190 @@ module RBS
             @content = tree.nth_token!(1)[1]
           end
         end
+
+        # `@rbs METHOD-TYPE``
+        #
+        class Method < Base
+          # @rbs! type method_type = [MethodType, method_type?] | String
+
+          attr_reader :method_types #: method_type?
+
+          # `true` if the method definition is overloading something
+          #
+          attr_reader :overloading #: bool
+
+          attr_reader :type #: MethodType?
+
+          attr_reader :method_type_source #: String
+
+          # @rbs override
+          def initialize(tree, source)
+            @tree = tree
+            @source = source
+
+            overloads = tree.nth_tree!(1)
+            @method_types = construct_method_types(overloads.non_trivia_trees.dup)
+            @overloading = overloads.token?(:kDOT3, at: -1)
+          end
+
+          #: (Array[tree]) -> method_type?
+          def construct_method_types(children)
+            first = children.shift
+
+            case first
+            when MethodType
+              children.shift
+              [
+                first,
+                construct_method_types(children)
+              ]
+            when Array
+              # `...`
+              nil
+            when AST::Tree
+              # Syntax error
+              first.to_s
+            end
+          end
+
+          # @rbs () { (MethodType) -> void } -> void
+          #    | () -> Enumerator[MethodType, void]
+          def each_method_type
+            if block_given?
+              type = self.method_types
+
+              while true
+                if type.is_a?(Array)
+                  yield type[0]
+                  type = type[1]
+                else
+                  break
+                end
+              end
+            else
+              enum_for :each_method_type
+            end
+          end
+
+          # Returns the parsing error overload string
+          #
+          # Returns `nil` if no parsing error found.
+          #
+          def error_source #: String?
+            type = self.method_types
+
+            while true
+              if type.is_a?(Array)
+                type = type[1]
+              else
+                break
+              end
+            end
+
+            if type.is_a?(String)
+              type
+            end
+          end
+        end
+
+        # `@rbs module Foo`
+        class ModuleDecl < Base
+          attr_reader :name #: TypeName?
+
+          attr_reader :type_params #: Array[RBS::AST::TypeParam]
+
+          attr_reader :self_types #: Array[RBS::AST::Declarations::Module::Self]
+
+          include Utils
+
+          # @rbs override
+          def initialize(tree, comments)
+            @tree = tree
+            @source = comments
+
+            decl_tree = tree.nth_tree!(1)
+
+            if type_name = translate_type_name(decl_tree.nth_tree!(1))
+              if type_name.class?
+                @name = type_name
+              end
+            end
+
+            @type_params = []
+            if type_params = decl_tree.nth_tree(2)
+              params = type_params.non_trivia_trees
+              params.shift
+              params.pop
+              params.each_slice(2) do |param, _comma|
+                raise unless param.is_a?(Tree)
+                if type_param = translate_type_param(param)
+                  @type_params << type_param
+                end
+              end
+            end
+
+            @self_types = []
+            if selfs_tree = decl_tree.nth_tree(3)
+              self_trees = selfs_tree.non_trivia_trees
+              self_trees.shift
+
+              self_trees.each_slice(2) do |type, _comma|
+                case type
+                when Types::ClassInstance, Types::Interface
+                  @self_types << RBS::AST::Declarations::Module::Self.new(
+                    name: type.name,
+                    args: type.args,
+                    location: type.location
+                  )
+                end
+              end
+            end
+          end
+        end
+
+        # `@rbs class Foo`
+        class ClassDecl < Base
+          attr_reader :name #: TypeName?
+
+          attr_reader :type_params #: Array[RBS::AST::TypeParam]
+
+          attr_reader :super_class #: RBS::AST::Declarations::Class::Super?
+
+          include Utils
+
+          # @rbs override
+          def initialize(tree, comments)
+            @tree = tree
+            @source = comments
+
+            decl_tree = tree.nth_tree!(1)
+
+            if type_name = translate_type_name(decl_tree.nth_tree!(1))
+              if type_name.class?
+                @name = type_name
+              end
+            end
+
+            @type_params = []
+            if type_params = decl_tree.nth_tree(2)
+              params = type_params.non_trivia_trees
+              params.shift
+              params.pop
+              params.each_slice(2) do |param, _comma|
+                raise unless param.is_a?(Tree)
+                if type_param = translate_type_param(param)
+                  @type_params << type_param
+                end
+              end
+            end
+
+            if super_tree = decl_tree.nth_tree(3)
+              if type = super_tree.nth_type?(1)
+                @super_class = translate_super_class(type)
+              end
+            end
+          end
+        end
       end
     end
   end