steep-relaxed 1.9.3.3

data/lib/steep/ast/annotation/collection.rb

@@ -0,0 +1,172 @@
+module Steep
+  module AST
+    module Annotation
+      class Collection
+        attr_reader :annotations
+        attr_reader :factory
+        attr_reader :context
+
+        attr_reader :var_type_annotations
+        attr_reader :const_type_annotations
+        attr_reader :ivar_type_annotations
+        attr_reader :method_type_annotations
+        attr_reader :block_type_annotation
+        attr_reader :return_type_annotation
+        attr_reader :self_type_annotation
+        attr_reader :instance_type_annotation
+        attr_reader :module_type_annotation
+        attr_reader :implement_module_annotation
+        attr_reader :dynamic_annotations
+        attr_reader :break_type_annotation
+
+        def initialize(annotations:, factory:, context:)
+          @annotations = annotations
+          @factory = factory
+          @context = context
+
+          @var_type_annotations = {}
+          @method_type_annotations = {}
+          @const_type_annotations = {}
+          @ivar_type_annotations = {}
+          @dynamic_annotations = []
+
+          annotations.each do |annotation|
+            case annotation
+            when VarType
+              var_type_annotations[annotation.name] = annotation
+            when MethodType
+              method_type_annotations[annotation.name] = annotation
+            when BlockType
+              @block_type_annotation = annotation
+            when ReturnType
+              @return_type_annotation = annotation
+            when SelfType
+              @self_type_annotation = annotation
+            when ConstType
+              @const_type_annotations[annotation.name] = annotation
+            when InstanceType
+              @instance_type_annotation = annotation
+            when ModuleType
+              @module_type_annotation = annotation
+            when Implements
+              @implement_module_annotation = annotation
+            when IvarType
+              @ivar_type_annotations[annotation.name] = annotation
+            when Dynamic
+              @dynamic_annotations << annotation
+            when BreakType
+              @break_type_annotation = annotation
+            else
+              raise "Unexpected annotation: #{annotation.inspect}"
+            end
+          end
+        end
+
+        def absolute_type(type)
+          if type
+            factory.absolute_type(type, context: context)
+          end
+        end
+
+        def var_type(lvar: nil, ivar: nil, const: nil)
+          case
+          when lvar
+            absolute_type(var_type_annotations[lvar]&.type)
+          when ivar
+            absolute_type(ivar_type_annotations[ivar]&.type)
+          when const
+            absolute_type(const_type_annotations[const]&.type)
+          end
+        end
+
+        def method_type(name)
+          if (a = method_type_annotations[name])
+            a.type.map_type {|type| absolute_type(type) }
+          end
+        end
+
+        def block_type
+          absolute_type(block_type_annotation&.type)
+        end
+
+        def return_type
+          absolute_type(return_type_annotation&.type)
+        end
+
+        def self_type
+          absolute_type(self_type_annotation&.type)
+        end
+
+        def instance_type
+          absolute_type(instance_type_annotation&.type)
+        end
+
+        def module_type
+          absolute_type(module_type_annotation&.type)
+        end
+
+        def break_type
+          absolute_type(break_type_annotation&.type)
+        end
+
+        def lvar_types
+          var_type_annotations.each_key.with_object({}) do |name, hash| #$ Hash[Symbol, Types::t]
+            hash[name] = var_type(lvar: name) || raise
+          end
+        end
+
+        def ivar_types
+          ivar_type_annotations.each_key.with_object({}) do |name, hash| #$ Hash[Symbol, Types::t]
+            hash[name] = var_type(ivar: name) || raise
+          end
+        end
+
+        def const_types
+          const_type_annotations.each_key.with_object({}) do |name, hash| #$ Hash[RBS::TypeName, Types::t]
+            hash[name] = var_type(const: name) || raise
+          end
+        end
+
+        def instance_dynamics
+          dynamic_annotations.flat_map do |annot|
+            annot.names.select(&:instance_method?).map(&:name)
+          end
+        end
+
+        def module_dynamics
+          dynamic_annotations.flat_map do |annot|
+            annot.names.select(&:module_method?).map(&:name)
+          end
+        end
+
+        def merge_block_annotations(annotations)
+          if annotations.context != context || annotations.factory != factory
+            raise "Cannot merge another annotation: self=#{self}, other=#{annotations}"
+          end
+
+          retained_annotations = self.annotations.reject do |annotation|
+            annotation.is_a?(BlockType) || annotation.is_a?(BreakType)
+          end
+
+          self.class.new(
+            annotations: retained_annotations + annotations.annotations,
+            factory: factory,
+            context: context
+          )
+        end
+
+        def any?(&block)
+          annotations.any?(&block)
+        end
+
+        def size
+          annotations.size
+        end
+
+        def include?(obj)
+          annotations.include?(obj)
+        end
+      end
+    end
+  end
+end

