steep 0.37.0 → 0.38.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f3d9186b6988081611f8bf060700ad97eb408ab605ab11ab32b717b9a0e9b8b9
-  data.tar.gz: 6f308f7bd551472237d5857614b765468782290733514793b2dfe35a3ac232cf
+  metadata.gz: 1662ab3cd8c9b1630d38939e491bd9db3b46701a5ab6f09061e4470c95fbbae8
+  data.tar.gz: 9fea79ba28f595b1a51812708c0b3a98170110f0367a0baa287623232fe64156
 SHA512:
-  metadata.gz: 1fee308a7783a6e54c974c71c78189492c0f557528bccb0da530927cfdb4e4a16f4ff6cd2ec9f8c3292dd9839bb1637f68fd3aff9da0fef6783e3f4b5d838984
-  data.tar.gz: 7cd72caf879d339e5fec0bed219957befd40d5dc2466b345435f4b523c8028a9264404b1d9c695c11ca638b8e6bbeb1d1ad8f600367cd87bf9b3c4fade99eeaa
+  metadata.gz: 2f42e7e12ff24d1d4acbebc7693b1bb7f1417f4d44f0cc2b2590990a50a1c20ee690d23a316414113e9a65601971cd3bf19b13babc9e09a64cfcebae1fe8c4ec
+  data.tar.gz: 6aa3693092fa2811fe0663c4266ed3cf9ccd2b79d7e0e8e6c3c79e3c3a29b1d19954ac0127ed0c62a1619dac2555c67ae987f3a4386001cbdf6a73a76e405829

data/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## master
 
