steep-activesupport-4 1.9.3

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

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

@@ -0,0 +1,81 @@
+module Steep
+  module AST
+    module Node
+      class TypeAssertion
+        attr_reader :location
+
+        def initialize(location)
+          @location = location
+        end
+
+        def source
+          location.source
+        end
+
+        def line
+          location.start_line
+        end
+
+        def type(context, subtyping, type_vars)
+          if ty = RBS::Parser.parse_type(type_location.buffer, range: type_location.range, variables: type_vars, require_eof: true)
+            resolver = RBS::Resolver::TypeNameResolver.new(subtyping.factory.env)
+            ty = 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
+
+            unless validator.has_error?
+              subtyping.factory.type(ty)
+            else
+              validator.each_error.to_a
+            end
+          else
+            nil
+          end
+        rescue ::RBS::ParsingError => exn
+          exn
+        end
+
+        def type_syntax?
+          RBS::Parser.parse_type(type_location.buffer, range: type_location.range, variables: [], require_eof: true)
+          true
+        rescue ::RBS::ParsingError
+          false
+        end
+
+        def type?(context, subtyping, type_vars)
+          type = type(context, subtyping, type_vars)
+
+          case type
+          when RBS::ParsingError, nil, Array
+            nil
+          else
+            type
+          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)
+          source = location.source.strip
+
+          if source =~/\A:\s*(.+)/
+            assertion = TypeAssertion.new(location)
+            if assertion.type_syntax?
+              assertion
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/steep/ast/types/any.rb

@@ -0,0 +1,35 @@
+module Steep
+  module AST
+    module Types
+      class Any
+        extend SharedInstance
+
+        def ==(other)
+          other.is_a?(Any)
+        end
+
+        def hash
+          self.class.hash
+        end
+
+        alias eql? ==
+
+        def subst(s)
+          self
+        end
+
+        def to_s
+          "untyped"
+        end
+
+        include Helper::NoFreeVariables
+
+        include Helper::NoChild
+
+        def level
+          [1]
+        end
+      end
+    end
+  end
+end

data/lib/steep/ast/types/boolean.rb

@@ -0,0 +1,45 @@
+module Steep
+  module AST
+    module Types
+      class Boolean
+        extend SharedInstance
+        
+        def ==(other)
+          other.is_a?(Boolean)
+        end
+
+        def hash
+          self.class.hash
+        end
+
+        alias eql? ==
+
+        def subst(s)
+          self
+        end
+
+        def to_s
+          "bool"
+        end
+
+        include Helper::NoFreeVariables
+
+        include Helper::NoChild
+
+        def level
+          [0]
+        end
+
+        def back_type
+          Union.build(
+            types: [
+              Builtin::TrueClass.instance_type,
+              Builtin::FalseClass.instance_type
+            ]
+          )
+        end
+      end
+    end
+  end
+end
+

data/lib/steep/ast/types/bot.rb

@@ -0,0 +1,35 @@
+module Steep
+  module AST
+    module Types
+      class Bot
+        extend SharedInstance
+        
+        def ==(other)
+          other.is_a?(Bot)
+        end
+
+        def hash
+          self.class.hash
+        end
+
+        alias eql? ==
+
+        def subst(s)
+          self
+        end
+
+        def to_s
+          "bot"
+        end
+
+        include Helper::NoFreeVariables
+
+        include Helper::NoChild
+
+        def level
+          [2]
+        end
+      end
+    end
+  end
+end

data/lib/steep/ast/types/class.rb

@@ -0,0 +1,43 @@
+module Steep
+  module AST
+    module Types
+      class Class
+        extend SharedInstance
+
+        def to_s
+          "class"
+        end
+
+        def ==(other)
+          other.is_a?(Class)
+        end
+
+        def hash
+          self.class.hash
+        end
+
+        alias eql? ==
+
+        def subst(s)
+          if s.module_type
+            s.module_type
+          else
+            self
+          end
+        end
+
+        @@fvs = Set[instance]
+
+        def free_variables
+          @@fvs
+        end
+
+        include Helper::NoChild
+
+        def level
+          [0]
+        end
+      end
+    end
+  end
+end