data/lib/steep/ast/annotation.rb

@@ -0,0 +1,137 @@
+module Steep
+  module AST
+    module Annotation
+      module Located
+        attr_reader :location
+
+        def line
+          location&.start_line
+        end
+      end
+
+      class Named
+        include Located
+
+        attr_reader :name
+        attr_reader :type
+
+        def initialize(name:, type:, location: nil)
+          @name = name
+          @type = type
+          @location = location
+        end
+
+        def ==(other)
+          other.is_a?(self.class) &&
+            other.name == name &&
+            other.type == type
+        end
+      end
+
+      class Typed
+        include Located
+
+        attr_reader :type
+
+        def initialize(type:, location: nil)
+          @type = type
+          @location = location
+        end
+
+        def ==(other)
+          other.is_a?(self.class) &&
+            other.type == type
+        end
+      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; end
+      class VarType < Named; end
+      class ConstType < Named; end
+      class IvarType < Named; end
+
+      class Implements
+        class Module
+          attr_reader :name
+          attr_reader :args
+
+          def initialize(name:, args:)
+            @name = name
+            @args = args
+          end
+
+          def ==(other)
+            other.is_a?(Module) && other.name == name && other.args == args
+          end
+
+          alias eql? ==
+
+          def hash
+            self.class.hash ^ name.hash ^ args.hash
+          end
+        end
+
+        include Located
+
+        attr_reader :name
+
+        def initialize(name:, location: nil)
+          @location = location
+          @name = name
+        end
+
+        def ==(other)
+          other.is_a?(Implements) && other.name == name
+        end
+      end
+
+      class Dynamic
+        class Name
+          attr_reader :kind
+          attr_reader :name
+          attr_reader :location
+
+          def initialize(name:, kind:, location: nil)
+            @name = name
+            @kind = kind
+            @location = location
+          end
+
+          def instance_method?
+            kind == :instance || kind == :module_instance
+          end
+
+          def module_method?
+            kind == :module || kind == :module_instance
+          end
+
+          def ==(other)
+            other.is_a?(Name) &&
+              other.name == name &&
+              other.kind == kind
+          end
+        end
+
+        include Located
+
+        attr_reader :names
+
+        def initialize(names:, location: nil)
+          @location = location
+          @names = names
+        end
+
+        def ==(other)
+          other.is_a?(Dynamic) &&
+            other.names == names
+        end
+      end
+    end
+  end
+end

data/lib/steep/ast/builtin.rb