+## 0.38.0 (2020-12-10)
+
+* Improve `break`/`next` typing ([#271](https://github.com/soutaro/steep/pull/271))
+* Add LSP `workspace/symbol` feature ([#267](https://github.com/soutaro/steep/pull/267))
+
 ## 0.37.0 (2020-12-06)
 
 * Update to RBS 0.20.0 with _singleton attribute_ syntax and _proc types with blocks_. ([#264](https://github.com/soutaro/steep/pull/264))

data/lib/steep.rb

@@ -76,6 +76,10 @@ require "steep/type_inference/logic_type_interpreter"
 require "steep/type_inference/method_call"
 require "steep/ast/types"
 
+require "steep/index/rbs_index"
+require "steep/index/signature_symbol_provider"
+require "steep/index/source_index"
+
 require "steep/server/utils"
 require "steep/server/base_worker"
 require "steep/server/code_worker"

data/lib/steep/errors.rb

@@ -195,6 +195,25 @@ module Steep
       end
     end
 
+    class BlockBodyTypeMismatch < Base
+      attr_reader :expected
+      attr_reader :actual
+      attr_reader :result
+
+      include ResultPrinter
+
+      def initialize(node:, expected:, actual:, result:)
+        super(node: node)
+        @expected = expected
+        @actual = actual
+        @result = result
+      end
+
+      def to_s
+        "#{location_to_str}: BlockBodyTypeMismatch: expected=#{expected}, actual=#{actual}"
+      end
+    end
+
     class BreakTypeMismatch < Base
       attr_reader :expected
       attr_reader :actual

data/lib/steep/index/rbs_index.rb

@@ -0,0 +1,334 @@
+module Steep
+  module Index
+    class RBSIndex
+      class TypeEntry
+        attr_reader :type_name
+        attr_reader :declarations
+        attr_reader :references
+
+        def initialize(type_name:)
+          @type_name = type_name
+          @declarations = Set[]
+          @references = Set[]
+        end
+
+        def add_declaration(decl)
+          case decl
+          when RBS::AST::Declarations::Class, RBS::AST::Declarations::Module
+            declarations << decl
+          when RBS::AST::Declarations::Interface
+            declarations << decl
+          when RBS::AST::Declarations::Alias
+            declarations << decl
+          else
+            raise "Unexpected type declaration: #{decl}"
+          end
+
+          self
+        end
+
+        def add_reference(ref)
+          case ref
+          when RBS::AST::Members::MethodDefinition
+            references << ref
+          when RBS::AST::Members::AttrAccessor, RBS::AST::Members::AttrReader, RBS::AST::Members::AttrWriter
+            references << ref
+          when RBS::AST::Members::InstanceVariable, RBS::AST::Members::ClassInstanceVariable, RBS::AST::Members::ClassVariable
+            references << ref
+          when RBS::AST::Members::Include, RBS::AST::Members::Extend
+            references << ref
+          when RBS::AST::Declarations::Module, RBS::AST::Declarations::Class
+            references << ref
+          when RBS::AST::Declarations::Constant, RBS::AST::Declarations::Global
+            references << ref
+          when RBS::AST::Declarations::Alias
+            references << ref
+          else
+            raise "Unexpected type reference: #{ref}"
+          end
+
+          self
+        end
+      end
+
+      class MethodEntry
+        attr_reader :method_name
+        attr_reader :declarations
+        attr_reader :references
+
+        def initialize(method_name:)
+          @method_name = method_name
+          @declarations = Set[]
+          @references = Set[]
+        end
+
+        def add_declaration(decl)
+          case decl
+          when RBS::AST::Members::MethodDefinition,
+            RBS::AST::Members::Alias,
+            RBS::AST::Members::AttrWriter,
+            RBS::AST::Members::AttrReader,
+            RBS::AST::Members::AttrAccessor
+            declarations << decl
+          else
+            raise "Unexpected method declaration: #{decl}"
+          end
+
+          self
+        end
+      end
+
+      class ConstantEntry
+        attr_reader :const_name
+        attr_reader :declarations
+
+        def initialize(const_name:)
+          @const_name = const_name
+          @declarations = Set[]
+        end
+
+        def add_declaration(decl)
+          case decl
+          when RBS::AST::Declarations::Constant
+            declarations << decl
+          else
+            raise
+          end
+
+          self
+        end
+      end
+
+      class GlobalEntry
+        attr_reader :global_name
+        attr_reader :declarations
+
+        def initialize(global_name:)
+          @global_name = global_name
+          @declarations = Set[]
+        end
+
+        def add_declaration(decl)
+          case decl
+          when RBS::AST::Declarations::Global
+            declarations << decl
+          else
+            raise
+          end
+
+          self
+        end
+      end
+
+      attr_reader :type_index
+      attr_reader :method_index
+      attr_reader :const_index
+      attr_reader :global_index
+
+      def initialize()
+        @type_index = {}
+        @method_index = {}
+        @const_index = {}
+        @global_index = {}
+      end
+
+      def entry(type_name: nil, method_name: nil, const_name: nil, global_name: nil)
+        case
+        when type_name
+          type_index[type_name] ||= TypeEntry.new(type_name: type_name)
+        when method_name
+          method_index[method_name] ||= MethodEntry.new(method_name: method_name)
+        when const_name
+          const_index[const_name] ||= ConstantEntry.new(const_name: const_name)
+        when global_name
+          global_index[global_name] ||= GlobalEntry.new(global_name: global_name)
+        else
+          raise
+        end
+      end
+
+      def each_entry(&block)
+        if block_given?
+          type_index.each_value(&block)
+          method_index.each_value(&block)
+          const_index.each_value(&block)
+          global_index.each_value(&block)
+        else
+          enum_for(:each_entry)
+        end
+      end
+
+      def add_type_declaration(type_name, declaration)
+        entry(type_name: type_name).add_declaration(declaration)
+      end
+
+      def add_method_declaration(method_name, member)
+        entry(method_name: method_name).add_declaration(member)
+      end
+
+      def add_constant_declaration(const_name, decl)
+        entry(const_name: const_name).add_declaration(decl)
+      end
+
+      def add_global_declaration(global_name, decl)
+        entry(global_name: global_name).add_declaration(decl)
+      end
+
+      def each_declaration(type_name: nil, method_name: nil, const_name: nil, global_name: nil, &block)
+        if block
+          entry = entry(type_name: type_name, method_name: method_name, const_name: const_name, global_name: global_name)
+          entry.declarations.each(&block)
+        else
+          enum_for(:each_declaration, type_name: type_name, method_name: method_name, const_name: const_name, global_name: global_name)
+        end
+      end
+
+      def add_type_reference(type_name, ref)
+        entry(type_name: type_name).add_reference(ref)
+      end
+
+      def each_reference(type_name: nil, &block)
+        if block
+          entry(type_name: type_name).references.each(&block)
+        else
+          enum_for(:each_reference, type_name: type_name)
+        end
+      end
+
+      class Builder
+        attr_reader :index
+
+        def initialize(index:)
+          @index = index
+        end
+
+        def member(type_name, member)
+          case member
+          when RBS::AST::Members::MethodDefinition
+            member.types.each do |method_type|
+              method_type.each_type do |type|
+                type_reference type, from: member
+              end
+            end
+
+            if member.instance?
+              method_name = InstanceMethodName.new(type_name: type_name, method_name: member.name)
+              index.add_method_declaration(method_name, member)
+            end
+
+            if member.singleton?
+              method_name = SingletonMethodName.new(type_name: type_name, method_name: member.name)
+              index.add_method_declaration(method_name, member)
+            end
+
+          when RBS::AST::Members::AttrAccessor, RBS::AST::Members::AttrReader, RBS::AST::Members::AttrWriter
+            type_reference member.type, from: member
+
+            if member.is_a?(RBS::AST::Members::AttrReader) || member.is_a?(RBS::AST::Members::AttrAccessor)
+              method_name = case member.kind
+                            when :instance
+                              InstanceMethodName.new(type_name: type_name, method_name: member.name)
+                            when :singleton
+                              SingletonMethodName.new(type_name: type_name, method_name: member.name)
+                            end
+              index.add_method_declaration(method_name, member)
+            end
+
+            if member.is_a?(RBS::AST::Members::AttrWriter) || member.is_a?(RBS::AST::Members::AttrAccessor)
+              method_name = case member.kind
+                            when :instance
+                              InstanceMethodName.new(type_name: type_name, method_name: "#{member.name}=".to_sym)
+                            when :singleton
+                              SingletonMethodName.new(type_name: type_name, method_name: "#{member.name}=".to_sym)
+                            end
+              index.add_method_declaration(method_name, member)
+            end
+
+          when RBS::AST::Members::InstanceVariable, RBS::AST::Members::ClassVariable, RBS::AST::Members::ClassInstanceVariable
+            type_reference member.type, from: member
+
+          when RBS::AST::Members::Include, RBS::AST::Members::Extend
+            index.add_type_reference member.name, member
+            member.args.each do |type|
+              type_reference type, from: member
+            end
+
+          when RBS::AST::Members::Alias
+            if member.instance?
+              new_name = InstanceMethodName.new(type_name: type_name, method_name: member.new_name)
+              index.add_method_declaration(new_name, member)
+            end
+
+            if member.singleton?
+              new_name = SingletonMethodName.new(type_name: type_name, method_name: member.new_name)
+              index.add_method_declaration(new_name, member)
+            end
+          end
+        end
+
+        def type_reference(type, from:)
+          case type
+          when RBS::Types::ClassInstance, RBS::Types::ClassSingleton, RBS::Types::Alias, RBS::Types::Interface
+            index.add_type_reference(type.name, from)
+          end
+
+          type.each_type do |ty|
+            type_reference ty, from: from
+          end
+        end
+
+        def env(env)
+          env.class_decls.each do |name, decl|
+            decl.decls.each do |d|
+              index.add_type_declaration(name, d.decl)
+
+              case d.decl
+              when RBS::AST::Declarations::Class
+                if super_class = d.decl.super_class
+                  index.add_type_reference(super_class.name, d.decl)
+                  super_class.args.each do |type|
+                    type_reference(type, from: d.decl)
+                  end
+                end
+              when RBS::AST::Declarations::Module
+                d.decl.self_types.each do |self_type|
+                  index.add_type_reference(self_type.name, d.decl)
+                  self_type.args.each do |type|
+                    type_reference(type, from: d.decl)
+                  end
+                end
+              end
+
+              d.decl.members.each do |member|
+                member(name, member)
+              end
+            end
+          end
+
+          env.interface_decls.each do |name, decl|
+            index.add_type_declaration(name, decl.decl)
+
+            decl.decl.members.each do |member|
+              member(name, member)
+            end
+          end
+
+          env.alias_decls.each do |name, decl|
+            index.add_type_declaration(name, decl.decl)
+            type_reference decl.decl.type, from: decl.decl
+          end
+
+          env.constant_decls.each do |name, decl|
+            index.add_constant_declaration(name, decl.decl)
+            type_reference decl.decl.type, from: decl.decl
+          end
+
+          env.global_decls.each do |name, decl|
+            index.add_global_declaration(name, decl.decl)
+            type_reference decl.decl.type, from: decl.decl
+          end
+        end
+      end
+    end
+  end
+end

data/lib/steep/index/signature_symbol_provider.rb

@@ -0,0 +1,154 @@
+module Steep
+  module Index
+    class SignatureSymbolProvider
+      LSP = LanguageServer::Protocol
+      SymbolInformation = Struct.new(:name, :kind, :container_name, :location, keyword_init: true)
+
+      attr_reader :indexes
+
+      def initialize()
+        @indexes = []
+      end
+
+      def self.test_type_name(query, type_name)
+        case
+        when query == ""
+          true
+        else
+          type_name.to_s.upcase.include?(query.upcase)
+        end
+      end
+
+      class <<self
+        alias test_const_name test_type_name
+        alias test_global_name test_type_name
+      end
+
+      def self.test_method_name(query, method_name)
+        case
+        when query == ""
+          true
+        else
+          method_name.to_s.upcase.include?(query.upcase)
+        end
+      end
+
+      def query_symbol(query)
+        symbols = []
+
+        indexes.each do |index|
+          index.each_entry do |entry|
+            case entry
+            when RBSIndex::TypeEntry
+              next unless SignatureSymbolProvider.test_type_name(query, entry.type_name)
+
+              container_name = entry.type_name.namespace.relative!.to_s.delete_suffix("::")
+              name = entry.type_name.name.to_s
+
+              entry.declarations.each do |decl|
+                case decl
+                when RBS::AST::Declarations::Class
+                  symbols << SymbolInformation.new(
+                    name: name,
+                    location: decl.location,
+                    kind: LSP::Constant::SymbolKind::CLASS,
+                    container_name: container_name
+                  )
+                when RBS::AST::Declarations::Module
+                  symbols << SymbolInformation.new(
+                    name: name,
+                    location: decl.location,
+                    kind: LSP::Constant::SymbolKind::MODULE,
+                    container_name: container_name
+                  )
+                when RBS::AST::Declarations::Interface
+                  symbols << SymbolInformation.new(
+                    name: name,
+                    location: decl.location,
+                    kind: LSP::Constant::SymbolKind::INTERFACE,
+                    container_name: container_name
+                  )
+                when RBS::AST::Declarations::Alias
+                  symbols << SymbolInformation.new(
+                    name: name,
+                    location: decl.location,
+                    kind: LSP::Constant::SymbolKind::ENUM,
+                    container_name: container_name
+                  )
+                end
+              end
+            when RBSIndex::MethodEntry
+              next unless SignatureSymbolProvider.test_method_name(query, entry.method_name)
+
+              name = case entry.method_name
+                     when InstanceMethodName
+                       "##{entry.method_name.method_name}"
+                     when SingletonMethodName
+                       ".#{entry.method_name.method_name}"
+                     end
+              container_name = entry.method_name.type_name.relative!.to_s
+
+              entry.declarations.each do |decl|
+                case decl
+                when RBS::AST::Members::MethodDefinition
+                  symbols << SymbolInformation.new(
+                    name: name,
+                    location: decl.location,
+                    kind: LSP::Constant::SymbolKind::METHOD,
+                    container_name: container_name
+                  )
+                when RBS::AST::Members::Alias
+                  symbols << SymbolInformation.new(
+                    name: name,
+                    location: decl.location,
+                    kind: LSP::Constant::SymbolKind::METHOD,
+                    container_name: container_name
+                  )
+                when RBS::AST::Members::AttrAccessor, RBS::AST::Members::AttrReader, RBS::AST::Members::AttrWriter
+                  symbols << SymbolInformation.new(
+                    name: name,
+                    location: decl.location,
+                    kind: LSP::Constant::SymbolKind::PROPERTY,
+                    container_name: container_name
+                  )
+
+                  if decl.ivar_name
+                    symbols << SymbolInformation.new(
+                      name: decl.ivar_name.to_s,
+                      location: decl.location,
+                      kind: LSP::Constant::SymbolKind::FIELD,
+                      container_name: container_name
+                    )
+                  end
+                end
+              end
+            when RBSIndex::ConstantEntry
+              next unless SignatureSymbolProvider.test_const_name(query, entry.const_name)
+
+              entry.declarations.each do |decl|
+                symbols << SymbolInformation.new(
+                  name: entry.const_name.name.to_s,
+                  location: decl.location,
+                  kind: LSP::Constant::SymbolKind::CONSTANT,
+                  container_name: entry.const_name.namespace.relative!.to_s.delete_suffix("::")
+                )
+              end
+            when RBSIndex::GlobalEntry
+              next unless SignatureSymbolProvider.test_global_name(query, entry.global_name)
+
+              entry.declarations.each do |decl|
+                symbols << SymbolInformation.new(
+                  name: decl.name.to_s,
+                  location: decl.location,
+                  kind: LSP::Constant::SymbolKind::VARIABLE
+                )
+              end
+            end
+          end
+        end
+
+        symbols.uniq {|symbol| [symbol.name, symbol.location] }.sort_by {|symbol| symbol.name.to_s }
+      end
+    end
+  end
+end

data/lib/steep/index/source_index.rb

@@ -0,0 +1,100 @@
+module Steep
+  module Index
+    class SourceIndex
+      class ConstantEntry
+        attr_reader :name
+
+        attr_reader :definitions
+        attr_reader :references
+
+        def initialize(name:)
+          @name = name
+
+          @definitions = Set[].compare_by_identity
+          @references = Set[].compare_by_identity
+        end
+
+        def add_definition(node)
+          case node.type
+          when :casgn, :class, :module
+            @definitions << node
+          else
+            raise "Unexpected constant definition: #{node.type}"
+          end
+
+          self
+        end
+
+        def add_reference(node)
+          case node.type
+          when :const
+            @references << node
+          else
+            raise "Unexpected constant reference: #{node.type}"
+          end
+
+          self
+        end
+
+        def merge!(other)
+          definitions.merge(other.definitions)
+          references.merge(other.references)
+          self
+        end
+      end
+
+      attr_reader :source
+      attr_reader :constant_index
+
+      attr_reader :parent
+      attr_reader :count
+      attr_reader :parent_count
+
+      def initialize(source:, parent: nil)
+        @source = source
+        @parent = parent
+        @parent_count = parent&.count
+
+        @count = @parent_count || 0
+
+        @constant_index = {}
+      end
+
+      def new_child
+        SourceIndex.new(source: source, parent: self)
+      end
+
+      def merge!(child)
+        raise unless child.parent == self
+        raise unless child.parent_count == count
+
+        constant_index.merge!(child.constant_index) do |_, entry, child_entry|
+          entry.merge!(child_entry)
+        end
+
+        @count = child.count + 1
+      end
+
+      def add_definition(constant:, definition:)
+        @count += 1
+        entry(constant: constant).add_definition(definition)
+        self
+      end
+
+      def add_reference(constant:, ref:)
+        @count += 1
+        entry(constant: constant).add_reference(ref)
+        self
+      end
+
+      def entry(constant:)
+        case
+        when constant
+          constant_index[constant] ||= ConstantEntry.new(name: constant)
+        else
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/steep/server/master.rb

@@ -111,7 +111,8 @@ module Steep
                 hover_provider: true,
                 completion_provider: LSP::Interface::CompletionOptions.new(
                   trigger_characters: [".", "@"]
-                )
+                ),
+                workspace_symbol_provider: true
               )
             )
           }
@@ -143,6 +144,9 @@ module Steep
         when "textDocument/open"
           # Ignores open notification
 
+        when "workspace/symbol"
+          signature_worker << message
+
         when "shutdown"
           queue << { id: id, result: nil }
           @shutdown_request_id = id

data/lib/steep/server/signature_worker.rb

@@ -24,7 +24,12 @@ module Steep
       def enqueue_target(target:, timestamp:)
         Steep.logger.debug "queueing target #{target.name}@#{timestamp}"
         last_target_validated_at[target] = timestamp
-        queue << [target, timestamp]
+        queue << [:validate, [target, timestamp]]
+      end
+
+      def enqueue_symbol(id:, query:)
+        Steep.logger.debug "queueing symbol #{query} (#{id})"
+        queue << [:symbol, [id, query]]
       end
 
       def handle_request(request)
@@ -37,6 +42,8 @@ module Steep
         when "textDocument/didChange"
           update_source(request)
           validate_signature_if_required(request)
+        when "workspace/symbol"
+          enqueue_symbol(query: request[:params][:query], id: request[:id])
         end
       end
 
@@ -138,13 +145,63 @@ module Steep
         end
       end
 
+      def handle_workspace_symbol(query:, id:)
+        provider = Index::SignatureSymbolProvider.new()
+
+        project.targets.each do |target|
+          case target.status
+          when Project::Target::TypeCheckStatus
+            index = Index::RBSIndex.new()
+
+            builder = Index::RBSIndex::Builder.new(index: index)
+            builder.env(target.status.environment)
+
+            provider.indexes << index
+          end
+        end
+
+        symbols = provider.query_symbol(query)
+
+        result = symbols.map do |symbol|
+          {
+            name: symbol.name.to_s,
+            kind: symbol.kind,
+            deprecated: false,
+            containerName: symbol.container_name.to_s,
+            location: {
+              uri: URI.parse(project.absolute_path(symbol.location.buffer.name).to_s),
+              range: {
+                start: LSP::Interface::Position.new(
+                  line: symbol.location.start_line - 1,
+                  character: symbol.location.start_column,
+                  ),
+                end: LSP::Interface::Position.new(
+                  line: symbol.location.end_line - 1,
+                  character: symbol.location.end_column
+                )
+              }
+            }
+          }
+        end
+
+        writer.write(id: id, result: result)
+      end
+
       def handle_job(job)
-        target, timestamp = job
+        action, data = job
+
+        case action
+        when :validate
+          target, timestamp = data
 
-        if active_job?(target, timestamp)
-          validate_signature(target, timestamp: timestamp)
-        else
-          Steep.logger.info "Skipping signature validation: #{target.name}, queued timestamp=#{timestamp}, latest timestamp=#{last_target_validated_at[target]}"
+          if active_job?(target, timestamp)
+            validate_signature(target, timestamp: timestamp)
+          else
+            Steep.logger.info "Skipping signature validation: #{target.name}, queued timestamp=#{timestamp}, latest timestamp=#{last_target_validated_at[target]}"
+          end
+        when :symbol
+          id, query = data
+          handle_workspace_symbol(query: query, id: id)
         end
       end
     end

data/lib/steep/type_construction.rb

@@ -1012,22 +1012,30 @@ module Steep
           value = node.children[0]
 
           if break_context
-            case
-            when value && break_context.break_type
-              check(value, break_context.break_type) do |break_type, actual_type, result|
-                typing.add_error Errors::BreakTypeMismatch.new(node: node,
-                                                               expected: break_type,
-                                                               actual: actual_type,
-                                                               result: result)
+            if break_type = break_context.break_type
+              if value
+                check(value, break_type) do |break_type, actual_type, result|
+                  typing.add_error Errors::BreakTypeMismatch.new(node: node,
+                                                                 expected: break_type,
+                                                                 actual: actual_type,
+                                                                 result: result)
+                end
+              else
+                check_relation(sub_type: AST::Builtin.nil_type, super_type: break_type).else do |result|
+                  typing.add_error Errors::BreakTypeMismatch.new(node: node,
+                                                                 expected: break_type,
+                                                                 actual: AST::Builtin.nil_type,
+                                                                 result: result)
+                end
               end
-            when !value
-              # ok
             else
-              synthesize(value) if value
-              typing.add_error Errors::UnexpectedJumpValue.new(node: node)
+              if value
+                synthesize(value)
+                typing.add_error Errors::UnexpectedJumpValue.new(node: node)
+              end
             end
           else
-            synthesize(value)
+            synthesize(value) if value
             typing.add_error Errors::UnexpectedJump.new(node: node)
           end
 
@@ -1037,22 +1045,32 @@ module Steep
           value = node.children[0]
 
           if break_context
-            case
-            when value && break_context.next_type
-              check(value, break_context.next_type) do |break_type, actual_type, result|
-                typing.add_error Errors::BreakTypeMismatch.new(node: node,
-                                                               expected: break_type,
-                                                               actual: actual_type,
-                                                               result: result)
+            if next_type = break_context.next_type
+              next_type = deep_expand_alias(next_type)
+
+              if value
+                _, constr = check(value, next_type) do |break_type, actual_type, result|
+                  typing.add_error Errors::BreakTypeMismatch.new(node: node,
+                                                                 expected: break_type,
+                                                                 actual: actual_type,
+                                                                 result: result)
+                end
+              else
+                check_relation(sub_type: AST::Builtin.nil_type, super_type: next_type).else do |result|
+                  typing.add_error Errors::BreakTypeMismatch.new(node: node,
+                                                                 expected: next_type,
+                                                                 actual: AST::Builtin.nil_type,
+                                                                 result: result)
+                end
               end
-            when !value
-              # ok
             else
-              synthesize(value) if value
-              typing.add_error Errors::UnexpectedJumpValue.new(node: node)
+              if value
+                synthesize(value)
+                typing.add_error Errors::UnexpectedJumpValue.new(node: node)
+              end
             end
           else
-            synthesize(value)
+            synthesize(value) if value
             typing.add_error Errors::UnexpectedJump.new(node: node)
           end
 
@@ -1250,13 +1268,32 @@ module Steep
             constr = self
 
             name, sup, _ = node.children
-            _, constr = constr.synthesize(name)
+            if name.type == :const
+              # skip the last constant reference
+              if const_parent = name.children[0]
+                _, constr = constr.synthesize(const_parent)
+              end
+            else
+              _, constr = constr.synthesize(name)
+            end
             _, constr = constr.synthesize(sup) if sup
 
             constr.for_class(node).tap do |constructor|
+              if module_type = constructor.module_context&.module_type
+                _, constructor = constructor.add_typing(name, type: module_type)
+              else
+                _, constructor = constructor.fallback_to_any(name)
+              end
+
+              constructor.typing.source_index.add_definition(
+                constant: constructor.module_context.class_name,
+                definition: node
+              )
+
               constructor.typing.add_context_for_node(node, context: constructor.context)
               constructor.typing.add_context_for_body(node, context: constructor.context)
 
+              constructor.synthesize(node.children[1]) if node.children[1]
               constructor.synthesize(node.children[2]) if node.children[2]
 
               if constructor.module_context&.implement_name && !namespace_module?(node)
@@ -1275,6 +1312,11 @@ module Steep
             _, constr = constr.synthesize(name)
 
             for_module(node).yield_self do |constructor|
+              constructor.typing.source_index.add_definition(
+                constant: constructor.module_context.class_name,
+                definition: node
+              )
+
               constructor.typing.add_context_for_node(node, context: constructor.context)
               constructor.typing.add_context_for_body(node, context: constructor.context)
 
@@ -1335,6 +1377,10 @@ module Steep
           const_name = constr.module_name_from_node(node)
 
           if const_name
+            if constant = module_context.const_env.lookup_constant(const_name)
+              typing.source_index.add_reference(constant: constant.name, ref: node)
+            end
+
             type = type_env.get(const: const_name) do
               constr.fallback_to_any(node)
             end
@@ -1352,6 +1398,10 @@ module Steep
             const_name = constr.module_name_from_node(node)
 
             if const_name
+              if constant = module_context.const_env.lookup_constant(const_name)
+                typing.source_index.add_definition(constant: constant.name, definition: node)
+              end
+
               const_type = type_env.get(const: const_name) {}
               value_type, constr = constr.synthesize(node.children.last, hint: const_type)
               type = type_env.assign(const: const_name, type: value_type, self_type: self_type) do |error|
@@ -2376,6 +2426,7 @@ module Steep
       block_constr = for_block(
         block_params: params,
         block_param_hint: params_hint,
+        block_type_hint: return_hint,
         block_annotations: block_annotations,
         node_type_hint: nil
       )
@@ -2390,10 +2441,22 @@ module Steep
         return_type = block_constr.synthesize_block(
           node: node,
           block_body: block_body,
-          topdown_hint: true,
           block_type_hint: return_hint
-        ) do |error|
-          typing.add_error(error)
+        )
+
+        if expected_block_type = block_constr.block_context.body_type
+          check_relation(sub_type: return_type, super_type: expected_block_type).else do |result|
+            block_constr.typing.add_error(
+              Errors::BlockBodyTypeMismatch.new(
+                node: block_body,
+                expected: expected_block_type,
+                actual: return_type,
+                result: result
+              )
+            )
+
+            return_type = expected_block_type
+          end
         end
       else
         return_type = AST::Builtin.any_type
@@ -2473,9 +2536,7 @@ module Steep
               block_params: TypeInference::BlockParams.from_node(block_params, annotations: block_annotations),
               block_annotations: block_annotations,
               block_body: block_body
-            ) do |error|
-              constr.typing.add_error(error)
-            end
+            )
           end
         end
 
