steep 1.4.0 → 1.5.0.pre.1

data/sig/steep/services/completion_provider.rbs

@@ -152,7 +152,29 @@ module Steep
         ) -> void
       end
 
-      type item = InstanceVariableItem | LocalVariableItem | ConstantItem | SimpleMethodNameItem | ComplexMethodNameItem | GeneratedMethodNameItem
+      class TypeNameItem
+        attr_reader env: Environment
+
+        attr_reader absolute_type_name: TypeName
+
+        attr_reader relative_type_name: TypeName
+
+        attr_reader range: Range
+
+        def initialize: (absolute_type_name: TypeName, relative_type_name: TypeName, env: Environment, range: Range) -> void
+
+        def decl: () -> Server::LSPFormatter::summarizable_decl
+
+        def comments: () -> Array[RBS::AST::Comment]
+      end
+
+      type item = InstanceVariableItem
+                | LocalVariableItem
+                | ConstantItem
+                | SimpleMethodNameItem
+                | ComplexMethodNameItem
+                | GeneratedMethodNameItem
+                | TypeNameItem
 
       attr_reader source_text: String
 
@@ -176,6 +198,8 @@ module Steep
 
       def range_from_loc: (Parser::Source::Range loc) -> Range
 
+      def at_comment?: (Position pos) -> bool
+
       def at_end?: (Position pos, of: Parser::Source::Map | Parser::Source::Range | nil) -> boolish
 
       def range_for: (Position position, ?prefix: ::String) -> Range
@@ -184,10 +208,14 @@ module Steep
 
       def items_for_dot: (position: Position) -> Array[item]
 
+      def items_for_qcall: (position: Position) -> Array[item]
+
       def items_for_colon2: (position: Position) -> Array[item]
 
       def items_for_atmark: (position: Position) -> Array[item]
 
+      def items_for_rbs: (position: Position, buffer: RBS::Buffer) -> Array[item]
+
       def method_items_for_receiver_type: (AST::Types::t, include_private: bool, prefix: String, position: Position, items: Array[item]) -> void
 
       def word_name?: (String name) -> bool
@@ -202,6 +230,8 @@ module Steep
 
       def disallowed_method?: (Symbol name) -> bool
 
+      def unwrap_optional: (AST::Types::t) -> AST::Types::t
+
     end
   end
 end

data/sig/steep/services/goto_service.rbs

@@ -1,45 +1,106 @@
+use RBS::TypeName, RBS::Location
+
 module Steep
   module Services
     class GotoService
       include ModuleHelper
 
-      module SourceHelper
-        def from_ruby?: () -> untyped
+      # Where the query is issued from
+      #
+      # * `:ruby` if the query is issued from a Ruby code
+      # * `:rbs` if the query is issued from a RBS file
+      #
+      type from = :ruby | :rbs
+
+      module SourceHelper : _From
+        interface _From
+          def from: () -> from
+        end
+
+        def from_ruby?: () -> bool
+
+        def from_rbs?: () -> bool
+      end
+
+      # Query a constant
+      #
+      class ConstantQuery
+        include SourceHelper
+
+        attr_reader name: TypeName
+
+        # Where the query is issued from
+        attr_reader from: from
+
+        def initialize: (name: TypeName, from: from) -> void
+      end
+
+      # Query a method
+      #
+      class MethodQuery
+        include SourceHelper
+
+        attr_reader name: method_name
 
-        def from_rbs?: () -> untyped
+        # Where the query is issued from
+        attr_reader from: from
+
+        def initialize: (name: method_name, from: from) -> void
       end
 
-      ConstantQuery: untyped
+      # Query a type name
+      #
+      #
+      #
+      class TypeNameQuery
+        attr_reader name: TypeName
+
+        def initialize: (name: TypeName) -> void
+      end
+
+      type query = ConstantQuery | MethodQuery | TypeNameQuery
+
+      type loc = Location[bot, bot] | Parser::Source::Range
+
+      attr_reader type_check: TypeCheckService
 
-      MethodQuery: untyped
+      attr_reader assignment: PathAssignment
 
-      TypeNameQuery: untyped
+      def initialize: (type_check: TypeCheckService, assignment: PathAssignment) -> void
 
-      attr_reader type_check: untyped
+      def project: () -> Project
 
