steep 1.2.0 → 1.3.0.pre.1

data/lib/steep/signature/validator.rb

@@ -20,7 +20,7 @@ module Steep
       end
 
       def each_error(&block)
-        if block_given?
+        if block
           @errors.each(&block)
         else
           enum_for :each_error
@@ -64,6 +64,8 @@ module Steep
           )
 
           type_params.zip(type_args).each do |param, arg|
+            arg or raise
+
             if param.upper_bound
               upper_bound_type = factory.type(param.upper_bound).subst(subst)
               arg_type = factory.type(arg)
@@ -121,7 +123,7 @@ module Steep
 
         if name && type_params && type_args
           if !type_params.empty? && !type_args.empty?
-            validate_type_application_constraints(type.name, type_params, type_args, location: type.location)
+            validate_type_application_constraints(name, type_params, type_args, location: type.location)
           end
         end
 
@@ -156,19 +158,21 @@ module Steep
       end
 
       def mixin_constraints(definition, mixin_ancestors, immediate_self_types:)
+        # @type var relations: Array[[Subtyping::Relation[AST::Types::t], RBS::Definition::Ancestor::Instance]]
         relations = []
 
         self_type = checker.factory.type(definition.self_type)
         if immediate_self_types && !immediate_self_types.empty?
-          self_type = AST::Types::Intersection.build(
-            types: immediate_self_types.map {|st| ancestor_to_type(st) }.push(self_type),
-            location: nil
-          )
+          # @type var sts: Array[AST::Types::t]
+          sts = immediate_self_types.map {|st| ancestor_to_type(st) }
+          self_type = AST::Types::Intersection.build(types: sts.push(self_type), location: nil)
         end
 
         mixin_ancestors.each do |ancestor|
           args = ancestor.args.map {|type| checker.factory.type(type) }
           ancestor_ancestors = builder.ancestor_builder.one_instance_ancestors(ancestor.name)
+          ancestor_ancestors.self_types or raise
+          ancestor_ancestors.params or raise
           self_constraints = ancestor_ancestors.self_types.map do |self_ancestor|
             s = Interface::Substitution.build(ancestor_ancestors.params, args)
             ancestor_to_type(self_ancestor).subst(s)
@@ -263,7 +267,7 @@ module Steep
                 end
 
                 ancestors = builder.ancestor_builder.one_instance_ancestors(name)
-                mixin_constraints(definition, ancestors.included_modules, immediate_self_types: ancestors.self_types).each do |relation, ancestor|
+                mixin_constraints(definition, ancestors.included_modules || raise, immediate_self_types: ancestors.self_types).each do |relation, ancestor|
                   checker.check(
                     relation,
                     self_type: AST::Types::Self.new,
@@ -271,6 +275,8 @@ module Steep
                     class_type: AST::Types::Class.new,
                     constraints: Subtyping::Constraints.empty
                   ).else do
+                    raise if ancestor.source.is_a?(Symbol)
+
                     @errors << Diagnostic::Signature::ModuleSelfTypeError.new(
                       name: name,
                       location: ancestor.source&.location || raise,
@@ -292,6 +298,14 @@ module Steep
             end
 
             builder.build_singleton(name).tap do |definition|
+              entry =
+                case definition.entry
+                when RBS::Environment::ClassEntry, RBS::Environment::ModuleEntry
+                  definition.entry
+                else
+                  raise
+                end
+
               definition.instance_variables.each do |name, var|
                 if parent = var.parent_variable
                   var_type = checker.factory.type(var.type)
@@ -327,7 +341,7 @@ module Steep
               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|
+                    class_var = entry.decls.flat_map {|decl| decl.decl.members }.find do |member|
                       member.is_a?(RBS::AST::Members::ClassVariable) && member.name == name
                     end
 
@@ -336,7 +350,7 @@ module Steep
                         class_name: definition.type_name,
                         other_class_name: parent.declared_in,
                         variable_name: name,
-                        location: class_var.location[:name]
+                        location: class_var.location&.[](:name)
                       )
                     end
                   end
@@ -344,6 +358,7 @@ module Steep
               end
 
               ancestors = builder.ancestor_builder.one_singleton_ancestors(name)
+              ancestors.extended_modules or raise
               mixin_constraints(definition, ancestors.extended_modules, immediate_self_types: ancestors.self_types).each do |relation, ancestor|
                 checker.check(
                   relation,
@@ -352,6 +367,8 @@ module Steep
                   class_type: AST::Types::Class.new,
                   constraints: Subtyping::Constraints.empty
                 ).else do
