steep 1.8.0.dev.2 → 1.8.0.pre.1

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

@@ -36,77 +36,103 @@ module Steep
           end
         end
 
-        def type(type)
-          unless type.location
-            if ty = type_cache[type]
-              return ty
+        def normalize_args(type_name, args)
+          case
+          when type_name.class?
+            if entry = env.normalized_module_class_entry(type_name)
+              type_params = entry.type_params
+            end
+          when type_name.interface?
+            if entry = env.interface_decls.fetch(type_name, nil)
+              type_params = entry.decl.type_params
+            end
+          when type_name.alias?
+            if entry = env.type_alias_decls.fetch(type_name, nil)
+              type_params = entry.decl.type_params
             end
           end
 
+          if type_params && !type_params.empty?
+            RBS::AST::TypeParam.normalize_args(type_params, args)
+          else
+            args
+          end
+        end
+
+        def type(type)
+          if ty = type_cache[type]
+            return ty
+          end
+
           type_cache[type] =
             case type
             when RBS::Types::Bases::Any
-              Any.new(location: type.location)
+              Any.instance
             when RBS::Types::Bases::Class
-              Class.new(location: type.location)
+              Class.instance
             when RBS::Types::Bases::Instance
-              Instance.new(location: type.location)
+              Instance.instance
             when RBS::Types::Bases::Self
-              Self.new(location: type.location)
+              Self.instance
             when RBS::Types::Bases::Top
-              Top.new(location: type.location)
+              Top.instance
             when RBS::Types::Bases::Bottom
-              Bot.new(location: type.location)
+              Bot.instance
             when RBS::Types::Bases::Bool
-              Boolean.new(location: type.location)
+              Boolean.instance
             when RBS::Types::Bases::Void
-              Void.new(location: type.location)
+              Void.instance
             when RBS::Types::Bases::Nil
-              Nil.new(location: type.location)
+              Nil.instance
             when RBS::Types::Variable
-              Var.new(name: type.name, location: type.location)
+              Var.new(name: type.name)
             when RBS::Types::ClassSingleton
               type_name = type.name
-              Name::Singleton.new(name: type_name, location: type.location)
+              Name::Singleton.new(name: type_name)
             when RBS::Types::ClassInstance
               type_name = type.name
-              args = type.args.map {|arg| type(arg) }
-              Name::Instance.new(name: type_name, args: args, location: type.location)
+              args = normalize_args(type_name, type.args).map {|arg| type(arg) }
+              Name::Instance.new(name: type_name, args: args)
             when RBS::Types::Interface
               type_name = type.name
-              args = type.args.map {|arg| type(arg) }
-              Name::Interface.new(name: type_name, args: args, location: type.location)
+              args = normalize_args(type_name, type.args).map {|arg| type(arg) }
+              Name::Interface.new(name: type_name, args: args)
             when RBS::Types::Alias
               type_name = type.name
-              args = type.args.map {|arg| type(arg) }
-              Name::Alias.new(name: type_name, args: args, location: type.location)
+              args = normalize_args(type_name, type.args).map {|arg| type(arg) }
+              Name::Alias.new(name: type_name, args: args)
             when RBS::Types::Union
-              Union.build(types: type.types.map {|ty| type(ty) }, location: type.location)
+              Union.build(types: type.types.map {|ty| type(ty) })
             when RBS::Types::Intersection
-              Intersection.build(types: type.types.map {|ty| type(ty) }, location: type.location)
+              Intersection.build(types: type.types.map {|ty| type(ty) })
             when RBS::Types::Optional
-              Union.build(types: [type(type.type), Nil.new(location: nil)], location: type.location)
+              Union.build(types: [type(type.type), Nil.instance()])
             when RBS::Types::Literal
-              Literal.new(value: type.literal, location: type.location)
+              Literal.new(value: type.literal)
             when RBS::Types::Tuple
-              Tuple.new(types: type.types.map {|ty| type(ty) }, location: type.location)
+              Tuple.new(types: type.types.map {|ty| type(ty) })
             when RBS::Types::Record
