steep 0.14.0 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 86924db409406024edb29a087196304bacba8730dfa3c986c604fbe8b6b9a6fd
-  data.tar.gz: d688f6b2f58343da51328f13bc26da7e4e54de7f1dd9393f0cd98d48c5ea8420
+  metadata.gz: 498c3c95c9c03e8ef047c774aff47158d8681e2ae485d5b0449a74fae33cd06b
+  data.tar.gz: 64e9572dc4ec5b5fea6035c1a1fbb7241a758f76c5d328d2ac0011c37e176044
 SHA512:
-  metadata.gz: a70b109afc79267f2a47425dcc8b93f05074fbffa1e410fa62824b5a94320f18a9274182ad2fbaa4083867dd0bab9e4e8796fc8b472edd2328d2b332e76f9f66
-  data.tar.gz: 6b4dc08b74b0f042b325180f1b358862d510fefe06a9e07f06380bbf7e86f47e3547d365d0cc94a278c80946befec64689a5c56e87a3e820db767103727e69f7
+  metadata.gz: acef7a13109ecd0660d72dff4559b4432f96c62f79aa4dcb762722f9a96678bb6f68f0bd288017381c6ebef65f9648a24f2b349d2af28f1a6f0c66560d56aee6
+  data.tar.gz: 9d31c49a37770c7493cefcde0f608ee6b6c94bd5fa1935c3ce963bae70b3e526b678000ae1b2b9f59d94a775c5103cbabf7effd480262725db476f70e6124dcf

data/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## master
 
