steep 1.0.2 → 1.1.0.pre.1

data/lib/steep/services/hover_provider/ruby.rb

@@ -2,22 +2,36 @@ module Steep
   module Services
     module HoverProvider
       class Ruby
-        TypeContent = Struct.new(:node, :type, :location, keyword_init: true)
-        VariableContent = Struct.new(:node, :name, :type, :location, keyword_init: true)
-        MethodCallContent = Struct.new(:node, :method_call, :location, keyword_init: true)
-        DefinitionContent = Struct.new(:node, :method_name, :method_type, :definition, :location, keyword_init: true)
-        ConstantContent = Struct.new(:location, :full_name, :type, :decl, keyword_init: true) do
+        TypeContent = _ = Struct.new(:node, :type, :location, keyword_init: true)
+        VariableContent = _ = Struct.new(:node, :name, :type, :location, keyword_init: true)
+        MethodCallContent = _ = Struct.new(:node, :method_call, :location, keyword_init: true)
+        DefinitionContent = _ = Struct.new(:node, :method_name, :method_type, :definition, :location, keyword_init: true)
+        ConstantContent = _ = Struct.new(:location, :full_name, :type, :decl, keyword_init: true) do
+          # @implements ConstantContent
+
           def comments
             case
-            when class_or_module?
-              decl.decls.filter_map {|d| d.decl.comment }
-            when constant?
+            when decl = class_decl
+              decl.decls.map {|d| d.decl.comment }
+            when decl = constant_decl
               [decl.decl.comment]
             else
-              []
+              raise
             end.compact
           end
 
+          def class_decl
+            if (decl = decl()).is_a?(::RBS::Environment::MultiEntry)
+              decl
+            end
+          end
+
+          def constant_decl
+            if (decl = decl()).is_a?(::RBS::Environment::SingleEntry)
+              decl
+            end
+          end
+
           def constant?
             decl.is_a?(::RBS::Environment::SingleEntry)
           end
@@ -49,6 +63,8 @@ module Steep
             else
               methods[singleton_method]
             end
+          else
+            raise "One of the instance_method or singleton_method is required"
           end
         end
 
@@ -72,6 +88,8 @@ module Steep
               InstanceMethodName.new(type_name: defined_in, method_name: method_name)
             when builder.build_singleton(defined_in).methods.key?(method_name)
               SingletonMethodName.new(type_name: defined_in, method_name: method_name)
+            else
+              raise
             end
           else
             InstanceMethodName.new(type_name: defined_in, method_name: method_name)
@@ -83,19 +101,19 @@ module Steep
           typing = typecheck(target, path: path, content: file.content, line: line, column: column) or return
           node, *parents = typing.source.find_nodes(line: line, column: column)
 
-          if node
+          if node && parents
             case node.type
             when :lvar
               var_name = node.children[0]
               context = typing.context_at(line: line, column: column)
-              var_type = context.lvar_env[var_name] || AST::Types::Any.new(location: nil)
+              var_type = context.type_env[var_name] || AST::Types::Any.new(location: nil)
 
               return VariableContent.new(node: node, name: var_name, type: var_type, location: node.location.name)
 
             when :lvasgn
               var_name, rhs = node.children
               context = typing.context_at(line: line, column: column)
-              type = context.lvar_env[var_name] || typing.type_of(node: rhs)
+              type = context.type_env[var_name] || typing.type_of(node: node)
 
               return VariableContent.new(node: node, name: var_name, type: type, location: node.location.name)
 

data/lib/steep/services/type_check_service.rb

@@ -342,21 +342,22 @@ module Steep
 
       def self.type_check(source:, subtyping:)
         annotations = source.annotations(block: source.node, factory: subtyping.factory, context: nil)
+
+        definition = subtyping.factory.definition_builder.build_instance(AST::Builtin::Object.module_name)
+
         const_env = TypeInference::ConstantEnv.new(
           factory: subtyping.factory,
           context: nil,
           resolver: RBS::Resolver::ConstantResolver.new(builder: subtyping.factory.definition_builder)
         )
-        type_env = TypeInference::TypeEnv.build(annotations: annotations,
-                                                subtyping: subtyping,
-                                                const_env: const_env,
-                                                signatures: subtyping.factory.env)
-        lvar_env = TypeInference::LocalVariableTypeEnv.empty(
-          subtyping: subtyping,
-          self_type: AST::Builtin::Object.instance_type,
-          instance_type: AST::Builtin::Object.instance_type,
-          class_type: AST::Builtin::Object.module_type
-        ).annotate(annotations)
+        type_env = TypeInference::TypeEnv.new(const_env)
+        type_env = TypeInference::TypeEnvBuilder.new(
+          TypeInference::TypeEnvBuilder::Command::ImportConstantAnnotations.new(annotations),
+          TypeInference::TypeEnvBuilder::Command::ImportGlobalDeclarations.new(subtyping.factory),
+          TypeInference::TypeEnvBuilder::Command::ImportInstanceVariableDefinition.new(definition, subtyping.factory),
+          TypeInference::TypeEnvBuilder::Command::ImportInstanceVariableAnnotations.new(annotations),
+          TypeInference::TypeEnvBuilder::Command::ImportLocalVariableAnnotations.new(annotations)
+        ).build(type_env)
 
         context = TypeInference::Context.new(
           block_context: nil,
@@ -364,7 +365,7 @@ module Steep
             instance_type: AST::Builtin::Object.instance_type,
             module_type: AST::Builtin::Object.module_type,
             implement_name: nil,
-            const_env: const_env,
+            nesting: nil,
             class_name: AST::Builtin::Object.module_name,
             instance_definition: subtyping.factory.definition_builder.build_instance(AST::Builtin::Object.module_name),
             module_definition: subtyping.factory.definition_builder.build_singleton(AST::Builtin::Object.module_name)
@@ -373,7 +374,6 @@ module Steep
           break_context: nil,
           self_type: AST::Builtin::Object.instance_type,
           type_env: type_env,
-          lvar_env: lvar_env,
           call_context: TypeInference::MethodCall::TopLevelContext.new,
           variable_context: TypeInference::Context::TypeVariableContext.empty
         )