-      attr_reader assignment: untyped
+      # Returns array of locations that is a response to a *Go to implementation* request
+      #
+      def implementation: (path: Pathname, line: Integer, column: Integer) -> Array[loc]
 
-      def initialize: (type_check: untyped, assignment: untyped) -> void
+      # Returns array of locations that is a response to a *Go to definition* request
+      #
+      def definition: (path: Pathname, line: Integer, column: Integer) -> Array[loc]
 
-      def project: () -> untyped
+      # Returns array of locations that is a response to a *Go to type-definition* request
+      #
+      def type_definition: (path: Pathname, line: Integer, column: Integer) -> Array[loc]
 
-      def implementation: (path: untyped, line: untyped, column: untyped) -> untyped
+      private
 
-      def definition: (path: untyped, line: untyped, column: untyped) -> untyped
+      # Returns a set of queries
+      def query_at: (path: Pathname, line: Integer, column: Integer) -> Array[query]
 
-      def test_ast_location: (untyped loc, line: untyped, column: untyped) -> (false | true)
+      def each_type_name: (AST::Types::t) { (TypeName) -> void } -> void
+                        | (AST::Types::t) -> Enumerator[TypeName, void]
 
-      def query_at: (path: untyped, line: untyped, column: untyped) -> untyped
+      def test_ast_location: (Parser::Source::Range loc, line: Integer, column: Integer) -> bool
 
-      def type_check_path: (target: untyped, path: untyped, content: untyped, line: untyped, column: untyped) -> untyped
+      def type_check_path: (target: Project::Target, path: Pathname, content: String, line: Integer, column: Integer) -> [Typing, SignatureService]?
 
-      def constant_definition_in_rbs: (untyped name, locations: untyped) -> untyped
+      def constant_definition_in_rbs: (TypeName name, locations: Array[loc]) -> Array[loc]
 
-      def constant_definition_in_ruby: (untyped name, locations: untyped) -> untyped
+      def constant_definition_in_ruby: (TypeName name, locations: Array[loc]) -> Array[loc]
 
-      def method_locations: (untyped name, in_ruby: untyped, in_rbs: untyped, locations: untyped) -> untyped
+      def method_locations: (method_name, in_ruby: bool, in_rbs: bool, locations: Array[loc]) -> Array[loc]
 
-      def type_name_locations: (untyped name, ?locations: untyped) -> untyped
+      def type_name_locations: (TypeName name, ?locations: Array[loc]) -> Array[loc]
     end
   end
 end

data/sig/steep/source.rbs

@@ -2,19 +2,29 @@ module Steep
   class Source
     extend NodeHelper
 
+    attr_reader buffer: RBS::Buffer
+
     attr_reader path: Pathname
 
     attr_reader node: Parser::AST::Node?
 
     attr_reader mapping: Hash[Parser::AST::Node, Array[AST::Annotation::t]]
 
-    def initialize: (path: Pathname, node: Parser::AST::Node?, mapping: Hash[Parser::AST::Node, Array[AST::Annotation::t]]) -> void
+    attr_reader comments: Array[Parser::Source::Comment]
+
+    def initialize: (
+      buffer: RBS::Buffer,
+      path: Pathname,
+      node: Parser::AST::Node?,
+      mapping: Hash[Parser::AST::Node, Array[AST::Annotation::t]],
+      comments: Array[Parser::Source::Comment]
+    ) -> void
 
     class Builder < ::Parser::Builders::Default
       def string_value: (untyped token) -> untyped
     end
 
-    def self.new_parser: () -> Parser::Ruby31
+    def self.new_parser: () -> Parser::Ruby32
 
     def self.parse: (String source_code, path: Pathname, factory: AST::Types::Factory) -> Source
 
@@ -36,8 +46,8 @@ module Steep
     #
     # Yields arrays, inner node first, outer node last -- `[heredoc_node, *outer_node, node]`.
     #
-    def each_heredoc_node: (?Parser::AST::Node? node, ?Array[Parser::AST::Node] parents) { (Array[Parser::AST::Node]) -> void } -> void
-                         | (?Parser::AST::Node? node, ?Array[Parser::AST::Node] parents) -> Enumerator[Array[Parser::AST::Node], void]
+    def each_heredoc_node: (?Parser::AST::Node? node, ?Array[Parser::AST::Node] parents) { ([Array[Parser::AST::Node], Parser::Source::Map & Parser::AST::_Heredoc]) -> void } -> void
+                         | (?Parser::AST::Node? node, ?Array[Parser::AST::Node] parents) -> Enumerator[[Array[Parser::AST::Node], Parser::Source::Map & Parser::AST::_Heredoc], void]
 
     # Returns array of nodes that is located inside heredoc
     #