-              elements = type.fields.each.with_object({}) do |(key, value), hash|
-                hash[key] = type(value)
+              elements = {} #: Hash[Record::key, AST::Types::t]
+              required_keys = Set[] #: Set[Record::key]
+
+              type.all_fields.each do |key, (value, required)|
+                required_keys << key if required
+                elements[key] = type(value)
               end
-              Record.new(elements: elements, location: type.location)
+
+              Record.new(elements: elements, required_keys: required_keys)
             when RBS::Types::Proc
               func = Interface::Function.new(
                 params: params(type.type),
                 return_type: type(type.type.return_type),
-                location: type.location
+                location: nil
               )
               block = if type.block
                         Interface::Block.new(
                           type: Interface::Function.new(
                             params: params(type.block.type),
                             return_type: type(type.block.type.return_type),
-                            location: type.location
+                            location: nil
                           ),
                           optional: !type.block.required,
                           self_type: type_opt(type.block.self_type)
@@ -126,67 +152,69 @@ module Steep
         def type_1(type)
           case type
           when Any
-            RBS::Types::Bases::Any.new(location: type.location)
+            RBS::Types::Bases::Any.new(location: nil)
           when Class
-            RBS::Types::Bases::Class.new(location: type.location)
+            RBS::Types::Bases::Class.new(location: nil)
           when Instance
-            RBS::Types::Bases::Instance.new(location: type.location)
+            RBS::Types::Bases::Instance.new(location: nil)
           when Self
-            RBS::Types::Bases::Self.new(location: type.location)
+            RBS::Types::Bases::Self.new(location: nil)
           when Top
-            RBS::Types::Bases::Top.new(location: type.location)
+            RBS::Types::Bases::Top.new(location: nil)
           when Bot
-            RBS::Types::Bases::Bottom.new(location: type.location)
+            RBS::Types::Bases::Bottom.new(location: nil)
           when Boolean
-            RBS::Types::Bases::Bool.new(location: type.location)
+            RBS::Types::Bases::Bool.new(location: nil)
           when Void
-            RBS::Types::Bases::Void.new(location: type.location)
+            RBS::Types::Bases::Void.new(location: nil)
           when Nil
-            RBS::Types::Bases::Nil.new(location: type.location)
+            RBS::Types::Bases::Nil.new(location: nil)
           when Var
-            RBS::Types::Variable.new(name: type.name, location: type.location)
+            RBS::Types::Variable.new(name: type.name, location: nil)
           when Name::Singleton
-            RBS::Types::ClassSingleton.new(name: type.name, location: type.location)
+            RBS::Types::ClassSingleton.new(name: type.name, location: nil)
           when Name::Instance
             RBS::Types::ClassInstance.new(
               name: type.name,
               args: type.args.map {|arg| type_1(arg) },
-              location: type.location
+              location: nil
             )
           when Name::Interface
             RBS::Types::Interface.new(
               name: type.name,
               args: type.args.map {|arg| type_1(arg) },
-              location: type.location
+              location: nil
             )
           when Name::Alias
             RBS::Types::Alias.new(
               name: type.name,
               args: type.args.map {|arg| type_1(arg) },
-              location: type.location
+              location: nil
             )
           when Union
             RBS::Types::Union.new(
               types: type.types.map {|ty| type_1(ty) },
-              location: type.location
+              location: nil
             )
           when Intersection
             RBS::Types::Intersection.new(
               types: type.types.map {|ty| type_1(ty) },
-              location: type.location
+              location: nil
             )
           when Literal
-            RBS::Types::Literal.new(literal: type.value, location: type.location)
+            RBS::Types::Literal.new(literal: type.value, location: nil)
           when Tuple
             RBS::Types::Tuple.new(
               types: type.types.map {|ty| type_1(ty) },
-              location: type.location
+              location: nil
             )
           when Record
-            fields = type.elements.each.with_object({}) do |(key, value), hash|
-              hash[key] = type_1(value)
+            all_fields = {} #: Hash[Symbol, [RBS::Types::t, bool]]
+            type.elements.each do |key, value|
+              raise unless key.is_a?(Symbol)
+              all_fields[key] = [type_1(value), type.required?(key)]
             end
-            RBS::Types::Record.new(fields: fields, location: type.location)
+            RBS::Types::Record.new(all_fields: all_fields, location: nil)
           when Proc
             block = if type.block
                       RBS::Types::Block.new(
@@ -199,10 +227,10 @@ module Steep
               type: function_1(type.type),
               self_type: type_1_opt(type.self_type),
               block: block,
-              location: type.location
+              location: nil
             )
           when Logic::Base
-            RBS::Types::Bases::Bool.new(location: type.location)
+            RBS::Types::Bases::Bool.new(location: nil)
           else
             raise "Unexpected type given: #{type} (#{type.class})"
           end
@@ -247,9 +275,10 @@ module Steep
         def type_param(type_param)
           Interface::TypeParam.new(
             name: type_param.name,
-            upper_bound: type_opt(type_param.upper_bound),
+            upper_bound: type_opt(type_param.upper_bound_type),
             variance: type_param.variance,
-            unchecked: type_param.unchecked?
+            unchecked: type_param.unchecked?,
+            default_type: type_opt(type_param.default_type)
           )
         end
 
@@ -269,8 +298,8 @@ module Steep
           ).unchecked!(type_param.unchecked)
         end
 
