steep 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 376c287eb4edd3b191575c4dae0d6f928394ba2a52ee41ed6245c4b73579d3f0
-  data.tar.gz: ef83cd047a6f35f597e3709f45ee3918c0bad4944c970002827baf2ea012df76
+  metadata.gz: 680c21e93b572cec898efc4efe60db2826ed86e06f17be5c3380e84f3884e50b
+  data.tar.gz: b638f8968a0bd9e8f05de731059f58dc47da209ccc0430337f32efcfb95fab36
 SHA512:
-  metadata.gz: 6f350dd1d6043f7389bb97ec1c6526fbc7a62aa86a9fb3b4b4f1c01241d6bd691c9fe51a5e91a242900e4c9528cc50d2ed5638b5b70e6e21645088bd6f85fffc
-  data.tar.gz: 3df8d10e17edeb6cad99199370f21925681f81cfebf29a471cee4087edb5a1efd13580dae0c9ddc46e2f64b3a6314d18b0a72f0299a42dd597134512fa32593f
+  metadata.gz: 013d9357eb3d2710aedecafea03d883486628c62c45bec80abfb761faba4131d2542d1afbbf1151853f729eae0ea13875c860d2ae5390b925649b84b3d4de7de
+  data.tar.gz: 7a7ee6ffaf6dc688d4375f5290237aea99262e5ab4cbe18b69458c411596b426037151a2afc7d96153b62a25fa27dde9141c98b32a4d31c6a24f7f17fdd3935d

data/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## master
 