@@ -58,6 +68,19 @@ module Steep
     # Returns a node and it's outer nodes
     def find_nodes: (line: Integer, column: Integer) -> ::Array[Parser::AST::Node]?
 
+    # Returns comment at the given position
+    #
+    # Note that a cursor position that is at the beginning of a comment returns `nil`.
+    #
+    # ```ruby
+    # .#. .H.e.l.l.o.
+    # ^                   => Returns nil
+    #   ^                 => Returns the comment
+    #               ^     => Returns the comment
+    # ```
+    #
+    def find_comment: (line: Integer, column: Integer) -> Parser::Source::Comment?
+
     def self.delete_defs: (Parser::AST::Node node, Set[Parser::AST::Node] allow_list) -> Parser::AST::Node
 
     def without_unrelated_defs: (line: Integer, column: Integer) -> Source

data/sig/steep/subtyping/variable_variance.rbs

@@ -1,25 +1,25 @@
 module Steep
   module Subtyping
     class VariableVariance
-      attr_reader covariants: untyped
+      attr_reader covariants: Set[Symbol]
 
-      attr_reader contravariants: untyped
+      attr_reader contravariants: Set[Symbol]
 
-      def initialize: (covariants: untyped, contravariants: untyped) -> void
+      def initialize: (covariants: Set[Symbol], contravariants: Set[Symbol]) -> void
 
-      def covariant?: (untyped var) -> untyped
+      def covariant?: (Symbol var) -> bool
 
-      def contravariant?: (untyped var) -> untyped
+      def contravariant?: (Symbol var) -> bool
 
-      def invariant?: (untyped var) -> untyped
+      def invariant?: (Symbol var) -> bool
 
       def self.from_type: (AST::Types::t) -> VariableVariance
 
-      def self.from_method_type: (untyped method_type) -> untyped
+      def self.from_method_type: (Interface::MethodType method_type) -> VariableVariance
 
-      def self.add_params: (untyped params, block: untyped, covariants: untyped, contravariants: untyped) -> untyped
+      def self.add_params: (Interface::Function::Params params, block: bool, covariants: Set[Symbol], contravariants: Set[Symbol]) -> void
 
-      def self.add_type: (untyped `type`, variance: untyped, covariants: untyped, contravariants: untyped) -> untyped
+      def self.add_type: (AST::Types::t `type`, variance: :covariant | :contravariant | :invariant, covariants: Set[Symbol], contravariants: Set[Symbol]) -> void
     end
   end
 end

data/sig/steep/thread_waiter.rbs

@@ -0,0 +1,13 @@
+module Steep
+  class ThreadWaiter[A]
+    attr_reader objects: Array[A]
+
+    attr_reader queue: Thread::Queue
+
+    attr_reader waiter_threads: Set[Thread]
+
+    def initialize: (Array[A]) { (A) -> Thread } -> void
+
+    def wait_one: () -> Thread?
+  end
+end

data/sig/steep/type_construction.rbs

@@ -1,3 +1,5 @@
+use Steep::AST::Types
+
 module Steep
   class TypeConstruction
     class Pair
@@ -34,6 +36,8 @@ module Steep
 
     %a{pure} def module_context: () -> TypeInference::Context::ModuleContext
 
+    # `method_context` is `nil` outside of any `def` syntax
+    #
     %a{pure} def method_context: () -> TypeInference::Context::MethodContext?
 
     def method_context!: () -> TypeInference::Context::MethodContext
@@ -162,9 +166,11 @@ module Steep
     #
     def synthesize_constant: (Parser::AST::Node? node, Parser::AST::Node? parent_node, Symbol constant_name) ?{ () -> void } -> [AST::Types::t, TypeConstruction, RBS::TypeName?]
 
-    def optional_proc?: (untyped `type`) -> (untyped | nil | nil | nil | nil)
+    # Returns a proc type if given type is a two clause union with the proc type and `nil`
+    #
+    def optional_proc?: (AST::Types::t) -> AST::Types::Proc?
 
