steep 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 188a058370f3907cd216a30b481e78ff0c2573639baef3e052f192e9ec0c118d
-  data.tar.gz: bacaac26779348dc7e1e4d36c3fa49d0842576429085d7ea496983fa684d21b3
+  metadata.gz: 562a6dfa36fc5da260d7dfc0cbc2a92f44000038aeb45447d79185cf700dfa9b
+  data.tar.gz: 48a656998959cce3a87cd6c59f4115b753336b33f54e2d961d656efd3e47b0c2
 SHA512:
-  metadata.gz: a6ab5520ff7251a49da2673180c00b4d8be64b42e89b67153e1ca65f70dbf66c14f82384feff68a1a1ec19f8a20899802493f23e2e6f13e858b3962239416dd6
-  data.tar.gz: 1a28b00375d3091600728241e218a305844fcb62ac52f3f99d190b8a01d3cda7f251a65d1efa10d2576073f84c53b9346615b9549cd7702b699a658c7d588bb0
+  metadata.gz: 6d22bbd0e6a251db6431a7f90a59b087ebf879d1664af7195aa889ade8d0c3a5191908740501bd97a5315dc041a8704946361f821f1c5d9e6ed79e2e07a80451
+  data.tar.gz: 3cd0b8bdd13aed0035f6a3f0363bb96f75ee67ed4d88fb0912bff7e828ebdcc0f2244a4eb3280c83c306b983270c97848b618b410c2002a887b1dc44aac6fe5b

data/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## master
 