@@ -2850,6 +2911,7 @@ module Steep
               block_constr = constr.for_block(
                 block_params: block_params_,
                 block_param_hint: method_type.block.type.params,
+                block_type_hint: method_type.block.type.return_type,
                 block_annotations: block_annotations,
                 node_type_hint: method_type.type.return_type
               )
@@ -2888,12 +2950,9 @@ module Steep
               if block_body
                 block_body_type = block_constr.synthesize_block(
                   node: node,
-                  block_type_hint: method_type.block.type.return_type,
                   block_body: block_body,
-                  topdown_hint: topdown_hint
-                ) do |error|
-                  errors << error
-                end
+                  block_type_hint: method_type.block.type.return_type
+                )
               else
                 block_body_type = AST::Builtin.nil_type
               end
@@ -2940,6 +2999,7 @@ module Steep
               end
 
               block_constr.typing.save!
+
             rescue Subtyping::Constraints::UnsatisfiableConstraint => exn
               errors << Errors::UnsatisfiableConstraint.new(
                 node: node,
@@ -3069,6 +3129,7 @@ module Steep
       block_constr = for_block(
         block_params: block_params,
         block_param_hint: nil,
+        block_type_hint: nil,
         block_annotations: block_annotations,
         node_type_hint: nil
       )
@@ -3079,10 +3140,23 @@ module Steep
         _, block_constr = block_constr.synthesize(param.node, hint: param.type)
       end
 
-      block_constr.synthesize_block(node: node, block_type_hint: nil, block_body: block_body, topdown_hint: false, &block)
+      block_type = block_constr.synthesize_block(node: node, block_type_hint: nil, block_body: block_body)
+
+      if expected_block_type = block_constr.block_context.body_type
+        block_constr.check_relation(sub_type: block_type, super_type: expected_block_type).else do |result|
+          block_constr.typing.add_error(
+            Errors::BlockBodyTypeMismatch.new(
+              node: node,
+              expected: expected_block_type,
+              actual: block_type,
+              result: result
+            )
+          )
+        end
+      end
     end
 
-    def for_block(block_params:, block_param_hint:, block_annotations:, node_type_hint:)
+    def for_block(block_params:, block_param_hint:, block_type_hint:, block_annotations:, node_type_hint:)
       block_param_pairs = block_param_hint && block_params.zip(block_param_hint)
 
       param_types_hash = {}
@@ -3114,7 +3188,7 @@ module Steep
                    end
 
       block_context = TypeInference::Context::BlockContext.new(
-        body_type: block_annotations.block_type
+        body_type: block_annotations.block_type || block_type_hint || AST::Builtin.any_type
       )
       break_context = TypeInference::Context::BreakContext.new(
         break_type: break_type,
@@ -3139,20 +3213,9 @@ module Steep
       )
     end
 
-    def synthesize_block(node:, block_type_hint:, block_body:, topdown_hint:)
+    def synthesize_block(node:, block_type_hint:, block_body:)
       if block_body
-        body_type, _, context =
-          if (body_type = block_context.body_type)
-            check(block_body, body_type) do |expected, actual, result|
-              error = Errors::BlockTypeMismatch.new(node: block_body,
-                                                    expected: expected,
-                                                    actual: actual,
-                                                    result: result)
-              yield(error) if block_given?
-            end
-          else
-            synthesize(block_body, hint: topdown_hint ? block_type_hint : nil)
-          end
+        body_type, _, context = synthesize(block_body, hint: block_context.body_type || block_type_hint)
 
         range = block_body.loc.expression.end_pos..node.loc.end.begin_pos
         typing.add_context(range, context: context)
@@ -3245,7 +3308,7 @@ module Steep
       if module_name.namespace.relative?
         (current_namespace + module_name.namespace).append(module_name.name)
       else
-        module_name
+        module_name.to_namespace
       end
     end
 

data/lib/steep/type_inference/constant_env.rb

@@ -15,9 +15,13 @@ module Steep
         @table = RBS::ConstantTable.new(builder: factory.definition_builder)
       end
 
+      def lookup_constant(name)
+        table.resolve_constant_reference(name, context: context)
+      end
+
       def lookup(name)
         cache[name] ||= begin
-          constant = table.resolve_constant_reference(name, context: context)
+          constant = lookup_constant(name)
 
           if constant
             factory.type(constant.type)

data/lib/steep/typing.rb

@@ -21,8 +21,9 @@ module Steep
     attr_reader :contexts
     attr_reader :root_context
     attr_reader :method_calls
+    attr_reader :source_index
 
-    def initialize(source:, root_context:, parent: nil, parent_last_update: parent&.last_update, contexts: nil)
+    def initialize(source:, root_context:, parent: nil, parent_last_update: parent&.last_update, contexts: nil, source_index: nil)
       @source = source
 
       @parent = parent
@@ -35,6 +36,8 @@ module Steep
       @root_context = root_context
       @contexts = contexts || TypeInference::ContextArray.from_source(source: source)
       @method_calls = {}.compare_by_identity
+
+      @source_index = source_index || Index::SourceIndex.new(source: source)
     end
 
     def add_error(error)
@@ -195,7 +198,8 @@ module Steep
       child = self.class.new(source: source,
                              parent: self,
                              root_context: root_context,
-                             contexts: TypeInference::ContextArray.new(buffer: contexts.buffer, range: range, context: nil))
+                             contexts: TypeInference::ContextArray.new(buffer: contexts.buffer, range: range, context: nil),
+                             source_index: source_index.new_child)
       @should_update = true
 
       if block_given?
@@ -224,6 +228,8 @@ module Steep
       errors.each do |error|
         parent.add_error error
       end
+
+      parent.source_index.merge!(source_index)
     end
   end
 end

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "0.37.0"
+  VERSION = "0.38.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: steep
 version: !ruby/object:Gem::Version
-  version: 0.37.0
+  version: 0.38.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-12-06 00:00:00.000000000 Z
+date: 2020-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -178,6 +178,9 @@ files:
 - lib/steep/drivers/watch.rb
 - lib/steep/drivers/worker.rb
 - lib/steep/errors.rb
+- lib/steep/index/rbs_index.rb
+- lib/steep/index/signature_symbol_provider.rb
+- lib/steep/index/source_index.rb
 - lib/steep/interface/block.rb
 - lib/steep/interface/function.rb
 - lib/steep/interface/interface.rb