module Steep
  module AST
    module Annotation
      type t = ReturnType | BlockType | SelfType | InstanceType | ModuleType | BreakType
             | MethodType | VarType | ConstType | IvarType
             | Implements | Dynamic

      type loc = RBS::Location[untyped, untyped]

      module Located
        attr_reader location: loc?

        %a{pure} def line: () -> Integer?
      end

      class Named[T, N]
        attr_reader name: N

        attr_reader type: T

        include Located

        def initialize: (name: N, type: T, ?location: loc?) -> void

        def ==: (untyped other) -> bool
      end

      class Typed
        attr_reader type: Types::t

        def initialize: (type: Types::t, ?location: loc?) -> void

        def ==: (untyped other) -> bool

        include Located
      end

      class ReturnType < Typed
      end

      class BlockType < Typed
      end

      class SelfType < Typed
      end

      class InstanceType < Typed
      end

      class ModuleType < Typed
      end

      class BreakType < Typed
      end

      class MethodType < Named[Interface::MethodType, Symbol]
      end

      class VarType < Named[Types::t, Symbol]
      end

      class ConstType < Named[Types::t, RBS::TypeName]
      end

      class IvarType < Named[Types::t, Symbol]
      end

      class Implements
        class Module
          attr_reader name: RBS::TypeName

          attr_reader args: Array[Symbol]

          def initialize: (name: RBS::TypeName, args: Array[Symbol]) -> void

          def ==: (untyped other) -> bool

          alias eql? ==

          def hash: () -> Integer
        end

        include Located

        attr_reader name: Module

        def initialize: (name: Module, ?location: loc?) -> void

        def ==: (untyped other) -> bool
      end

      class Dynamic
        class Name
          type kind = :instance | :module_instance | :module

          attr_reader kind: kind

          attr_reader name: Symbol

          attr_reader location: loc?

          def initialize: (name: Symbol, kind: kind, ?location: loc?) -> void

          def instance_method?: () -> bool

          def module_method?: () -> bool

          def ==: (untyped other) -> bool
        end

        include Located

        attr_reader names: Array[Name]

        def initialize: (names: Array[Name], ?location: loc?) -> void

        def ==: (untyped other) -> bool
      end
    end
  end
end