-    def type_lambda: (Parser::AST::Node & Parser::AST::_BlockNode node, params_node: Parser::AST::Node, body_node: Parser::AST::Node, type_hint: AST::Types::t?) -> Pair
+    def type_lambda: (Parser::AST::Node & Parser::AST::_BlockNode node, params_node: Parser::AST::Node, body_node: Parser::AST::Node?, type_hint: AST::Types::t?) -> Pair
 
     def synthesize_children: (Parser::AST::Node node, ?skips: Array[Parser::AST::Node?]) -> TypeConstruction
 
@@ -184,7 +190,8 @@ module Steep
       block_params: Parser::AST::Node?,
       block_body: Parser::AST::Node?,
       ?unwrap: bool,
-      tapp: AST::Node::TypeApplication?
+      tapp: AST::Node::TypeApplication?,
+      hint: Types::t?
     ) -> Pair
 
     # The second step to type check method calls, which handles type refinements on *pure* calls
@@ -201,7 +208,8 @@ module Steep
       arguments: Array[Parser::AST::Node],
       block_params: Parser::AST::Node?,
       block_body: Parser::AST::Node?,
-      tapp: AST::Node::TypeApplication?
+      tapp: AST::Node::TypeApplication?,
+      hint: Types::t?
     ) -> Pair
 
     # The third step to type check method calls, which tries all of the overlods defined for the method
@@ -218,7 +226,8 @@ module Steep
       arguments: Array[Parser::AST::Node],
       block_params: Parser::AST::Node?,
       block_body: Parser::AST::Node?,
-      tapp: AST::Node::TypeApplication?
+      tapp: AST::Node::TypeApplication?,
+      hint: Types::t?
     ) -> [TypeInference::MethodCall::t, TypeConstruction]?
 
     # The core to type check method calls, which implements type checking arguments including blocks and type inference
@@ -233,7 +242,8 @@ module Steep
       arguments: Array[Parser::AST::Node],
       block_params: Parser::AST::Node?,
       block_body: Parser::AST::Node?,
-      tapp: AST::Node::TypeApplication?
+      tapp: AST::Node::TypeApplication?,
+      hint: Types::t?
     ) -> [TypeInference::MethodCall::t, TypeConstruction]
 
     # Extra step to type check method calls, which implements custom typing rules based on the methods
@@ -247,7 +257,8 @@ module Steep
       method_type: Interface::MethodType,
       arguments: Array[Parser::AST::Node],
       block_params: Parser::AST::Node?,
-      block_body: Parser::AST::Node?
+      block_body: Parser::AST::Node?,
+      hint: Types::t?
     ) -> [TypeInference::MethodCall::t, TypeConstruction]?
 
     def builder_config: () -> Interface::Builder::Config
@@ -262,7 +273,7 @@ module Steep
 
     def expand_self: (untyped `type`) -> untyped
 
-    SPECIAL_METHOD_NAMES: { array_compact: untyped, hash_compact: untyped }
+    SPECIAL_METHOD_NAMES: Hash[Symbol, Set[method_name]]
 
     KNOWN_PURE_METHODS: Set[method_name]
 
@@ -301,6 +312,12 @@ module Steep
       Array[Diagnostic::Ruby::Base]
     ) -> TypeConstruction
 
+    # Type check arguments without known method type
+    #
+    # This handles `:splat` nodes and `:kwargs` node that appears as an argument.
+    #
+    def type_check_untyped_args: (Array[Parser::AST::Node] arguments) -> TypeConstruction
+
     def type_check_argument: (Parser::AST::Node node, type: AST::Types::t, constraints: Subtyping::Constraints, errors: Array[Diagnostic::Ruby::Base], ?report_node: Parser::AST::Node) -> Pair
 
     def type_block_without_hint: (node: Parser::AST::Node & Parser::AST::_BlockNode, block_annotations: AST::Annotation::Collection, block_params: TypeInference::BlockParams?, block_body: Parser::AST::Node?) ?{ (Diagnostic::Ruby::Base) -> void } -> void
@@ -485,7 +502,7 @@ module Steep
     # * When hint is union type, it tries recursively with the union cases.
     # * Otherwise, it tries to be a hash instance.
     #