+## 0.5.0 (2018-08-11)
+
+* Support *lambda* `->` (#47)
+* Introduce *incompatible* method (#45)
+* Add type alias (#44)
+* Steep is MIT license (#43)
+* Improved block parameter typing (#41) 
+* Support optional block
+* Support attributes in module
+* Support `:xstr` node
+* Allow missing method definition with `steep check` without `--strict`
+
 ## 0.4.0 (2018-06-14)
 
 * Add *tuple* type (#40)

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Soutaro Matsumoto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/bin/smoke_runner.rb

@@ -74,6 +74,9 @@ ARGV.each do |arg|
                                        stdout: stdout,
                                        stderr: stderr)
 
+    driver.fallback_any_is_error = false
+    driver.allow_missing_definitions = false
+
     Rainbow.enabled = false
     driver.run
   rescue => exn

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

@@ -2,78 +2,155 @@ module Steep
   module AST
     module Annotation
       class Collection
-        attr_reader :var_types
-        attr_reader :method_types
         attr_reader :annotations
-        attr_reader :block_type
-        attr_reader :return_type
-        attr_reader :self_type
-        attr_reader :const_types
-        attr_reader :instance_type
-        attr_reader :module_type
-        attr_reader :implement_module
-        attr_reader :ivar_types
-        attr_reader :dynamics
-        attr_reader :break_type
-
-        def initialize(annotations:)
-          @var_types = {}
-          @method_types = {}
-          @const_types = {}
-          @ivar_types = {}
-          @dynamics = {}
-          @break_type = nil
+        attr_reader :builder
+        attr_reader :current_module
+
+        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:, builder:, current_module:)
+          @annotations = annotations
+          @builder = builder
+          @current_module = current_module
+
+          @var_type_annotations = {}
+          @method_type_annotations = {}
+          @const_type_annotations = {}
+          @ivar_type_annotations = {}
+          @dynamic_annotations = []
 
           annotations.each do |annotation|
             case annotation
             when VarType
-              var_types[annotation.name] = annotation
+              var_type_annotations[annotation.name] = annotation
             when MethodType
-              method_types[annotation.name] = annotation
+              method_type_annotations[annotation.name] = annotation
             when BlockType
-              @block_type = annotation.type
+              @block_type_annotation = annotation
             when ReturnType
-              @return_type = annotation.type
+              @return_type_annotation = annotation
             when SelfType
-              @self_type = annotation.type
+              @self_type_annotation = annotation
             when ConstType
-              @const_types[annotation.name] = annotation.type
+              @const_type_annotations[annotation.name] = annotation
             when InstanceType
-              @instance_type = annotation.type
+              @instance_type_annotation = annotation
             when ModuleType
-              @module_type = annotation.type
+              @module_type_annotation = annotation
             when Implements
-              @implement_module = annotation
+              @implement_module_annotation = annotation
             when IvarType
-              ivar_types[annotation.name] = annotation.type
+              @ivar_type_annotations[annotation.name] = annotation
             when Dynamic
-              annotation.names.each do |name|
-                dynamics[name.name] = name
-              end
+              @dynamic_annotations << annotation
             when BreakType
-              @break_type = annotation.type
+              @break_type_annotation = annotation
             else
               raise "Unexpected annotation: #{annotation.inspect}"
             end
           end
+        end
+
+        def absolute_type(type)
+          if type
+            builder.absolute_type(type, current: current_module)
+          end
+        end
 
-          @annotations = annotations
+        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])
+            builder.method_type_to_method_type(a.type, current: current_module)
+          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 lookup_var_type(name)
-          var_types[name]&.type
+        def instance_type
+          absolute_type(instance_type_annotation&.type)
         end
 
-        def lookup_method_type(name)
-          method_types[name]&.type
+        def module_type
+          absolute_type(module_type_annotation&.type)
         end
 
-        def lookup_const_type(node)
-          const_types[node]
+        def break_type
+          absolute_type(break_type_annotation&.type)
         end
 
-        def +(other)
-          self.class.new(annotations: annotations.reject {|a| a.is_a?(BlockType) } + other.annotations)
+        def lvar_types
+          var_type_annotations.each_key.with_object({}) do |name, hash|
+            hash[name] = var_type(lvar: name)
+          end
+        end
+
+        def ivar_types
+          ivar_type_annotations.each_key.with_object({}) do |name, hash|
+            hash[name] = var_type(ivar: name)
+          end
+        end
+
+        def const_types
+          const_type_annotations.each_key.with_object({}) do |name, hash|
+            hash[name] = var_type(const: name)
+          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.current_module != current_module || annotations.builder != builder
+            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,
+                         builder: builder,
+                         current_module: current_module)
         end
 
         def any?(&block)

data/lib/steep/ast/annotation.rb

@@ -15,8 +15,7 @@ module Steep
         def ==(other)
           other.is_a?(self.class) &&
             other.name == name &&
-            other.type == type &&
-            (!other.location || !location || other.location == location)
+            other.type == type
         end
       end
 
@@ -32,8 +31,7 @@ module Steep
 
         def ==(other)
           other.is_a?(self.class) &&
-            other.type == type &&
-            (!other.location || !location || other.location == location)
+            other.type == type
         end
       end
 
@@ -73,15 +71,13 @@ module Steep
         attr_reader :location
         attr_reader :name
 
-        def initialize(name:, location:)
+        def initialize(name:, location: nil)
           @location = location
           @name = name
         end
 
         def ==(other)
-          other.is_a?(Implements) &&
-            other.name == name &&
-            other.location == location
+          other.is_a?(Implements) && other.name == name
         end
       end
 
@@ -122,8 +118,7 @@ module Steep
 
         def ==(other)
           other.is_a?(Dynamic) &&
-            other.names == names &&
-            (!other.location || location || other.location == location)
+            other.names == names
         end
       end
     end

data/lib/steep/ast/location.rb

@@ -12,7 +12,7 @@ module Steep
       end
 
       def inspect
-        "#<#{self.class}:#{self.__id__} @buffer=..., @start_pos=#{start_pos}, @end_pos=#{end_pos}, source='#{source.lines.first}', start_line=#{start_line}, start_column=#{start_column}>"
+        "#<#{self.class}:#{self.__id__} @buffer=#{buffer.name}, @start_pos=#{start_pos}, @end_pos=#{end_pos}, source='#{source.lines.first}', start_line=#{start_line}, start_column=#{start_column}>"
       end
 
       def name

data/lib/steep/ast/method_type.rb

@@ -90,11 +90,13 @@ module Steep
         attr_reader :location
         attr_reader :params
         attr_reader :return_type
+        attr_reader :optional
 
-        def initialize(location:, params:, return_type:)
+        def initialize(location:, params:, return_type:, optional:)
           @location = location
           @params = params
           @return_type = return_type
+          @optional = optional
         end
       end
 

data/lib/steep/ast/signature/alias.rb

@@ -0,0 +1,19 @@
+module Steep
+  module AST
+    module Signature
+      class Alias
+        attr_reader :location
+        attr_reader :name
+        attr_reader :params
+        attr_reader :type
+
+        def initialize(location:, name:, params:, type:)
+          @location = location
+          @name = name
+          @params = params
+          @type = type
+        end
+      end
+    end
+  end
+end

data/lib/steep/ast/signature/env.rb

@@ -8,6 +8,7 @@ module Steep
         attr_reader :interfaces
         attr_reader :constants
         attr_reader :globals
+        attr_reader :aliases
 
         def initialize()
           @modules = {}
@@ -16,6 +17,7 @@ module Steep
           @interfaces = {}
           @constants = {}
           @globals = {}
+          @aliases = {}
         end
 
         def add(sig)
@@ -40,6 +42,9 @@ module Steep
           when Signature::Gvar
             raise "Duplicated global: #{sig.name}" if globals.key?(sig.name)
             globals[sig.name] = sig
+          when Signature::Alias
+            raise "Duplicated alias: #{sig.name}" if aliases.key?(sig.name)
+            aliases[sig.name] = sig
           else
             raise "Unknown signature:: #{sig}"
           end
@@ -73,6 +78,10 @@ module Steep
           globals[name]
         end
 
+        def find_alias(name)
+          aliases[name]
+        end
+
         def find_name(hash, name, current_module:)
           if current_module
             hash[current_module + name] || find_name(hash, name, current_module: current_module.parent)

data/lib/steep/ast/signature/members.rb

@@ -52,6 +52,10 @@ module Steep
           def constructor?
             attributes.include?(:constructor)
           end
+
+          def incompatible?
+            attributes.include?(:incompatible)
+          end
         end
 
         class Ivar

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

@@ -0,0 +1,79 @@
+module Steep
+  module AST
+    module Types
+      class Proc
+        attr_reader :location
+        attr_reader :params
+        attr_reader :return_type
+
+        def initialize(params:, return_type:, location: nil)
+          @location = location
+          @params = params
+          @return_type = return_type
+        end
+
+        def ==(other)
+          other.is_a?(self.class) &&
+            other.params == params &&
+            other.return_type == return_type
+        end
+
+        def hash
+          self.class.hash && params.hash && return_type.hash
+        end
+
+        alias eql? ==
+
+        def subst(s)
+          self.class.new(
+            params: params.subst(s),
+            return_type: return_type.subst(s),
+            location: location
+          )
+        end
+
+        def to_s
+          "^#{params} -> #{return_type}"
+        end
+
+        def free_variables
+          params.free_variables + return_type.free_variables
+        end
+
+        def level
+          children = params.each_type.to_a + [return_type]
+          [0] + level_of_children(children)
+        end
+
+        def closed?
+          params.closed? && return_type.closed?
+        end
+
+        def with_location(new_location)
+          self.class.new(location: new_location)
+        end
+
+        def map_type(&block)
+          self.class.new(
+            params: params.map_type(&block),
+            return_type: yield(return_type),
+            location: location
+          )
+        end
+
+        def one_arg?
+          params.required.size == 1 &&
+            params.optional.empty? &&
+            !params.rest &&
+            params.required_keywords.empty? &&
+            params.optional_keywords.empty? &&
+            !params.rest_keywords
+        end
+
+        def back_type
+          Name.new_instance(name: "::Proc", location: location)
+        end
+      end
+    end
+  end
+end

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

@@ -30,6 +30,10 @@ module Steep
           Set.new
         end
 
+        def level
+          [0]
+        end
+
         def with_location(new_location)
           self.class.new(location: new_location)
         end

data/lib/steep/cli.rb

@@ -75,6 +75,7 @@ module Steep
         check.verbose = verbose
         check.dump_all_types = dump_all_types
         check.fallback_any_is_error = fallback_any_is_error || strict
+        check.allow_missing_definitions = false if strict
       end.run
     end
 
@@ -118,7 +119,7 @@ module Steep
       OptionParser.new do |opts|
         opts.on("-I [PATH]") {|path| signature_dirs << Pathname(path) }
         opts.on("--no-builtin") { no_builtin = true }
-      end
+      end.parse!(argv)
 
       unless no_builtin
         signature_dirs.unshift Pathname(__dir__).join("../../stdlib").realpath

data/lib/steep/drivers/check.rb

@@ -10,6 +10,7 @@ module Steep
       attr_accessor :accept_implicit_any
       attr_accessor :dump_all_types
       attr_accessor :fallback_any_is_error
+      attr_accessor :allow_missing_definitions
 
       attr_reader :labeling
 
@@ -25,6 +26,7 @@ module Steep
         self.accept_implicit_any = false
         self.dump_all_types = false
         self.fallback_any_is_error = false
+        self.allow_missing_definitions = true
 
         @labeling = ASTUtils::Labeling.new
       end
@@ -61,7 +63,7 @@ module Steep
         sources.each do |source|
           Steep.logger.tagged source.path do
             Steep.logger.debug "Typechecking..."
-            annotations = source.annotations(block: source.node) || []
+            annotations = source.annotations(block: source.node, builder: check.builder, current_module: nil)
 
             pp annotations if verbose
 
@@ -113,6 +115,7 @@ module Steep
 
         typing.errors.each do |error|
           next if error.is_a?(Errors::FallbackAny) && !fallback_any_is_error
+          next if error.is_a?(Errors::MethodDefinitionMissing) && allow_missing_definitions
           error.print_to stdout
         end
       end

data/lib/steep/errors.rb

@@ -333,6 +333,19 @@ module Steep
       end
     end
 
+    class IncompatibleZuper < Base
+      attr_reader :method
+
+      def initialize(node:, method:)
+        super(node: node)
+        @method = method
+      end
+
+      def to_s
+        "#{location_to_str}: IncompatibleZuper: method=#{method}"
+      end
+    end
+
     class MethodDefinitionMissing < Base
       attr_reader :module_name
       attr_reader :kind