steep 1.0.0 → 1.1.0.pre.1

data/lib/steep/services/type_check_service.rb

@@ -335,25 +335,29 @@ module Steep
         SourceFile.with_syntax_error(path: path, content: text, error: error)
       rescue EncodingError => exn
         SourceFile.no_data(path: path, content: "")
+      rescue RuntimeError => exn
+        Steep.log_error(exn)
+        SourceFile.no_data(path: path, content: text)
       end
 
       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,
@@ -361,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)
@@ -370,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

@@ -58,9 +58,14 @@ module Steep
 
       def validate_type_application_constraints(type_name, type_params, type_args, location:)
         if type_params.size == type_args.size
+          subst = Interface::Substitution.build(
+            type_params.map(&:name),
+            type_args.map {|type| factory.type(type) }
+          )
+
           type_params.zip(type_args).each do |param, arg|
             if param.upper_bound
-              upper_bound_type = factory.type(param.upper_bound)
+              upper_bound_type = factory.type(param.upper_bound).subst(subst)
               arg_type = factory.type(arg)
 
               constraints = Subtyping::Constraints.empty
@@ -319,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/source.rb

@@ -39,7 +39,7 @@ module Steep
     end
 
     def self.new_parser
-      ::Parser::Ruby30.new(Builder.new).tap do |parser|
+      ::Parser::Ruby31.new(Builder.new).tap do |parser|
         parser.diagnostics.all_errors_are_fatal = true
         parser.diagnostics.ignore_warnings = true
       end

data/lib/steep/subtyping/check.rb

@@ -421,9 +421,6 @@ module Steep
         when relation.sub_type.is_a?(AST::Types::Proc) && relation.super_type.is_a?(AST::Types::Proc)
           name = :__proc__
 
-          sub_type = relation.sub_type
-          super_type = relation.super_type
-
           All(relation) do |result|
             result.add(relation.map {|p| p.type }) do |rel|
               check_function(name, rel)

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