steep 0.14.0 → 0.15.0

data/lib/steep/project/file.rb

@@ -31,14 +31,6 @@ module Steep
         case status
         when TypeCheckStatus
           status.typing.errors
-          # errors.reject do |error|
-          #   case
-          #   when error.is_a?(Errors::FallbackAny)
-          #     !options.fallback_any_is_error
-          #   when error.is_a?(Errors::MethodDefinitionMissing)
-          #     options.allow_missing_definitions
-          #   end
-          # end
         else
           []
         end
@@ -49,40 +41,45 @@ module Steep
       end
 
       def self.type_check(source, subtyping:)
-        typing = Typing.new
-
-        if source
-          annotations = source.annotations(block: source.node, factory: subtyping.factory, current_module: AST::Namespace.root)
-          const_env = TypeInference::ConstantEnv.new(factory: subtyping.factory, context: nil)
-          type_env = TypeInference::TypeEnv.build(annotations: annotations,
-                                                  subtyping: subtyping,
-                                                  const_env: const_env,
-                                                  signatures: subtyping.factory.env)
-
-          construction = TypeConstruction.new(
-            checker: subtyping,
-            annotations: annotations,
-            source: source,
-            context: TypeInference::Context.new(
-              block_context: nil,
-              module_context: TypeInference::Context::ModuleContext.new(
-                instance_type: nil,
-                module_type: nil,
-                implement_name: nil,
-                current_namespace: AST::Namespace.root,
-                const_env: const_env,
-                class_name: nil
-              ),
-              method_context: nil,
-              break_context: nil,
-              self_type: AST::Builtin::Object.instance_type,
-              type_env: type_env
-            ),
-            typing: typing
-          )
-
-          construction.synthesize(source.node)
-        end
+        annotations = source.annotations(block: source.node, factory: subtyping.factory, current_module: AST::Namespace.root)
+        const_env = TypeInference::ConstantEnv.new(factory: subtyping.factory, context: nil)
+        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
+        ).annotate(annotations)
+
+        context = TypeInference::Context.new(
+          block_context: nil,
+          module_context: TypeInference::Context::ModuleContext.new(
+            instance_type: nil,
+            module_type: nil,
+            implement_name: nil,
+            current_namespace: AST::Namespace.root,
+            const_env: const_env,
+            class_name: nil
+          ),
+          method_context: nil,
+          break_context: nil,
+          self_type: AST::Builtin::Object.instance_type,
+          type_env: type_env,
+          lvar_env: lvar_env
+        )
+
+        typing = Typing.new(source: source, root_context: context)
+
+        construction = TypeConstruction.new(
+          checker: subtyping,
+          annotations: annotations,
+          source: source,
+          context: context,
+          typing: typing
+        )
+
+        construction.synthesize(source.node) if source.node
 
         typing
       end
@@ -93,7 +90,6 @@ module Steep
 
         parse(subtyping.factory) do |source|
           typing = self.class.type_check(source, subtyping: subtyping)
-
           @status = TypeCheckStatus.new(
             typing: typing,
             source: source,
@@ -143,10 +139,10 @@ module Steep
       end
 
       def load!
-        buffer = Ruby::Signature::Buffer.new(name: path, content: content)
-        decls = Ruby::Signature::Parser.parse_signature(buffer)
+        buffer = RBS::Buffer.new(name: path, content: content)
+        decls = RBS::Parser.parse_signature(buffer)
         @status = DeclarationsStatus.new(declarations: decls)
-      rescue Ruby::Signature::Parser::SyntaxError, Ruby::Signature::Parser::SemanticsError => exn
+      rescue RBS::Parser::SyntaxError, RBS::Parser::SemanticsError => exn
         @status = ParseErrorStatus.new(error: exn)
       end
     end

data/lib/steep/project/hover_content.rb

@@ -42,12 +42,18 @@ module Steep
 
             if node
               case node.type
-              when :lvar, :lvasgn
+              when :lvar
                 var_name = node.children[0]
-                context = status.typing.context_of(node: node)
-                var_type = context.type_env.get(lvar: var_name.name)
+                context = status.typing.context_at(line: line, column: column)
+                var_type = context.lvar_env[var_name.name] || AST::Types::Any.new(location: nil)
 
                 VariableContent.new(node: node, name: var_name.name, type: var_type, location: node.location.name)
+              when :lvasgn
+                var_name, rhs = node.children
+                context = status.typing.context_at(line: line, column: column)
+                type = context.lvar_env[var_name.name] || status.typing.type_of(node: rhs)
+
+                VariableContent.new(node: node, name: var_name.name, type: type, location: node.location.name)
               when :send
                 receiver, method_name, *_ = node.children
 
@@ -58,7 +64,7 @@ module Steep
                                 node
                               end
 
-                context = status.typing.context_of(node: result_node)
+                context = status.typing.context_at(line: line, column: column)
 
                 receiver_type = if receiver
                                   status.typing.type_of(node: receiver)
@@ -98,7 +104,7 @@ module Steep
                   location: result_node.location.expression
                 )
               when :def, :defs
-                context = status.typing.context_of(node: node)
+                context = status.typing.context_at(line: line, column: column)
                 method_context = context.method_context
 
                 if method_context

data/lib/steep/project/options.rb

@@ -1,20 +1,42 @@
 module Steep
   class Project
     class Options
-      attr_accessor :fallback_any_is_error
+      attr_accessor :allow_fallback_any
       attr_accessor :allow_missing_definitions