-    def type_hash: (Parser::AST::Node hash_node, hint: AST::Types::t?) -> untyped
+    def type_hash: (Parser::AST::Node hash_node, hint: AST::Types::t?) -> Pair
 
     # Returns the first one from elements of `types` that returns a type `t` where `t <: hint`.
     #

data/sig/steep/type_inference/block_params.rbs

@@ -89,6 +89,12 @@ module Steep
         #
         def each_param: () { (Param) -> void } -> void
                       | () -> Enumerator[Param, void]
+
+        # Type that is constructed from `#params` type annotations
+        #
+        # Returns `nil` any part of the params is left un-annotated.
+        #
+        def type: () -> AST::Types::t?
       end
 
       attr_reader leading_params: Array[Param | MultipleParam]
@@ -151,8 +157,14 @@ module Steep
               | () -> Enumerator[Param | MultipleParam, void]
 
       # Yields `Param` recursively
-      # 
+      #
       def each_single_param: () { (Param) -> void } -> void
+
+      # Returns true if the parameter is single `untyped`
+      #
+      # This will automatically distribute `untyped` on block parameters.
+      #
+      def untyped_args?: (Interface::Function::Params) -> bool
     end
   end
 end

data/sig/steep/type_inference/context.rbs

@@ -8,7 +8,7 @@ module Steep
       #
       class MethodContext
         # Name of the method
-        attr_reader name: Symbol?
+        attr_reader name: Symbol
 
         # `nil` when RBS doesn't have the corresponding method definition
         attr_reader method: RBS::Definition::Method?
@@ -36,6 +36,10 @@ module Steep
 
         # Type of the block of the current method type
         def block_type: () -> Interface::Block?
+
+        # Returns `true` if the method is a setter -- ends with `=`
+        #
+        def attribute_setter?: () -> bool
       end
 
       # Information about the block which the body is being type checked

data/sig/steep/type_inference/context_array.rbs

@@ -2,36 +2,37 @@ module Steep
   module TypeInference
     class ContextArray
       class Entry
-        attr_reader range: untyped
+        attr_reader range: Range[Integer]
 
-        attr_reader context: untyped
+        attr_reader context: Context
 
-        attr_reader sub_entries: untyped
+        attr_reader sub_entries: Set[Entry]
 
-        def initialize: (range: untyped, context: untyped) -> void
+        def initialize: (range: Range[Integer], context: Context) -> void
       end
 
-      attr_reader buffer: untyped
+      attr_reader buffer: RBS::Buffer
 
-      attr_reader root: untyped
+      attr_reader root: Entry
 
-      def initialize: (buffer: untyped, context: untyped, ?range: untyped) -> void
+      def initialize: (buffer: RBS::Buffer, context: Context, ?range: Range[Integer]) -> void
 
-      def range: () -> untyped
+      def range: () -> Range[Integer]
 
-      def self.from_source: (source: untyped, ?range: untyped?, ?context: untyped?) -> untyped
+      def self.from_source: (source: Source, ?range: Range[Integer]?, context: Context) -> ContextArray
 
-      def insert_context: (untyped range, context: untyped, ?entry: untyped) -> untyped
+      def insert_context: (Range[Integer] range, context: Context, ?entry: Entry) -> void
 
-      def each_entry: () { (untyped) -> untyped } -> untyped
+      def each_entry: () { (Entry) -> void } -> void
+                    | () -> Enumerator[Entry, void]
 
-      def context_at: (untyped index, ?entry: untyped) -> (nil | untyped)
+      def context_at: (Integer index, ?entry: Entry) -> Context?
 
-      def []: (untyped index) -> untyped
+      def []: (Integer index) -> Context?
 
-      def at: (line: untyped, column: untyped) -> untyped
+      def at: (line: Integer, column: Integer) -> Context?
 
-      def merge: (untyped subtree) -> untyped
+      def merge: (ContextArray subtree) -> void
     end
   end
 end

data/sig/steep/type_inference/logic_type_interpreter.rbs

@@ -1,6 +1,34 @@
 module Steep
   module TypeInference
     class LogicTypeInterpreter