@@ -0,0 +1,104 @@
+module Steep
+  module AST
+    module Builtin
+      class Type
+        attr_reader :module_name
+        attr_reader :arity
+
+        def initialize(module_name, arity: 0)
+          @module_name = RBS::TypeName.parse(module_name)
+          @arity = arity
+        end
+
+        def instance_type(*args, fill_untyped: false)
+          if fill_untyped
+            (arity - args.size).times do
+              args << Builtin.any_type
+            end
+          end
+          arity == args.size or raise "Malformed instance type: name=#{module_name}, args=#{args}"
+
+          Types::Name::Instance.new(name: module_name, args: args)
+        end
+
+        def module_type
+          Types::Name::Singleton.new(name: module_name)
+        end
+
+        def instance_type?(type, args: nil)
+          if type.is_a?(Types::Name::Instance)
+            if args
+              arity == args.size or raise "Malformed instance type: name=#{module_name}, args=#{args}"
+              if type.name == module_name && type.args == args
+                type
+              end
+            else
+              if type.name == module_name && type.args.size == arity
+                type
+              end
+            end
+          end
+        end
+
+        def module_type?(type)
+          if type.is_a?(Types::Name::Singleton)
+            if type.name == module_name
+              type
+            end
+          end
+        end
+      end
+
+      Object = Type.new("::Object")
+      BasicObject = Type.new("::BasicObject")
+      Array = Type.new("::Array", arity: 1)
+      Range = Type.new("::Range", arity: 1)
+      Hash = Type.new("::Hash", arity: 2)
+      Module = Type.new("::Module")
+      Class = Type.new("::Class")
+      Integer = Type.new("::Integer")
+      Float = Type.new("::Float")
+      String = Type.new("::String")
+      Symbol = Type.new("::Symbol")
+      TrueClass = Type.new("::TrueClass")
+      FalseClass = Type.new("::FalseClass")
+      Regexp = Type.new("::Regexp")
+      NilClass = Type.new("::NilClass")
+      Proc = Type.new("::Proc")
+      Kernel = Type.new("::Kernel")
+      Method = Type.new("::Method")
+
+      def self.nil_type
+        AST::Types::Nil.instance
+      end
+
+      def self.any_type
+        AST::Types::Any.instance
+      end
+
+      def self.bool_type
+        AST::Types::Boolean.instance
+      end
+
+      def self.bottom_type
+        AST::Types::Bot.instance
+      end
+
+      def self.top_type
+        AST::Types::Top.instance
+      end
+
+      def self.optional(type)
+        AST::Types::Union.build(types: [type, nil_type])
+      end
+
+      def self.true_type
+        AST::Types::Literal.new(value: true)
+      end
+
+      def self.false_type
+        AST::Types::Literal.new(value: false)
+      end
+    end
+  end
+end

data/lib/steep/ast/ignore.rb