+## 0.15.0 (2020-05-05)
+
+* Add type checking configuration to dsl ([#132](https://github.com/soutaro/steep/pull/132))
+* More flow sensitive type checking
+
 ## 0.14.0 (2020-02-24)
 
 * Implementat LSP _completion_. ([#119](https://github.com/soutaro/steep/pull/119))

data/exe/rbs

@@ -1,3 +1,3 @@
 #!/usr/bin/env ruby
 
-load File.join(__dir__, "../vendor/ruby-signature/exe/ruby-signature")
+load File.join(__dir__, "../vendor/ruby-signature/exe/rbs")

data/lib/steep/annotation_parser.rb

@@ -2,7 +2,7 @@ module Steep
   class AnnotationParser
     VAR_NAME = /[a-z][A-Za-z0-9_]*/
     METHOD_NAME = Regexp.union(
-      /[A-Za-z][A-Za-z0-9_]*[?!]?/
+      /[^.:\s]+/
     )
     CONST_NAME = Regexp.union(
       /(::)?([A-Z][A-Za-z0-9_]*::)*[A-Z][A-Za-z0-9_]*/
@@ -34,7 +34,7 @@ module Steep
     TYPE_PARAMS = /(\[(?<params>#{PARAM}(,\s*#{PARAM})*)\])?/
 
     def parse_type(string)
-      factory.type(Ruby::Signature::Parser.parse_type(string))
+      factory.type(RBS::Parser.parse_type(string))
     end
 
     # @type ${keyword} ${name}: ${type}
@@ -68,7 +68,7 @@ module Steep
           name = match[:name]
           type = match[:type]
 
-          method_type = factory.method_type(Ruby::Signature::Parser.parse_method_type(type), self_type: AST::Types::Self.new)
+          method_type = factory.method_type(RBS::Parser.parse_method_type(type), self_type: AST::Types::Self.new)
 
           AST::Annotation::MethodType.new(name: name.to_sym,
                                           type: method_type,
@@ -160,7 +160,7 @@ module Steep
         end
       end
 
-    rescue Ruby::Signature::Parser::SyntaxError, Ruby::Signature::Parser::SemanticsError => exn
+    rescue RBS::Parser::SyntaxError, RBS::Parser::SemanticsError => exn
       raise SyntaxError.new(source: src, location: location, exn: exn)
     end
   end

data/lib/steep/ast/buffer.rb

@@ -10,21 +10,25 @@ module Steep
         @name = name
         @content = content
 
-        @lines = content.lines
+        @lines = content.split(/\n/, -1)
 
         @ranges = []
         offset = 0
-        lines.each do |line|
-          size = line.bytesize
-          range = offset .. (offset+size)
-          ranges << range
-          offset += size
+        lines.each.with_index do |line, index|
+          if index == lines.size - 1
+            ranges << (offset..offset)
+          else
+            size = line.size
+            range = offset..(offset+size)
+            ranges << range
+            offset += size+1
+          end
         end
       end
 
       def pos_to_loc(pos)
         index = ranges.bsearch_index do |range|
-          pos < range.end
+          pos <= range.end
         end
 
         if index

data/lib/steep/ast/builtin.rb

@@ -88,6 +88,14 @@ module Steep
         AST::Types::Boolean.new
       end
 
+      def self.bottom_type
+        AST::Types::Bot.new
+      end
+
+      def self.top_type
+        AST::Types::Top.new
+      end
+
       def self.optional(type)
         AST::Types::Union.build(types: [type, nil_type])
       end

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

@@ -10,56 +10,56 @@ module Steep
 
         def type(type)
           case type
-          when Ruby::Signature::Types::Bases::Any
+          when RBS::Types::Bases::Any
             Any.new(location: nil)
-          when Ruby::Signature::Types::Bases::Class
+          when RBS::Types::Bases::Class
             Class.new(location: nil)
-          when Ruby::Signature::Types::Bases::Instance
+          when RBS::Types::Bases::Instance
             Instance.new(location: nil)
-          when Ruby::Signature::Types::Bases::Self
+          when RBS::Types::Bases::Self
             Self.new(location: nil)
-          when Ruby::Signature::Types::Bases::Top
+          when RBS::Types::Bases::Top
             Top.new(location: nil)
-          when Ruby::Signature::Types::Bases::Bottom
+          when RBS::Types::Bases::Bottom
             Bot.new(location: nil)
-          when Ruby::Signature::Types::Bases::Bool
+          when RBS::Types::Bases::Bool
             Boolean.new(location: nil)
-          when Ruby::Signature::Types::Bases::Void
+          when RBS::Types::Bases::Void
             Void.new(location: nil)
-          when Ruby::Signature::Types::Bases::Nil
+          when RBS::Types::Bases::Nil
             Nil.new(location: nil)
-          when Ruby::Signature::Types::Variable
+          when RBS::Types::Variable
             Var.new(name: type.name, location: nil)
-          when Ruby::Signature::Types::ClassSingleton
+          when RBS::Types::ClassSingleton
             type_name = type_name(type.name)
             Name::Class.new(name: type_name, location: nil, constructor: nil)
-          when Ruby::Signature::Types::ClassInstance
+          when RBS::Types::ClassInstance
             type_name = type_name(type.name)
             args = type.args.map {|arg| type(arg) }
             Name::Instance.new(name: type_name, args: args, location: nil)
-          when Ruby::Signature::Types::Interface
+          when RBS::Types::Interface
             type_name = type_name(type.name)
             args = type.args.map {|arg| type(arg) }
             Name::Interface.new(name: type_name, args: args, location: nil)
-          when Ruby::Signature::Types::Alias
+          when RBS::Types::Alias
             type_name = type_name(type.name)
             Name::Alias.new(name: type_name, args: [], location: nil)
-          when Ruby::Signature::Types::Union
+          when RBS::Types::Union
             Union.build(types: type.types.map {|ty| type(ty) }, location: nil)
-          when Ruby::Signature::Types::Intersection
+          when RBS::Types::Intersection
             Intersection.build(types: type.types.map {|ty| type(ty) }, location: nil)
-          when Ruby::Signature::Types::Optional
+          when RBS::Types::Optional
             Union.build(types: [type(type.type), Nil.new(location: nil)], location: nil)
-          when Ruby::Signature::Types::Literal
+          when RBS::Types::Literal
             Literal.new(value: type.literal, location: nil)
-          when Ruby::Signature::Types::Tuple
+          when RBS::Types::Tuple
             Tuple.new(types: type.types.map {|ty| type(ty) }, location: nil)
-          when Ruby::Signature::Types::Record
+          when RBS::Types::Record
             elements = type.fields.each.with_object({}) do |(key, value), hash|
               hash[key] = type(value)
             end
             Record.new(elements: elements, location: nil)
-          when Ruby::Signature::Types::Proc
+          when RBS::Types::Proc
             params = params(type.type)
             return_type = type(type.type.return_type)
             Proc.new(params: params, return_type: return_type, location: nil)
@@ -71,56 +71,56 @@ module Steep
         def type_1(type)
           case type
           when Any
-            Ruby::Signature::Types::Bases::Any.new(location: nil)
+            RBS::Types::Bases::Any.new(location: nil)
           when Class
-            Ruby::Signature::Types::Bases::Class.new(location: nil)
+            RBS::Types::Bases::Class.new(location: nil)
           when Instance
-            Ruby::Signature::Types::Bases::Instance.new(location: nil)
+            RBS::Types::Bases::Instance.new(location: nil)
           when Self
-            Ruby::Signature::Types::Bases::Self.new(location: nil)
+            RBS::Types::Bases::Self.new(location: nil)
           when Top
-            Ruby::Signature::Types::Bases::Top.new(location: nil)
+            RBS::Types::Bases::Top.new(location: nil)
           when Bot
-            Ruby::Signature::Types::Bases::Bottom.new(location: nil)
+            RBS::Types::Bases::Bottom.new(location: nil)
           when Boolean
-            Ruby::Signature::Types::Bases::Bool.new(location: nil)
+            RBS::Types::Bases::Bool.new(location: nil)
           when Void
-            Ruby::Signature::Types::Bases::Void.new(location: nil)
+            RBS::Types::Bases::Void.new(location: nil)
           when Nil
-            Ruby::Signature::Types::Bases::Nil.new(location: nil)
+            RBS::Types::Bases::Nil.new(location: nil)
           when Var
-            Ruby::Signature::Types::Variable.new(name: type.name, location: nil)
+            RBS::Types::Variable.new(name: type.name, location: nil)
           when Name::Class, Name::Module
-            Ruby::Signature::Types::ClassSingleton.new(name: type_name_1(type.name), location: nil)
+            RBS::Types::ClassSingleton.new(name: type_name_1(type.name), location: nil)
           when Name::Instance
-            Ruby::Signature::Types::ClassInstance.new(
+            RBS::Types::ClassInstance.new(
               name: type_name_1(type.name),
               args: type.args.map {|arg| type_1(arg) },
               location: nil
             )
           when Name::Interface
-            Ruby::Signature::Types::Interface.new(
+            RBS::Types::Interface.new(
               name: type_name_1(type.name),
               args: type.args.map {|arg| type_1(arg) },
               location: nil
             )
           when Name::Alias
             type.args.empty? or raise "alias type with args is not supported"
-            Ruby::Signature::Types::Alias.new(name: type_name_1(type.name), location: nil)
+            RBS::Types::Alias.new(name: type_name_1(type.name), location: nil)
           when Union
-            Ruby::Signature::Types::Union.new(
+            RBS::Types::Union.new(
               types: type.types.map {|ty| type_1(ty) },
               location: nil
             )
           when Intersection
-            Ruby::Signature::Types::Intersection.new(
+            RBS::Types::Intersection.new(
               types: type.types.map {|ty| type_1(ty) },
               location: nil
             )
           when Literal
-            Ruby::Signature::Types::Literal.new(literal: type.value, location: nil)
+            RBS::Types::Literal.new(literal: type.value, location: nil)
           when Tuple
-            Ruby::Signature::Types::Tuple.new(
+            RBS::Types::Tuple.new(
               types: type.types.map {|ty| type_1(ty) },
               location: nil
             )
@@ -128,9 +128,9 @@ module Steep
             fields = type.elements.each.with_object({}) do |(key, value), hash|
               hash[key] = type_1(value)
             end
-            Ruby::Signature::Types::Record.new(fields: fields, location: nil)
+            RBS::Types::Record.new(fields: fields, location: nil)
           when Proc
-            Ruby::Signature::Types::Proc.new(
+            RBS::Types::Proc.new(
               type: function_1(type.params, type.return_type),
               location: nil
             )
@@ -151,7 +151,7 @@ module Steep
         end
 
         def type_name_1(name)
-          Ruby::Signature::TypeName.new(name: name.name, namespace: namespace_1(name.namespace))
+          RBS::TypeName.new(name: name.name, namespace: namespace_1(name.namespace))
         end
 
         def namespace(namespace)
@@ -159,18 +159,18 @@ module Steep
         end
 
         def namespace_1(namespace)
-          Ruby::Signature::Namespace.parse(namespace.to_s)
+          RBS::Namespace.parse(namespace.to_s)
         end
 
         def function_1(params, return_type)
-          Ruby::Signature::Types::Function.new(
-            required_positionals: params.required.map {|type| Ruby::Signature::Types::Function::Param.new(name: nil, type: type_1(type)) },
-            optional_positionals: params.optional.map {|type| Ruby::Signature::Types::Function::Param.new(name: nil, type: type_1(type)) },
-            rest_positionals: params.rest&.yield_self {|type| Ruby::Signature::Types::Function::Param.new(name: nil, type: type_1(type)) },
+          RBS::Types::Function.new(
+            required_positionals: params.required.map {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
+            optional_positionals: params.optional.map {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
+            rest_positionals: params.rest&.yield_self {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
             trailing_positionals: [],
-            required_keywords: params.required_keywords.transform_values {|type| Ruby::Signature::Types::Function::Param.new(name: nil, type: type_1(type)) },
-            optional_keywords: params.optional_keywords.transform_values {|type| Ruby::Signature::Types::Function::Param.new(name: nil, type: type_1(type)) },
-            rest_keywords: params.rest_keywords&.yield_self {|type| Ruby::Signature::Types::Function::Param.new(name: nil, type: type_1(type)) },
+            required_keywords: params.required_keywords.transform_values {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
+            optional_keywords: params.optional_keywords.transform_values {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
+            rest_keywords: params.rest_keywords&.yield_self {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
             return_type: type_1(return_type)
           )
         end
@@ -235,7 +235,7 @@ module Steep
 
           method_type.type_params.map do |name|
             if fvs.include?(name)
-              type = Ruby::Signature::Types::Variable.new(name: name, location: nil),
+              type = RBS::Types::Variable.new(name: name, location: nil),
               alpha_vars << name
               alpha_types << type
               type_params << type.name
@@ -245,13 +245,13 @@ module Steep
           end
           subst = Interface::Substitution.build(alpha_vars, alpha_types)
 
-          type = Ruby::Signature::MethodType.new(
+          type = RBS::MethodType.new(
             type_params: type_params,
             type: function_1(method_type.params.subst(subst), method_type.return_type.subst(subst)),
             block: method_type.block&.yield_self do |block|
               block_type = block.type.subst(subst)
 
-              Ruby::Signature::MethodType::Block.new(
+              RBS::MethodType::Block.new(
                 type: function_1(block_type.params, block_type.return_type),
                 required: !block.optional
               )
@@ -543,12 +543,12 @@ module Steep
 
         def module_name?(type_name)
           name = type_name_1(type_name)
-          env.class?(name) && env.find_class(name).is_a?(Ruby::Signature::AST::Declarations::Module)
+          env.class?(name) && env.find_class(name).is_a?(RBS::AST::Declarations::Module)
         end
 
         def class_name?(type_name)
           name = type_name_1(type_name)
-          env.class?(name) && env.find_class(name).is_a?(Ruby::Signature::AST::Declarations::Class)
+          env.class?(name) && env.find_class(name).is_a?(RBS::AST::Declarations::Class)
         end
 
         def env

data/lib/steep/drivers/check.rb

@@ -51,15 +51,31 @@ module Steep
               printer.print_semantic_errors(status.errors)
             when Project::Target::TypeCheckStatus
               status.type_check_sources.each do |source_file|
-                source_file.errors.each do |error|
-                  error.print_to stdout
+                case source_file.status
+                when Project::SourceFile::TypeCheckStatus
+                  source_file.errors.reject do |error|
+                    case
+                    when error.is_a?(Errors::FallbackAny)
+                      target.options.allow_fallback_any
+                    when error.is_a?(Errors::MethodDefinitionMissing)
+                      target.options.allow_missing_definitions
+                    when error.is_a?(Errors::NoMethod)
+                      target.options.allow_unknown_method_calls
+                    when error.is_a?(Errors::UnknownConstantAssigned)
+                      target.options.allow_unknown_constant_assignment
+                    end
+                  end.each do |error|
+                    error.print_to stdout
+                  end
+                when Project::SourceFile::TypeCheckErrorStatus
+                  Steep.log_error source_file.status.error
                 end
               end
             end
           end
         end
 
-        if project.targets.all? {|target| target.status.is_a?(Project::Target::TypeCheckStatus) && target.errors.empty? }
+        if project.targets.all? {|target| target.status.is_a?(Project::Target::TypeCheckStatus) && target.no_error? && target.errors.empty? }
           Steep.logger.info "No type error found"
           return 0
         end
@@ -70,7 +86,7 @@ module Steep
       def output_types(typing)
         lines = []
 
-        typing.nodes.each_value do |node|
+        typing.each_typing do |node, _|
           begin
             type = typing.type_of(node: node)
             lines << [node.loc.expression.source_buffer.name, [node.loc.last_line,node.loc.last_column], [node.loc.first_line, node.loc.column], node, type]

data/lib/steep/drivers/langserver.rb

@@ -234,6 +234,11 @@ module Steep
                                   source.errors.map {|error| diagnostic_for_type_error(error) }
                                 when Project::SourceFile::AnnotationSyntaxErrorStatus
                                   [diagnostics_raw(source.status.error.message, source.status.location)]
+                                when Project::SourceFile::ParseErrorStatus
+                                  []
+                                when Project::SourceFile::TypeCheckErrorStatus
+                                  Steep.log_error source.status.error
+                                  []
                                 end
 
                   if diagnostics
@@ -441,7 +446,7 @@ HOVER
 
 
         block = if method_type.block
-                  open, space, close = if method_type.block.type.return_type.is_a?(Ruby::Signature::Types::Bases::Void)
+                  open, space, close = if method_type.block.type.return_type.is_a?(RBS::Types::Bases::Void)
                                   ["do", " ", "end"]
                                 else
                                   ["{", "", "}"]

data/lib/steep/drivers/vendor.rb

@@ -20,7 +20,7 @@ module Steep
       def run
         stdout.puts "Vendoring into #{vendor_dir}..."
 
-        vendorer = Ruby::Signature::Vendorer.new(vendor_dir: vendor_dir)
+        vendorer = RBS::Vendorer.new(vendor_dir: vendor_dir)
 
         if clean_before
           stdout.puts "  Cleaning directory..."
@@ -32,7 +32,7 @@ module Steep
 
         if defined?(Bundler)
           Bundler.locked_gems.specs.each do |spec|
-            if Ruby::Signature::EnvironmentLoader.gem_sig_path(spec.name, spec.version.to_s).directory?
+            if RBS::EnvironmentLoader.gem_sig_path(spec.name, spec.version.to_s).directory?
               stdout.puts "  Vendoring rubygem: #{spec.full_name}..."
               vendorer.gem! spec.name, spec.version.to_s
             end

data/lib/steep/project/completion_provider.rb

@@ -99,10 +99,11 @@ module Steep
 
         items = []
 
+        context = typing.context_at(line: position.line, column: position.column)
+
         case
         when node.type == :send && node.children[0] == nil && at_end?(position, of: node.loc.selector)
           # foo ←
-          context = typing.context_of(node: node)
           prefix = node.children[1].to_s
 
           method_items_for_receiver_type(context.self_type,
@@ -114,12 +115,10 @@ module Steep
 
         when node.type == :lvar && at_end?(position, of: node.loc)
           # foo ← (lvar)
-          context = typing.context_of(node: node)
           local_variable_items_for_context(context, position: position, prefix: node.children[0].name.to_s, items: items)
 
         when node.type == :send && node.children[0] && at_end?(position, of: node.loc.selector)
           # foo.ba ←
-          context = typing.context_of(node: node)
           receiver_type = case (type = typing.type_of(node: node.children[0]))
                           when AST::Types::Self
                             context.self_type
@@ -136,7 +135,6 @@ module Steep
 
         when node.type == :const && node.children[0] == nil && at_end?(position, of: node.loc)
           # Foo ← (const)
-          context = typing.context_of(node: node)
           prefix = node.children[1].to_s
 
           method_items_for_receiver_type(context.self_type,
@@ -147,7 +145,6 @@ module Steep
 
         when node.type == :send && at_end?(position, of: node.loc.dot)
           # foo.← ba
-          context = typing.context_of(node: node)
           receiver_type = case (type = typing.type_of(node: node.children[0]))
                           when AST::Types::Self
                             context.self_type
@@ -163,12 +160,9 @@ module Steep
 
         when node.type == :ivar && at_end?(position, of: node.loc)
           # @fo ←
-          context = typing.context_of(node: node)
           instance_variable_items_for_context(context, position: position, prefix: node.children[0].to_s, items: items)
 
         else
-          context = typing.context_of(node: node)
-
           method_items_for_receiver_type(context.self_type,
                                          include_private: true,
                                          prefix: "",
@@ -190,7 +184,7 @@ module Steep
         return [] unless node
 
         if at_end?(shift_pos, of: node.loc)
-          context = typing.context_of(node: node)
+          context = typing.context_at(line: position.line, column: position.column)
           receiver_type = case (type = typing.type_of(node: node))
                           when AST::Types::Self
                             context.self_type
@@ -218,7 +212,7 @@ module Steep
 
         return [] unless node
 
-        context = typing.context_of(node: node)
+        context = typing.context_at(line: position.line, column: position.column)
         items = []
         instance_variable_items_for_context(context, prefix: "", position: position, items: items)
         items
@@ -263,7 +257,7 @@ module Steep
 
       def local_variable_items_for_context(context, position:, prefix:, items:)
         range = range_for(position, prefix: prefix)
-        context.type_env.lvar_types.each do |name, type|
+        context.lvar_env.each do |name, type|
           if name.to_s.start_with?(prefix)
             items << LocalVariableItem.new(identifier: name,
                                            range: range,

data/lib/steep/project/dsl.rb

@@ -9,6 +9,7 @@ module Steep
         attr_reader :ignored_sources
         attr_reader :no_builtin
         attr_reader :vendor_dir
+        attr_reader :strictness_level
 
         def initialize(name, sources: [], libraries: [], signatures: [], ignored_sources: [])
           @name = name
@@ -17,6 +18,7 @@ module Steep
           @signatures = signatures
           @ignored_sources = ignored_sources
           @vendor_dir = nil
+          @strictness_level = :default
         end
 
         def initialize_copy(other)
@@ -26,6 +28,7 @@ module Steep
           @signatures = other.signatures.dup
           @ignored_sources = other.ignored_sources.dup
           @vendor_dir = other.vendor_dir
+          @strictness_level = other.strictness_level
         end
 
         def check(*args)
@@ -40,6 +43,10 @@ module Steep
           libraries.push(*args)
         end
 
+        def typing_options(level)
+          @strictness_level = level
+        end
+
         def signature(*args)
           signatures.push(*args)
         end
@@ -114,6 +121,13 @@ module Steep
           options: Options.new.tap do |options|
             options.libraries.push(*target.libraries)
 
+            case target.strictness_level
+            when :strict
+              options.apply_strict_typing_options!
+            when :lenient
+              options.apply_lenient_typing_options!
+            end
+
             case target.vendor_dir
             when Array
               options.vendored_stdlib_path = target.vendor_dir[0]