+      class Result
+        attr_reader env: TypeEnv
+
+        attr_reader type: AST::Types::t
+
+        attr_accessor unreachable: bool
+
+        def initialize: (env: TypeEnv, type: AST::Types::t, unreachable: bool) -> void
+
+        def update_env: () { () -> TypeEnv } -> Result
+
+        def update_type: { () -> AST::Types::t } -> Result
+
+        # Make the instance unreachable, and returns self
+        #
+        def unreachable!: () -> self
+      end
+
+      TRUE: AST::Types::Literal
+
+      FALSE: AST::Types::Literal
+
+      BOOL: AST::Types::Boolean
+
+      BOT: AST::Types::Bot
+
+      UNTYPED: AST::Types::Any
+
       attr_reader subtyping: Subtyping::Check
 
       attr_reader typing: Typing
@@ -11,11 +39,11 @@ module Steep
 
       def initialize: (subtyping: Subtyping::Check, typing: Typing, config: Interface::Builder::Config) -> void
 
-      def eval: (env: TypeEnv, node: Parser::AST::Node) -> [TypeEnv, TypeEnv, Set[Symbol | Parser::AST::Node], AST::Types::t, AST::Types::t]
+      def eval: (env: TypeEnv, node: Parser::AST::Node) -> [Result, Result]
 
-      def evaluate_node: (env: TypeEnv, node: Parser::AST::Node, refined_objects: Set[Symbol | Parser::AST::Node]) -> [AST::Types::t, AST::Types::t, TypeEnv, TypeEnv]
+      def evaluate_node: (env: TypeEnv, node: Parser::AST::Node, ?type: AST::Types::t) -> [Result, Result]
 
-      def evaluate_method_call: (env: TypeEnv, type: AST::Types::Logic::Base, receiver: Parser::AST::Node?, arguments: Array[Parser::AST::Node], refined_objects: Set[Symbol | Parser::AST::Node]) -> [TypeEnv, TypeEnv]?
+      def evaluate_method_call: (env: TypeEnv, type: AST::Types::Logic::Base, receiver: Parser::AST::Node?, arguments: Array[Parser::AST::Node]) -> [Result, Result]?
 
       # Apply type refinement to `node` as `truthy_type` and `falsy_type`.
       #
@@ -27,7 +55,7 @@ module Steep
       # * `node` is a `lvasgn`
       # * `node` is a _pure_ method call
       #
-      def refine_node_type: (env: TypeEnv, node: Parser::AST::Node, truthy_type: AST::Types::t, falsy_type: AST::Types::t, refined_objects: Set[Symbol | Parser::AST::Node]) -> [TypeEnv, TypeEnv]
+      def refine_node_type: (env: TypeEnv, node: Parser::AST::Node, truthy_type: AST::Types::t, falsy_type: AST::Types::t) -> [TypeEnv, TypeEnv]
 
       # Returns a pair of a node and set of local variable names.
       #
@@ -45,7 +73,9 @@ module Steep
 
       private
 
-      def evaluate_assignment: (Parser::AST::Node node, TypeEnv env, AST::Types::t rhs_type, refined_objects: Set[Symbol | Parser::AST::Node]) -> TypeEnv
+      # Assign local variables included in the assignment node and masgn node
+      #
+      def evaluate_assignment: (Parser::AST::Node node, TypeEnv env, AST::Types::t rhs_type) -> TypeEnv
 
       def guess_type_from_method: (Parser::AST::Node node) -> (AST::Types::Logic::ReceiverIsArg | AST::Types::Logic::ReceiverIsNil | AST::Types::Logic::Not | AST::Types::Logic::ArgIsReceiver | nil)
 
@@ -64,7 +94,7 @@ module Steep
       #
       def literal_var_type_case_select: (Parser::AST::Node value_node, AST::Types::t arg_type) -> [Array[AST::Types::t], Array[AST::Types::t]]?
 
-      def type_case_select: (AST::Types::t `type`, RBS::TypeName klass) -> [AST::Types::t, AST::Types::t]
+      def type_case_select: (AST::Types::t `type`, RBS::TypeName klass) -> [AST::Types::t?, AST::Types::t?]
 
       def type_case_select0: (AST::Types::t `type`, RBS::TypeName klass) -> [Array[AST::Types::t], Array[AST::Types::t]]
 

data/sig/steep/type_inference/type_env_builder.rbs

@@ -49,7 +49,11 @@ module Steep
         end
 
         class ImportInstanceVariableAnnotations < AnnotationsBase
+          def merge!: (?bool) -> self
+                    
           include _Base
+
+          @merge: bool
         end
 
         class ImportInstanceVariableDefinition