+      attr_accessor :allow_unknown_constant_assignment
+      attr_accessor :allow_unknown_method_calls
       attr_accessor :vendored_stdlib_path
       attr_accessor :vendored_gems_path
       attr_reader :libraries
 
       def initialize
-        self.fallback_any_is_error = false
-        self.allow_missing_definitions = true
+        apply_default_typing_options!
         self.vendored_gems_path = nil
         self.vendored_stdlib_path = nil
 
         @libraries = []
       end
+
+      def apply_default_typing_options!
+        self.allow_fallback_any = true
+        self.allow_missing_definitions = true
+        self.allow_unknown_constant_assignment = false
+        self.allow_unknown_method_calls = false
+      end
+
+      def apply_strict_typing_options!
+        self.allow_fallback_any = false
+        self.allow_missing_definitions = false
+        self.allow_unknown_constant_assignment = false
+        self.allow_unknown_method_calls = false
+      end
+
+      def apply_lenient_typing_options!
+        self.allow_fallback_any = true
+        self.allow_missing_definitions = true
+        self.allow_unknown_constant_assignment = true
+        self.allow_unknown_method_calls = true
+      end
     end
   end
 end

data/lib/steep/project/target.rb

@@ -89,10 +89,10 @@ module Steep
       end
 
       def environment
-        @environment ||= Ruby::Signature::Environment.new().tap do |env|
-          stdlib_root = options.vendored_stdlib_path || Ruby::Signature::EnvironmentLoader::STDLIB_ROOT
+        @environment ||= RBS::Environment.new().tap do |env|
+          stdlib_root = options.vendored_stdlib_path || RBS::EnvironmentLoader::STDLIB_ROOT
           gem_vendor_path = options.vendored_gems_path
-          loader = Ruby::Signature::EnvironmentLoader.new(stdlib_root: stdlib_root, gem_vendor_path: gem_vendor_path)
+          loader = RBS::EnvironmentLoader.new(stdlib_root: stdlib_root, gem_vendor_path: gem_vendor_path)
           options.libraries.each do |lib|
             loader.add(library: lib)
           end
@@ -129,7 +129,7 @@ module Steep
               end
             end
 
-            definition_builder = Ruby::Signature::DefinitionBuilder.new(env: env)
+            definition_builder = RBS::DefinitionBuilder.new(env: env)
             factory = AST::Types::Factory.new(builder: definition_builder)
             check = Subtyping::Check.new(factory: factory)
 
@@ -177,6 +177,12 @@ module Steep
         )
       end
 
+      def no_error?
+        source_files.all? do |_, file|
+          file.status.is_a?(Project::SourceFile::TypeCheckStatus)
+        end
+      end
+
       def errors
         case status
         when TypeCheckStatus

data/lib/steep/signature/errors.rb

@@ -5,7 +5,7 @@ module Steep
         attr_reader :location
 
         def loc_to_s
-          Ruby::Signature::Location.to_string location
+          RBS::Location.to_string location
         end
 
         def to_s

data/lib/steep/signature/validator.rb

@@ -1,8 +1,8 @@
 module Steep
   module Signature
     class Validator
-      Location = Ruby::Signature::Location
-      Declarations = Ruby::Signature::AST::Declarations
+      Location = RBS::Location
+      Declarations = RBS::AST::Declarations
 
       attr_reader :checker
 
@@ -53,17 +53,17 @@ module Steep
           rescue_validation_errors do
             Steep.logger.info "#{Location.to_string decl.location}:\tValidating class definition `#{name}`..."
             builder.build_instance(decl.name.absolute!).each_type do |type|
-              env.validate type, namespace: Ruby::Signature::Namespace.root
+              env.validate type, namespace: RBS::Namespace.root
             end
             builder.build_singleton(decl.name.absolute!).each_type do |type|
-              env.validate type, namespace: Ruby::Signature::Namespace.root
+              env.validate type, namespace: RBS::Namespace.root
             end
           end
         when Declarations::Interface
           rescue_validation_errors do
             Steep.logger.info "#{Location.to_string decl.location}:\tValidating interface `#{name}`..."
             builder.build_interface(decl.name.absolute!, decl).each_type do |type|
-              env.validate type, namespace: Ruby::Signature::Namespace.root
+              env.validate type, namespace: RBS::Namespace.root
             end
           end
         end
@@ -88,7 +88,7 @@ module Steep
         env.each_global do |name, decl|
           rescue_validation_errors do
             Steep.logger.info "#{Location.to_string decl.location}:\tValidating global `#{name}`..."
-            env.validate(decl.type, namespace: Ruby::Signature::Namespace.root)
+            env.validate(decl.type, namespace: RBS::Namespace.root)
           end
         end
       end
@@ -104,14 +104,14 @@ module Steep
 
       def rescue_validation_errors
         yield
-      rescue Ruby::Signature::InvalidTypeApplicationError => exn
+      rescue RBS::InvalidTypeApplicationError => exn
         @errors << Errors::InvalidTypeApplicationError.new(
           name: factory.type_name(exn.type_name),
           args: exn.args.map {|ty| factory.type(ty) },
           params: exn.params.each.map(&:name),
           location: exn.location
         )
-      rescue Ruby::Signature::NoTypeFoundError => exn
+      rescue RBS::NoTypeFoundError => exn
         @errors << Errors::UnknownTypeNameError.new(
           name: factory.type_name(exn.type_name),
           location: exn.location

data/lib/steep/source.rb

@@ -51,7 +51,7 @@ module Steep
         if n
           labeling.translate(n, {})
         else
-          return
+          return new(path: path, node: nil, mapping: {})
         end
       end