+## 0.6.0 (2018-09-23)
+
+* Update ast_utils
+* Introduce *hash* type `{ id: Integer, name: String }` (#54)
+* Revise signature syntax; use `<` instead of `<:` for inheritance (#53)
+* Interface and alias name can be namespaced (#52)
+* Grammar formatting (#51 @iliabylich)
+
 ## 0.5.1 (2018-08-11)
 
 * Relax dependency requirements (#49, #50)
@@ -12,7 +20,7 @@
 * Introduce *incompatible* method (#45)
 * Add type alias (#44)
 * Steep is MIT license (#43)
-* Improved block parameter typing (#41) 
+* Improved block parameter typing (#41)
 * Support optional block
 * Support attributes in module
 * Support `:xstr` node

data/bin/smoke_runner.rb

@@ -33,7 +33,7 @@ ARGV.each do |arg|
     if file.extname == ".rb"
       buffer = ::Parser::Source::Buffer.new(file.to_s)
       buffer.source = file.read
-      parser = ::Parser::CurrentRuby.new
+      parser = ::Parser::Ruby25.new
 
       _, comments, _ = parser.tokenize(buffer)
       comments.each do |comment|

data/lib/steep.rb

@@ -1,13 +1,15 @@
 require "steep/version"
 
 require "pathname"
+require "parser/ruby25"
 require "ast_utils"
 require "active_support/core_ext/object/try"
 require "logger"
 require "active_support/tagged_logging"
 require "rainbow"
 
-require "steep/module_name"
+require "steep/ast/namespace"
+require "steep/names"
 require "steep/ast/location"
 require "steep/ast/types/helper"
 require "steep/ast/types/any"
@@ -26,6 +28,7 @@ require "steep/ast/types/literal"
 require "steep/ast/types/boolean"
 require "steep/ast/types/tuple"
 require "steep/ast/types/proc"
+require "steep/ast/types/hash"
 require "steep/ast/method_type"
 require "steep/ast/type_params"
 require "steep/ast/signature/class"
@@ -40,8 +43,7 @@ require "steep/ast/signature/alias"
 require "steep/ast/annotation"
 require "steep/ast/annotation/collection"
 require "steep/ast/buffer"
-
-require "steep/type_name"
+require "steep/ast/builtin"
 
 require "steep/interface/method_type"
 require "steep/interface/method"
@@ -87,7 +89,7 @@ module Steep
     unless @logger
       @logger = ActiveSupport::TaggedLogging.new(Logger.new(STDERR))
       @logger.push_tags "Steep #{VERSION}"
-      @logger.level = Logger::ERROR
+      @logger.level = Logger::WARN
     end
 
     @logger

data/lib/steep/ast/builtin.rb

@@ -0,0 +1,96 @@
+module Steep
+  module AST
+    module Builtin
+      class Type
+        attr_reader :module_name
+        attr_reader :arity
+
+        def initialize(module_name, arity: 0)
+          @module_name = Names::Module.parse(module_name)
+          @arity = arity
+        end
+
+        def instance_type(*args)
+          arity == args.size or raise "Mulformed instance type: name=#{module_name}, args=#{args}"
+          Types::Name::Instance.new(name: module_name, args: args)
+        end
+
+        def class_type(constructor: nil)
+          Types::Name::Class.new(name: module_name, constructor: constructor)
+        end
+
+        def module_type
+          Types::Name::Module.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 "Mulformed instance type: name=#{module_name}, args=#{args}"
+              type.name == module_name && type.args == args
+            else
+              type.name == module_name && type.args.size == arity
+            end
+          else
+            false
+          end
+        end
+
+        NONE = ::Object.new
+
+        def class_type?(type, constructor: NONE)
+          if type.is_a?(Types::Name::Class)
+            unless constructor.equal?(NONE)
+              type.name == module_name && type.name.constructor == constructor
+            else
+              type.name == module_name
+            end
+          else
+            false
+          end
+        end
+
+        def module_type?(type)
+          if type.is_a?(Types::Name::Module)
+            type.name == module_name
+          else
+            false
+          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")
+
+      def self.nil_type
+        AST::Types::Nil.new
+      end
+
+      def self.any_type
+        AST::Types::Any.new
+      end
+
+      def self.bool_type
+        AST::Types::Boolean.new
+      end
+
+      def self.optional(type)
+        AST::Types::Union.build(types: [type, nil_type])
+      end
+    end
+  end
+end

data/lib/steep/ast/location.rb

@@ -59,11 +59,15 @@ module Steep
       end
 
       def +(other)
-        raise "Invalid concat: buffer=#{buffer.name}, other.buffer=#{other.buffer.name}" unless other.buffer == buffer
-
-        self.class.new(buffer: buffer,
-                       start_pos: start_pos,
-                       end_pos: other.end_pos)
+        if other
+          raise "Invalid concat: buffer=#{buffer.name}, other.buffer=#{other.buffer.name}" unless other.buffer == buffer
+
+          self.class.new(buffer: buffer,
+                         start_pos: start_pos,
+                         end_pos: other.end_pos)
+        else
+          self
+        end
       end
 
       def self.concat(*locations)

data/lib/steep/ast/namespace.rb

@@ -0,0 +1,80 @@
+module Steep
+  module AST
+    class Namespace
+      attr_reader :path
+
+      def initialize(path:, absolute:)
+        @path = path
+        @absolute = absolute
+      end
+
+      def self.empty
+        new(path: [], absolute: false)
+      end
+
+      def self.root
+        new(path: [], absolute: true)
+      end
+
+      def +(other)
+        if other.absolute?
+          other
+        else
+          self.class.new(path: path + other.path, absolute: absolute?)
+        end
+      end
+
+      def append(component)
+        self.class.new(path: path + [component], absolute: absolute?)
+      end
+
+      def parent
+        raise "Parent with empty namespace" if empty?
+        self.class.new(path: path.take(path.size - 1), absolute: absolute?)
+      end
+
+      def absolute?
+        @absolute
+      end
+
+      def relative?
+        !absolute?
+      end
+
+      def absolute!
+        self.class.new(path: path, absolute: true)
+      end
+
+      def empty?
+        path.empty?
+      end
+
+      def ==(other)
+        other.is_a?(Namespace) && other.path == path && other.absolute? == absolute?
+      end
+
+      alias eql? ==
+
+      def hash
+        self.class.hath ^ path.hash ^ absolute?.hash
+      end
+
+      def to_s
+        if empty?
+          absolute? ? "::" : ""
+        else
+          s = path.join("::")
+          absolute? ? "::#{s}::" : "#{s}::"
+        end
+      end
+
+      def self.parse(string)
+        if string.start_with?("::")
+          new(path: string.split("::").drop(1).map(&:to_sym), absolute: true)
+        else
+          new(path: string.split("::").map(&:to_sym), absolute: false)
+        end
+      end
+    end
+  end
+end

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

@@ -20,15 +20,22 @@ module Steep
           @aliases = {}
         end
 
+        def assert_absolute_name(name)
+          name.namespace.absolute? or raise "Absolute name expected: #{name}"
+        end
+
         def add(sig)
           case sig
           when Signature::Class
-            raise "Duplicated class: #{sig.name}" if classes.key?(sig.name.absolute!) || modules.key?(sig.name.absolute!)
-            classes[sig.name.absolute!] = sig
+            assert_absolute_name sig.name
+            raise "Duplicated class: #{sig.name}" if classes.key?(sig.name) || modules.key?(sig.name)
+            classes[sig.name] = sig
           when Signature::Module
-            raise "Duplicated module: #{sig.name}" if classes.key?(sig.name.absolute!) || modules.key?(sig.name.absolute!)
+            assert_absolute_name sig.name
+            raise "Duplicated module: #{sig.name}" if classes.key?(sig.name) || modules.key?(sig.name)
             modules[sig.name.absolute!] = sig
           when Signature::Interface
+            assert_absolute_name sig.name
             raise "Duplicated interface: #{sig.name}" if interfaces.key?(sig.name)
             interfaces[sig.name] = sig
           when Signature::Extension
@@ -38,11 +45,13 @@ module Steep
             end
             extensions[sig.module_name.absolute!] << sig
           when Signature::Const
-            constants[sig.name.absolute!] = sig
+            assert_absolute_name sig.name
+            constants[sig.name] = sig
           when Signature::Gvar
             raise "Duplicated global: #{sig.name}" if globals.key?(sig.name)
             globals[sig.name] = sig
           when Signature::Alias
+            assert_absolute_name sig.name
             raise "Duplicated alias: #{sig.name}" if aliases.key?(sig.name)
             aliases[sig.name] = sig
           else
@@ -50,15 +59,15 @@ module Steep
           end
         end
 
-        def find_module(name, current_module: nil)
+        def find_module(name, current_module: AST::Namespace.root)
           find_name(modules, name, current_module: current_module) or raise "Unknown module: #{name}"
         end
 
-        def find_class(name, current_module: nil)
+        def find_class(name, current_module: AST::Namespace.root)
           find_name(classes, name, current_module: current_module) or raise "Unknown class: #{name}"
         end
 
-        def find_class_or_module(name, current_module: nil)
+        def find_class_or_module(name, current_module: AST::Namespace.root)
           sig =
             find_name(modules, name, current_module: current_module) ||
               find_name(classes, name, current_module: current_module)
@@ -66,11 +75,11 @@ module Steep
           sig or raise "Unknown class/module: #{name}}"
         end
 
-        def find_extensions(name, current_module: nil)
+        def find_extensions(name, current_module: AST::Namespace.root)
           find_name(extensions, name, current_module: current_module) || []
         end
 
-        def find_const(name, current_module: nil)
+        def find_const(name, current_module: Namespace.root)
           find_name(constants, name, current_module: current_module)
         end
 
@@ -78,42 +87,39 @@ module Steep
           globals[name]
         end
 
-        def find_alias(name)
-          aliases[name]
+        def find_alias(name, namespace:)
+          find_name(aliases, name, current_module: namespace) or raise "Unknown alias: #{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)
+          current_module.absolute? or raise "Current namespace should be absolute: #{current_module}"
+
+          if (object = hash[name.in_namespace(current_module)])
+            object
           else
-            hash[name.absolute!]
+            unless current_module.empty?
+              find_name(hash, name, current_module: current_module.parent)
+            end
           end
         end
 
-        def find_interface(name)
-          interfaces[name] or raise "Unknown interface: #{name}"
-        end
-
-        def module?(type_name, current_module: nil)
-          name = type_name.map_module_name {|m| current_module ? current_module + m : m.absolute! }.name
-          modules.key?(name)
+        def find_interface(name, namespace: Namespace.root)
+          find_name(interfaces, name, current_module: namespace) or raise "Unknown interface: #{name}"
         end
 
-        def class?(type_name, current_module: nil)
-          name = type_name.map_module_name {|m| current_module ? current_name + m : m.absolute! }.name
+        def class_name?(name)
+          assert_absolute_name name
           classes.key?(name)
         end
 
-        def class_name?(name, current_module: nil)
-          classes.key?(current_module ? current_module + name : name.absolute!)
-        end
-
-        def module_name?(name, current_module: nil)
-          modules.key?(current_module ? current_module + name : name.absolute!)
+        def module_name?(name)
+          assert_absolute_name name
+          modules.key?(name)
         end
 
-        def const_name?(name, current_module: nil)
-          constants.key?(current_module ? current_module + name : name.absolute!)
+        def const_name?(name)
+          assert_absolute_name name
+          constants.key?(name)
         end
 
         def each(&block)

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

@@ -41,8 +41,8 @@ module Steep
         def back_type
           Union.build(types:
                       [
-                        Name.new_instance(name: "::TrueClass", location: location),
-                        Name.new_instance(name: "::FalseClass", location: location)
+                        Builtin::TrueClass.instance_type,
+                        Builtin::FalseClass.instance_type
                       ],
                       location: location)
         end

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

@@ -0,0 +1,50 @@
+module Steep
+  module AST
+    module Types
+      class Hash
+        attr_reader :location
+        attr_reader :elements
+
+        def initialize(elements:, location: nil)
+          @elements = elements
+          @location = location
+        end
+
+        def ==(other)
+          other.is_a?(Hash) && other.elements == elements
+        end
+
+        def hash
+          self.class.hash ^ elements.hash
+        end
+
+        alias eql? ==
+
+        def subst(s)
+          self.class.new(location: location,
+                         elements: elements.transform_values {|type| type.subst(s) })
+        end
+
+        def to_s
+          "{ #{elements.map {|key, value| "#{key.inspect} => #{value}" }.join(", ")} }"
+        end
+
+        def free_variables
+          elements.each_value.with_object(Set.new) do |type, set|
+            set.merge(type.free_variables)
+          end
+        end
+
+        include Helper::ChildrenLevel
+
+        def level
+          [0] + level_of_children(elements.values)
+        end
+
+        def with_location(new_location)
+          self.class.new(elements: elements, location: new_location)
+        end
+      end
+    end
+  end
+end