data/lib/steep/shims/symbol_start_with.rb

@@ -0,0 +1,18 @@
+# Steep runs on Ruby 2.6 and it needs a shim of `Symbol#start_with?`
+
+module Shims
+  module SymbolStartWith
+    def start_with?(*args)
+      to_s.start_with?(*args)
+    end
+
+    def end_with?(*args)
+      to_s.end_with?(*args)
+    end
+  end
+
+  unless Symbol.method_defined?(:start_with?)
+    Symbol.include(SymbolStartWith)
+  end
+end
+

data/lib/steep/signature/validator.rb

@@ -324,6 +324,25 @@ module Steep
                 end
               end
 
+              definition.class_variables.each do |name, var|
+                if var.declared_in == definition.type_name
+                  if (parent = var.parent_variable) && var.declared_in != parent.declared_in
+                    class_var = definition.entry.decls.flat_map {|decl| decl.decl.members }.find do |member|
+                      member.is_a?(RBS::AST::Members::ClassVariable) && member.name == name
+                    end
+
+                    if class_var
+                      @errors << Diagnostic::Signature::ClassVariableDuplicationError.new(
+                        class_name: definition.type_name,
+                        other_class_name: parent.declared_in,
+                        variable_name: name,
+                        location: class_var.location[:name]
+                      )
+                    end
+                  end
+                end
+              end
+
               ancestors = builder.ancestor_builder.one_singleton_ancestors(name)
               mixin_constraints(definition, ancestors.extended_modules, immediate_self_types: ancestors.self_types).each do |relation, ancestor|
                 checker.check(

data/lib/steep/subtyping/constraints.rb

@@ -124,10 +124,10 @@ module Steep
           skips << type if skip
         end
 
-        super_fvs = supers.each.with_object(Set.new) do |type, fvs|
+        super_fvs = supers.each_with_object(Set.new) do |type, fvs|
           fvs.merge(type.free_variables)
         end
-        sub_fvs = subs.each.with_object(Set.new) do |type, fvs|
+        sub_fvs = subs.each_with_object(Set.new) do |type, fvs|
           fvs.merge(type.free_variables)
         end
 
@@ -169,6 +169,18 @@ module Steep
           else
             type
           end
+        when AST::Types::Tuple
+          AST::Types::Tuple.new(
+            types: type.types.map {|ty| eliminate_variable(ty, to: AST::Builtin.any_type) },
+            location: type.location
+          )
+        when AST::Types::Record
+          AST::Types::Record.new(
+            elements: type.elements.transform_values {|ty| eliminate_variable(ty, to: AST::Builtin.any_type) },
+            location: type.location
+          )
+        when AST::Types::Proc
+          type.map_type {|ty| eliminate_variable(ty, to: AST::Builtin.any_type) }
         else
           type
         end
@@ -193,34 +205,36 @@ module Steep
       end
 
       def upper_bound(var, skip: false)
-        _, upper_bound, skips = dictionary[var]
-        upper_bound -= skips if skip
+        if skip
+          upper_bound = upper_bound_types(var)
+        else
+          _, upper_bound, _ = dictionary[var]
+        end
 
         case upper_bound.size
         when 0
           AST::Types::Top.new
         when 1
-          upper_bound.first
+          upper_bound.first || raise
         else
           AST::Types::Intersection.build(types: upper_bound.to_a)
         end
       end
 
       def lower_bound(var, skip: false)
-        lower_bound, _, skips = dictionary[var]
-        lower_bound -= skips if skip
+        lower_bound = lower_bound_types(var)
 
         case lower_bound.size
         when 0
           AST::Types::Bot.new
         when 1
-          lower_bound.first
+          lower_bound.first || raise
         else
           AST::Types::Union.build(types: lower_bound.to_a)
         end
       end
 
-      Context = Struct.new(:variance, :self_type, :instance_type, :class_type, keyword_init: true)
+      Context = _ = Struct.new(:variance, :self_type, :instance_type, :class_type, keyword_init: true)
 
       def solution(checker, variance: nil, variables:, self_type: nil, instance_type: nil, class_type: nil, context: nil)
         if context
@@ -288,16 +302,13 @@ module Steep
       end
 
       def has_constraint?(var)
-        lower, upper, skips = dictionary[var]
-        lower -= skips
-        upper -= skips
-        !lower.empty? || !upper.empty?
+        !upper_bound_types(var).empty? || !lower_bound_types(var).empty?
       end
 
       def each
         if block_given?
           dictionary.each_key do |var|
-            yield var, lower_bound(var), upper_bound(var)
+            yield [var, lower_bound(var), upper_bound(var)]
           end
         else
           enum_for :each
@@ -311,6 +322,24 @@ module Steep
 
         "#{unknowns.to_a.join(",")}/#{vars.to_a.join(",")} |- { #{strings.join(", ")} }"
       end
+
+      def lower_bound_types(var_name)
+        lower, _, _ = dictionary[var_name]
+        lower
+      end
+
+      def upper_bound_types(var_name)
+        _, upper, skips = dictionary[var_name]
+
+        case
+        when upper.empty?
+          skips
+        when skips.empty?
+          upper
+        else
+          upper - skips
+        end
+      end
     end
   end
 end