-        def method_type(method_type, method_decls:)
-          mt = @method_type_cache[method_type] ||=
+        def method_type(method_type)
+          @method_type_cache[method_type] ||=
             Interface::MethodType.new(
               type_params: method_type.type_params.map {|param| type_param(param) },
               type: Interface::Function.new(
@@ -288,11 +317,8 @@ module Steep
                   ),
                   self_type: type_opt(block.self_type)
                 )
-              end,
-              method_decls: Set[]
+              end
             )
-
-          mt.with(method_decls: method_decls)
         end
 
         def method_type_1(method_type)
@@ -337,10 +363,10 @@ module Steep
             end
           when AST::Types::Union
             types = type.types.map {|ty| deep_expand_alias(ty, recursive: recursive) or return }
-            AST::Types::Union.build(types: types, location: type.location)
+            AST::Types::Union.build(types: types)
           when AST::Types::Intersection
             types = type.types.map {|ty| deep_expand_alias(ty, recursive: recursive) or return }
-            AST::Types::Intersection.build(types: types, location: type.location)
+            AST::Types::Intersection.build(types: types)
           else
             type
           end
@@ -445,11 +471,11 @@ module Steep
           type_name_resolver.resolve(type_name, context: context)
         end
 
-        def instance_type(type_name, args: nil, location: nil)
+        def instance_type(type_name, args: nil)
           raise unless type_name.class?
 
           definition = definition_builder.build_singleton(type_name)
-          def_args = definition.type_params.map { Any.new(location: nil) }
+          def_args = definition.type_params.map { Any.instance }
 
           if args
             raise if def_args.size != args.size
@@ -457,7 +483,7 @@ module Steep
             args = def_args
           end
 
-          AST::Types::Name::Instance.new(location: location, name: type_name, args: args)
+          AST::Types::Name::Instance.new(name: type_name, args: args)
         end
 
         def try_instance_type(type)
@@ -485,13 +511,11 @@ module Steep
           when AST::Types::Name::Instance
             AST::Types::Name::Instance.new(
               name: env.normalize_module_name(type.name),
-              args: type.args.map {|ty| normalize_type(ty) },
-              location: type.location
+              args: type.args.map {|ty| normalize_type(ty) }
             )
           when AST::Types::Name::Singleton
             AST::Types::Name::Singleton.new(
-              name: env.normalize_module_name(type.name),
-              location: type.location
+              name: env.normalize_module_name(type.name)
             )
           when AST::Types::Any, AST::Types::Boolean, AST::Types::Bot, AST::Types::Nil,
             AST::Types::Top, AST::Types::Void, AST::Types::Literal, AST::Types::Class, AST::Types::Instance,