+                  raise if ancestor.source.is_a?(Symbol)
+                  
                   @errors << Diagnostic::Signature::ModuleSelfTypeError.new(
                     name: name,
                     location: ancestor.source&.location || raise,
@@ -381,19 +398,23 @@ module Steep
               builder.build_instance(ancestor.name)
             when ancestor.name.interface?
               builder.build_interface(ancestor.name)
+            else
+              raise
             end
 
           location =
-            if ancestor.source == :super
+            case ancestor.source
+            when :super
               primary_decl = env.class_decls[name].primary.decl
+              primary_decl.is_a?(RBS::AST::Declarations::Class) or raise
               if super_class = primary_decl.super_class
                 super_class.location
               else
                 # Implicit super class (Object): this can be skipped in fact...
-                primary_decl.location[:name]
+                primary_decl.location&.aref(:name)
               end
             else
-              ancestor.source.location
+              ancestor.source&.location
             end
 
           validate_type_application_constraints(
@@ -423,12 +444,14 @@ module Steep
                 case ancestor
                 when RBS::Definition::Ancestor::Instance
                   # Interface ancestor cannot be other than Interface
+                  ancestor.source.is_a?(Symbol) and raise
+
                   defn = builder.build_interface(ancestor.name)
                   validate_type_application_constraints(
                     ancestor.name,
                     defn.type_params_decl,
                     ancestor.args,
-                    location: ancestor.source.location || raise
+                    location: ancestor.source&.location || raise
                   )
                 end
               end

data/lib/steep/source.rb

@@ -1,27 +1,11 @@
 module Steep
   class Source
-    class LocatedAnnotation
-      attr_reader :line
-      attr_reader :annotation
-      attr_reader :source
-
-      def initialize(line:, source:, annotation:)
-        @line = line
-        @source = source
-        @annotation = annotation
-      end
-
-      def ==(other)
-        other.is_a?(LocatedAnnotation) &&
-          other.line == line &&
-          other.annotation == annotation
-      end
-    end
-
     attr_reader :path
     attr_reader :node
     attr_reader :mapping
 
+    extend NodeHelper
+
     def initialize(path:, node:, mapping:)
       @path = path
       @node = node
@@ -47,46 +31,61 @@ module Steep
 
     def self.parse(source_code, path:, factory:)
       buffer = ::Parser::Source::Buffer.new(path.to_s, 1, source: source_code)
-      node = new_parser().parse(buffer)
+      node, comments = new_parser().parse_with_comments(buffer)
 
+      # @type var annotations: Array[AST::Annotation::t]
       annotations = []
-
-      _, comments, _ = yield_self do
-        buffer = ::Parser::Source::Buffer.new(path.to_s, 1, source: source_code)
-        new_parser().tokenize(buffer)
-      end
+      # @type var type_comments: Hash[Integer, type_comment]
+      type_comments = {}
 
       buffer = RBS::Buffer.new(name: path, content: source_code)
+      annotation_parser = AnnotationParser.new(factory: factory)
 
       comments.each do |comment|
-        src = comment.text.gsub(/\A#\s*/, '')
-        location = RBS::Location.new(buffer: buffer,
-                                     start_pos: comment.location.expression.begin_pos + 1,
-                                     end_pos: comment.location.expression.end_pos)
-        annotation = AnnotationParser.new(factory: factory).parse(src, location: location)
-        if annotation
-          annotations << LocatedAnnotation.new(line: comment.location.line, source: src, annotation: annotation)
+        if comment.inline?
+          content = comment.text.delete_prefix('#')
+          content.lstrip!
+          prefix = comment.text.size - content.size
+          content.rstrip!
+          suffix = comment.text.size - content.size - prefix
+
+          location = RBS::Location.new(
+            buffer: buffer,
+            start_pos: comment.location.expression.begin_pos + prefix,
+            end_pos: comment.location.expression.end_pos - suffix
+          )
+
+          case
+          when annotation = annotation_parser.parse(content, location: location)
+            annotations << annotation
+          when assertion = AST::Node::TypeAssertion.parse(location)
+            type_comments[assertion.line] = assertion
+          when tapp = AST::Node::TypeApplication.parse(location)
+            type_comments[tapp.line] = tapp
+          end
         end
       end
 
-      mapping = {}.compare_by_identity
+      map = {}
+      map.compare_by_identity
 
       if node
-        construct_mapping(node: node, annotations: annotations, mapping: mapping)
+        node = insert_type_node(node, type_comments)
+        construct_mapping(node: node, annotations: annotations, mapping: map)
       end
 
       annotations.each do |annot|
-        mapping[node] ||= []
-        mapping[node] << annot
+        map[node] ||= []
+        map[node] << annot
       end
 
-      new(path: path, node: node, mapping: mapping)
+      new(path: path, node: node, mapping: map)
     end
 
     def self.construct_mapping(node:, annotations:, mapping:, line_range: nil)
       case node.type
       when :if
-        if node.loc.is_a?(::Parser::Source::Map::Ternary)
+        if node.loc.respond_to?(:question)
           # Skip ternary operator
           each_child_node node do |child|
             construct_mapping(node: child, annotations: annotations, mapping: mapping, line_range: nil)
@@ -200,7 +199,7 @@ module Steep
         last_cond = node.children[-2]
         body = node.children.last
 
-        node.children.take(node.children.size-1) do |child|
+        node.children.take(node.children.size-1).each do |child|
           construct_mapping(node: child, annotations: annotations, mapping: mapping, line_range: nil)
         end
 
@@ -235,7 +234,7 @@ module Steep
         end
       end
 
-      associated_annotations = annotations.select do |annot|
+      associated_annotations, other_annotations = annotations.partition do |annot|
         case node.type
         when :def, :module, :class, :block, :ensure, :defs
           loc = node.loc
@@ -257,33 +256,34 @@ module Steep
       associated_annotations.each do |annot|
         mapping[node] ||= []
         mapping[node] << annot
-        annotations.delete annot
       end
-    end
 
-    def self.each_child_node(node)
-      node.children.each do |child|
-        if child.is_a?(::AST::Node)
-          yield child
-        end
-      end
+      annotations.replace(other_annotations)
     end
 
-    def self.map_child_nodes(node)
+    def self.map_child_node(node, type = nil, skip: nil)
       children = node.children.map do |child|
-        if child.is_a?(::AST::Node)
-          yield child
+        if child.is_a?(Parser::AST::Node)
+          if skip
+            if skip.member?(child)
+              child
+            else
+              yield child
+            end
+          else
+            yield child
+          end
         else
           child
         end
       end
 
-      node.updated(nil, children)
+      node.updated(type, children)
     end
 
     def annotations(block:, factory:, context:)
       AST::Annotation::Collection.new(
-        annotations: (mapping[block] || []).map(&:annotation),
+        annotations: (mapping[block] || []),
         factory: factory,
         context: context
       )
@@ -292,7 +292,7 @@ module Steep
     def each_annotation(&block)
       if block_given?
         mapping.each do |node, annots|
-          yield node, annots.map(&:annotation)
+          yield [node, annots]
         end
       else
         enum_for :each_annotation
@@ -301,9 +301,11 @@ module Steep
 
     def each_heredoc_node(node = self.node, parents = [], &block)
       if block
+        return unless node
+
         case node.type
         when :dstr, :str
-          if node.location.is_a?(Parser::Source::Map::Heredoc)
+          if node.location.respond_to?(:heredoc_body)
             yield [node, *parents]
           end
         end
@@ -344,7 +346,9 @@ module Steep
           parents.unshift node
 
           Source.each_child_node(node) do |child|
-            ns = find_nodes_loc(child, position, parents) and return ns
+            if ns = find_nodes_loc(child, position, parents)
+              return ns
+            end
           end
 
           parents
@@ -359,12 +363,14 @@ module Steep
         node.location.expression.source_buffer.source_line(i+1).size + 1
       end + column
 
-      if nodes = find_heredoc_nodes(line, column, position)
-        Source.each_child_node(nodes[0]) do |child|
-          find_nodes_loc(child, position, nodes) and break
+      if heredoc_nodes = find_heredoc_nodes(line, column, position)
+        Source.each_child_node(heredoc_nodes[0]) do |child|
+          if nodes = find_nodes_loc(child, position, heredoc_nodes)
+            return nodes
+          end
         end
 
-        nodes
+        return heredoc_nodes
       else
         find_nodes_loc(node, position, [])
       end
@@ -385,7 +391,7 @@ module Steep
           delete_defs(node.children[0], allow_list)
         end
       else
-        map_child_nodes(node) do |child|
+        map_child_node(node) do |child|
           delete_defs(child, allow_list)
         end
       end
@@ -398,7 +404,9 @@ module Steep
 
         node_ = Source.delete_defs(node, defs)
 
-        mapping = {}.compare_by_identity
+        # @type var mapping: Hash[Parser::AST::Node, Array[AST::Annotation::t]]
+        mapping = {}
+        mapping.compare_by_identity
 
         annotations = self.mapping.values.flatten
         Source.construct_mapping(node: node_, annotations: annotations, mapping: mapping)
@@ -414,19 +422,129 @@ module Steep
       end
     end
 
-    def compact_siblings(node)
-      case node
-      when :def
-        node.updated(:nil, [])
-      when :defs
-        node.children[0]
-      when :class
-        node.updated(:class, [node.children[0], node.children[1], nil])
-      when :module
-        node.updated(:module, [node.children[0], nil])
+    def self.insert_type_node(node, comments)
+      if node.location.expression
+        first_line = node.location.expression.first_line
+        last_line = node.location.expression.last_line
+        last_comment = comments[last_line]
+
+        if (first_line..last_line).none? {|l| comments.key?(l) }
+          return node
+        end
+
+        case
+        when last_comment.is_a?(AST::Node::TypeAssertion)
+          case node.type
+          when :lvasgn, :ivasgn, :gvasgn, :cvasgn, :casgn
+            # Skip
+          when :masgn
+            lhs, rhs = node.children
+            node = node.updated(nil, [lhs, insert_type_node(rhs, comments)])
+            return adjust_location(node)
+          when :return, :break, :next
+            # Skip
+          when :begin
+            if node.loc.begin
+              # paren
+              child_assertions = comments.except(last_line)
+              node = map_child_node(node) {|child| insert_type_node(child, child_assertions) }
+              node = adjust_location(node)
+              return assertion_node(node, last_comment)
+            end
+          else
+            child_assertions = comments.except(last_line)
+            node = map_child_node(node) {|child| insert_type_node(child, child_assertions) }
+            node = adjust_location(node)
+            return assertion_node(node, last_comment)
+          end
+        when selector_line = sendish_node?(node)
+          if (comment = comments[selector_line]).is_a?(AST::Node::TypeApplication)
+            child_assertions = comments.except(selector_line)
+            case node.type
+            when :block
+              send, *children = node.children
+              node = node.updated(
+                nil,
+                [
+                  map_child_node(send) {|child| insert_type_node(child, child_assertions) },
+                  *children.map {|child| insert_type_node(child, child_assertions) }
+                ]
+              )
+            when :numblock
+              send, size, body = node.children
+              node = node.updated(
+                nil,
+                [
+                  map_child_node(send) {|child| insert_type_node(child, child_assertions) },
+                  size,
+                  insert_type_node(body, child_assertions)
+                ]
+              )
+            else
+              node = map_child_node(node) {|child| insert_type_node(child, child_assertions) }
+            end
+            node = adjust_location(node)
+            return type_application_node(node, comment)
+          end
+        end
+      end
+
+      adjust_location(
+        map_child_node(node, nil) {|child| insert_type_node(child, comments) }
+      )
+    end
+
+    def self.sendish_node?(node)
+      send_node =
+        case node.type
+        when :send, :csend
+          node
+        when :block, :numblock
+          send = node.children[0]
+          case send.type
+          when :send, :csend
+            send
+          end
+        end
+
+      if send_node
+        if send_node.location.dot
+          send_node.location.selector.line
+        end
+      end
+    end
+
+    def self.adjust_location(node)
+      if end_pos = node.location.expression&.end_pos
+        if last_pos = each_child_node(node).map {|node| node.location.expression&.end_pos }.compact.max
+          if last_pos > end_pos
+            props = { location: node.location.with_expression(node.location.expression.with(end_pos: last_pos)) }
+          end
+        end
+      end
+
+      if props
+        node.updated(nil, nil, props)
       else
         node
       end
     end
+
+    def self.assertion_node(node, type)
+      map = Parser::Source::Map.new(node.location.expression.with(end_pos: type.location.end_pos))
+      Parser::AST::Node.new(:assertion, [node, type], { location: map })
+    end
+
+    def self.type_application_node(node, tapp)
+      if node.location.expression.end_pos > tapp.location.end_pos
+        map = Parser::Source::Map.new(node.location.expression)
+      else
+        map = Parser::Source::Map.new(node.location.expression.with(end_pos: tapp.location.end_pos))
+      end
+
+      node = Parser::AST::Node.new(:tapp, [node, tapp], { location: map })
+      tapp.set_node(node)
+      node
+    end
   end
 end