@@ -0,0 +1,148 @@
+module Steep
+  module AST
+    module Ignore
+      class BufferScanner
+        attr_reader :scanner, :location
+
+        def initialize(location)
+          @location = location
+
+          @scanner = StringScanner.new(location.source)
+        end
+
+        def offset
+          @location.start_pos
+        end
+
+        def charpos
+          scanner.charpos + offset
+        end
+
+        def scan(regexp)
+          if matched = scanner.scan(regexp)
+            end_pos = charpos()
+            begin_pos = end_pos - matched.size
+            RBS::Location.new(location.buffer, begin_pos, end_pos)
+          end
+        end
+
+        def skip(regexp)
+          scanner.skip(regexp)
+        end
+
+        def eos?
+          scanner.eos?
+        end
+      end
+
+      class IgnoreStart
+        attr_reader :comment, :location
+
+        def initialize(comment, location)
+          @comment = comment
+          @location = location
+        end
+
+        def line
+          location.start_line
+        end
+      end
+
+      class IgnoreEnd
+        attr_reader :comment, :location
+
+        def initialize(comment, location)
+          @comment = comment
+          @location = location
+        end
+
+        def line
+          location.start_line
+        end
+      end
+
+      class IgnoreLine
+        attr_reader :comment, :location, :raw_diagnostics
+
+        def initialize(comment, diagnostics, location)
+          @comment = comment
+          @raw_diagnostics = diagnostics
+          @location = location
+        end
+
+        def line
+          location.start_line
+        end
+
+        def ignored_diagnostics
+          if raw_diagnostics.empty?
+            return :all
+          end
+
+          if raw_diagnostics.size == 1 && raw_diagnostics.fetch(0).source == "all"
+            return :all
+          end
+
+          raw_diagnostics.map do |diagnostic|
+            name = diagnostic[:name].source
+            name.gsub(/\ARuby::/, "")
+          end
+        end
+      end
+
+      def self.parse(comment, buffer)
+        return unless comment.inline?
+
+        comment_location = RBS::Location.new(buffer, comment.loc.expression.begin_pos, comment.loc.expression.end_pos)
+        scanner = BufferScanner.new(comment_location)
+
+        scanner.scan(/#/)
+        scanner.skip(/\s*/)
+
+        begin_pos = comment.location.expression.begin_pos
+        end_pos = comment.location.expression.end_pos
+
+        case
+        when loc = scanner.scan(/steep:ignore:start\b/)
+          scanner.skip(/\s*/)
+          return unless scanner.eos?
+
+          IgnoreStart.new(comment, loc)
+        when loc = scanner.scan(/steep:ignore:end\b/)
+          scanner.skip(/\s*/)
+          return unless scanner.eos?
+
+          IgnoreEnd.new(comment, loc)
+        when keyword_loc = scanner.scan(/steep:ignore\b/)
+          # @type var diagnostics: IgnoreLine::diagnostics
+          diagnostics = []
+
+          scanner.skip(/\s*/)
+
+          while true
+            name = scanner.scan(/[A-Z]\w*/) or break
+            scanner.skip(/\s*/)
+            comma = scanner.scan(/,/)
+            scanner.skip(/\s*/)
+
+            diagnostic = RBS::Location.new(buffer, name.start_pos, comma&.end_pos || name.end_pos) #: IgnoreLine::diagnostic
+            diagnostic.add_required_child(:name, name.range)
+            diagnostic.add_optional_child(:following_comma, comma&.range)
+            diagnostics << diagnostic
+
+            break unless comma
+          end
+
+          return unless scanner.eos?
+
+          loc = RBS::Location.new(
+            buffer,
+            keyword_loc.start_pos,
+            diagnostics.last&.end_pos || keyword_loc.end_pos
+          )
+          IgnoreLine.new(comment, diagnostics, loc)
+        end
+      end
+    end
+  end
+end

data/lib/steep/ast/node/type_application.rb

@@ -0,0 +1,88 @@
+module Steep
+  module AST
+    module Node
+      class TypeApplication
+        attr_reader :location
+
+        def initialize(location)
+          @location = location
+        end
+
+        def node
+          @node || raise
+        end
+
+        def set_node(node)
+          @node = node
+        end
+
+        def line
+          location.start_line
+        end
+
+        def source
+          location.source
+        end
+
+        def types(context, subtyping, type_vars)
+          resolver = RBS::Resolver::TypeNameResolver.new(subtyping.factory.env)
+
+          # @type var types: Array[LocatedValue[Types::t]]
+          types = []
+
+          loc = type_location
+
+          while true
+            rbs_ty = RBS::Parser.parse_type(loc.buffer, range: loc.range, variables: type_vars) or break
+            rbs_loc = rbs_ty.location or raise
+            ty = rbs_ty.map_type_name {|name| resolver.resolve(name, context: context) || name.absolute! }
+
+            validator = Signature::Validator.new(checker: subtyping)
+            validator.rescue_validation_errors do
+              validator.validate_type(ty)
+            end
+
+            if validator.has_error?
+              return validator.each_error
+            end
+
+            ty = subtyping.factory.type(ty)
+            types << LocatedValue.new(value: ty, location: rbs_loc)
+
+            match = RBS::Location.new(loc.buffer, rbs_loc.end_pos, type_location.end_pos).source.match(/\A\s*,\s*/) or break
+            offset = match.length
+            loc = RBS::Location.new(loc.buffer, rbs_loc.end_pos + offset, type_location.end_pos)
+          end
+
+          types
+        rescue ::RBS::ParsingError => exn
+          exn
+        end
+
+        def types?(context, subtyping, type_vars)
+          case types = types(context, subtyping, type_vars)
+          when RBS::ParsingError, Enumerator
+            nil
+          else
+            types
+          end
+        end
+
+        def type_str
+          @type_str ||= source.delete_prefix("$").lstrip
+        end
+
+        def type_location
+          offset = source.size - type_str.size
+          RBS::Location.new(location.buffer, location.start_pos + offset, location.end_pos)
+        end
+
+        def self.parse(location)
+          if location.source =~/\A\$\s*(.+)/
+            TypeApplication.new(location)
+          end
+        end
+      end
+    end
+  end
+end