@@ -499,37 +523,29 @@ module Steep
             type
           when AST::Types::Intersection
             AST::Types::Intersection.build(
-              types: type.types.map {|type| normalize_type(type) },
-              location: type.location
+              types: type.types.map {|type| normalize_type(type) }
             )
           when AST::Types::Union
             AST::Types::Union.build(
-              types: type.types.map {|type| normalize_type(type) },
-              location: type.location
+              types: type.types.map {|type| normalize_type(type) }
             )
           when AST::Types::Record
-            AST::Types::Record.new(
-              elements: type.elements.transform_values {|type| normalize_type(type) },
-              location: type.location
-            )
+            type.map_type {|type| normalize_type(type) }
           when AST::Types::Tuple
             AST::Types::Tuple.new(
-              types: type.types.map {|type| normalize_type(type) },
-              location: type.location
+              types: type.types.map {|type| normalize_type(type) }
             )
           when AST::Types::Proc
             type.map_type {|type| normalize_type(type) }
           when AST::Types::Name::Alias
             AST::Types::Name::Alias.new(
               name: type.name,
-              args: type.args.map {|ty| normalize_type(ty) },
-              location: type.location
+              args: type.args.map {|ty| normalize_type(ty) }
             )
           when AST::Types::Name::Interface
             AST::Types::Name::Interface.new(
               name: type.name,
-              args: type.args.map {|ty| normalize_type(ty) },
-              location: type.location
+              args: type.args.map {|ty| normalize_type(ty) }
             )
           end
         end

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

@@ -2,15 +2,7 @@ module Steep
   module AST
     module Types
       class Instance
-        attr_reader :location
-
-        def initialize(location: nil)
-          @location = location
-        end
-
-        def self.instance
-          @instance ||= new()
-        end
+        extend SharedInstance
 
         def ==(other)
           other.is_a?(Instance)
@@ -44,10 +36,6 @@ module Steep
         def level
           [0]
         end
-
-        def with_location(new_location)
-          self.class.new(location: new_location)
-        end
       end
     end
   end

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

@@ -3,14 +3,12 @@ module Steep
     module Types
       class Intersection
         attr_reader :types
-        attr_reader :location
 
-        def initialize(types:, location: nil)
+        def initialize(types:)
           @types = types
-          @location = location
         end
 
-        def self.build(types:, location: nil)
+        def self.build(types:)
           types.flat_map do |type|
             if type.is_a?(Intersection)
               type.types
@@ -20,9 +18,9 @@ module Steep
           end.map do |type|
             case type
             when AST::Types::Any
-              return AST::Types::Any.new(location: location)
+              return AST::Types::Any.instance()
             when AST::Types::Bot
-              return AST::Types::Bot.new(location: location)
+              return AST::Types::Bot.instance
             when AST::Types::Top
               nil
             else
@@ -33,11 +31,11 @@ module Steep
 
             case dups.size
             when 0
-              AST::Types::Top.new(location: location)
+              AST::Types::Top.instance
             when 1
               tys.first || raise
             else
-              new(types: dups.to_a, location: location)
+              new(types: dups.to_a)
             end
           end
         end
@@ -53,7 +51,7 @@ module Steep
         alias eql? ==
 
         def subst(s)
-          self.class.build(location: location, types: types.map {|ty| ty.subst(s) })
+          self.class.build(types: types.map {|ty| ty.subst(s) })
         end
 
         def to_s
@@ -82,18 +80,13 @@ module Steep
 
         def map_type(&block)
           self.class.build(
-            types: each_child.map(&block),
-            location: location
+            types: each_child.map(&block)
           )
         end
 
         def level
           [0] + level_of_children(types)
         end
-
-        def with_location(new_location)
-          self.class.new(types: types, location: new_location)
-        end
       end
     end
   end

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

@@ -2,11 +2,9 @@ module Steep
   module AST
     module Types
       class Literal
-        attr_reader :location
         attr_reader :value
 
-        def initialize(value:, location: nil)
-          @location = location
+        def initialize(value:)
           @value = value
         end
 
@@ -37,10 +35,6 @@ module Steep
           [0]
         end
 
-        def with_location(new_location)
-          _ = self.class.new(value: value, location: new_location)
-        end
-
         def back_type
           klass = case value
                   when Integer
@@ -57,7 +51,7 @@ module Steep
                     raise "Unexpected literal type: #{(_ = value).inspect}"
                   end
 
-          Name::Instance.new(name: klass.module_name, args: [], location: location)
+          Name::Instance.new(name: klass.module_name, args: [])
         end
       end
     end

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

@@ -3,8 +3,8 @@ module Steep
     module Types
       module Logic
         class Base
-          attr_reader :location
-
+          extend SharedInstance
+          
           def subst(s)
             self
           end
@@ -33,51 +33,30 @@ module Steep
         end
 
         class Not < Base
-          def initialize(location: nil)
-            @location = location
-          end
         end
 
         class ReceiverIsNil < Base
-          def initialize(location: nil)
-            @location = location
-          end
         end
 
         class ReceiverIsNotNil < Base
-          def initialize(location: nil)
-            @location = location
-          end
         end
 
         class ReceiverIsArg < Base
-          def initialize(location: nil)
-            @location = location
-          end
         end
 
         class ArgIsReceiver < Base
-          def initialize(location: nil)
-            @location = location
-          end
         end
 
         class ArgEqualsReceiver < Base
-          def initialize(location: nil)
-            @location = location
-          end
         end
 
         class ArgIsAncestor < Base
-          def initialize(location: nil)
-            @location = location
-          end
         end
 
         class Env < Base
           attr_reader :truthy, :falsy, :type
 
-          def initialize(truthy:, falsy:, type:, location: nil)
+          def initialize(truthy:, falsy:, type:)
             @truthy = truthy
             @falsy = falsy
             @type = type

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

@@ -3,11 +3,9 @@ module Steep
     module Types
       module Name
         class Base
-          attr_reader :location
           attr_reader :name
 
-          def initialize(name:, location: nil)
-            @location = location
+          def initialize(name:)
             @name = name
           end
 
@@ -29,8 +27,8 @@ module Steep
         class Applying < Base
           attr_reader :args
 
-          def initialize(name:, args:, location: nil)
-            super(name: name, location: location)
+          def initialize(name:, args:)
+            super(name: name)
             @args = args
           end
 
@@ -54,14 +52,9 @@ module Steep
             end
           end
 
-          def with_location(new_location)
-            _ = self.class.new(name: name, args: args, location: new_location)
-          end
-
           def subst(s)
             if free_variables.intersect?(s.domain)
               _ = self.class.new(
-                location: location,
                 name: name,
                 args: args.map {|a| a.subst(s) }
               )
@@ -95,7 +88,7 @@ module Steep
           def map_type(&block)
             args = self.args.map(&block)
 
-            _ = self.class.new(name: self.name, args: self.args, location: self.location)
+            _ = self.class.new(name: self.name, args: self.args)
           end
         end
 
@@ -115,16 +108,12 @@ module Steep
             "singleton(#{name.to_s})"
           end
 
-          def with_location(new_location)
-            self.class.new(name: name, location: new_location)
-          end
-
           include Helper::NoChild
         end
 
         class Instance < Applying
           def to_module
-            Singleton.new(name: name, location: location)
+            Singleton.new(name: name)
           end
         end
 

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

@@ -2,12 +2,8 @@ module Steep
   module AST
     module Types
       class Nil
-        attr_reader :location
-
-        def initialize(location: nil)
-          @location = location
-        end
-
+        extend SharedInstance
+        
         def ==(other)
           other.is_a?(Nil)
         end
@@ -34,14 +30,9 @@ module Steep
           [0]
         end
 
-        def with_location(new_location)
-          self.class.new(location: new_location)
-        end
-
         def back_type
           Name::Instance.new(name: Builtin::NilClass.module_name,
-                             args: [],
-                             location: location)
+                             args: [])
         end
       end
     end