steep 0.11.1 → 0.12.0

data/vendor/ruby-signature/lib/ruby/signature/constant.rb

@@ -0,0 +1,28 @@
+module Ruby
+  module Signature
+    class Constant
+      attr_reader :name
+      attr_reader :type
+      attr_reader :declaration
+
+      def initialize(name:, type:, declaration:)
+        @name = name
+        @type = type
+        @declaration = declaration
+      end
+
+      def ==(other)
+        other.is_a?(Constant) &&
+          other.name == name &&
+          other.type == type &&
+          other.declaration == declaration
+      end
+
+      alias eql? ==
+
+      def hash
+        self.class.hash ^ name.hash ^ type.hash ^ declaration.hash
+      end
+    end
+  end
+end

data/vendor/ruby-signature/lib/ruby/signature/constant_table.rb

@@ -0,0 +1,152 @@
+module Ruby
+  module Signature
+    class ConstantTable
+      attr_reader :definition_builder
+      attr_reader :constant_scopes_cache
+
+      def env
+        definition_builder.env
+      end
+
+      def initialize(builder:)
+        @definition_builder = builder
+        @constant_scopes_cache = {}
+      end
+
+      def name_to_constant(name)
+        case
+        when env.name_to_constant.key?(name)
+          decl = env.name_to_constant[name]
+          type = env.absolute_type(decl.type, namespace: name.namespace) {|type| type.name.absolute! }
+          Constant.new(name: name, type: type, declaration: decl)
+        when env.class?(name)
+          decl = env.name_to_decl[name]
+          type = Types::ClassSingleton.new(name: name, location: nil)
+          Constant.new(name: name, type: type, declaration: decl)
+        end
+      end
+
+      def split_name(name)
+        name.namespace.path + [name.name]
+      end
+
+      def resolve_constant_reference(name, context:)
+        head, *tail = split_name(name)
+
+        head_constant = case
+                        when name.absolute?
+                          name_to_constant(TypeName.new(name: head, namespace: Namespace.root))
+                        when !context || context.empty?
+                          name_to_constant(TypeName.new(name: head, namespace: Namespace.root))
+                        else
+                          resolve_constant_reference_context(head, context: context) ||
+                            resolve_constant_reference_inherit(head,
+                                                               scopes: constant_scopes(context.to_type_name))
+                        end
+
+        if head_constant
+          tail.inject(head_constant) do |constant, name|
+            resolve_constant_reference_inherit name,
+                                               scopes: constant_scopes(constant.name),
+                                               no_object: constant.name != BuiltinNames::Object.name
+          end
+        end
+      end
+
+      def resolve_constant_reference_context(name, context:)
+        if context.empty?
+          nil
+        else
+          name_to_constant(TypeName.new(name: name, namespace: context)) ||
+            resolve_constant_reference_context(name, context: context.parent)
+        end
+      end
+
+      def resolve_constant_reference_inherit(name, scopes:, no_object: false)
+        scopes.each do |context|
+          if context.path == [:Object]
+            unless no_object
+              constant = name_to_constant(TypeName.new(name: name, namespace: context)) ||
+                name_to_constant(TypeName.new(name: name, namespace: Namespace.root))
+            end
+          else
+            constant = name_to_constant(TypeName.new(name: name, namespace: context))
+          end
+
+          return constant if constant
+        end
+
+        nil
+      end
+
+      def constant_scopes(name)
+        constant_scopes_cache[name] ||= constant_scopes0(name, scopes: [])
+      end
+
+      def constant_scopes_module(name, scopes:)
+        decl = env.find_class(name)
+        namespace = name.to_namespace
+
+        decl.members.each do |member|
+          case member
+          when AST::Members::Include
+            constant_scopes_module absolute_type_name(member.name, namespace: namespace),
+                                   scopes: scopes
+          end
+        end
+
+        scopes.unshift namespace
+      end
+
+      def constant_scopes0(name, scopes: [])
+        decl = env.find_class(name)
+        namespace = name.to_namespace
+
+        case decl
+        when AST::Declarations::Module
+          constant_scopes0 BuiltinNames::Module.name, scopes: scopes
+          constant_scopes_module name, scopes: scopes
+
+        when AST::Declarations::Class
+          unless name == BuiltinNames::BasicObject.name
+            super_name = decl.super_class&.yield_self {|super_class|
+              absolute_type_name(super_class.name, namespace: namespace)
+            } || BuiltinNames::Object.name
+
+            constant_scopes0 super_name, scopes: scopes
+          end
+
+          decl.members.each do |member|
+            case member
+            when AST::Members::Include
+              constant_scopes_module absolute_type_name(member.name, namespace: namespace),
+                                     scopes: scopes
+            end
+          end
+
+          scopes.unshift namespace
+        else
+          raise "Unexpected declaration: #{name}"
+        end
+
+        env.each_extension(name).sort_by {|e| e.extension_name.to_s }.each do |extension|
+          extension.members.each do |member|
+            case member
+            when AST::Members::Include
+              constant_scopes_module absolute_type_name(member.name, namespace: namespace),
+                                     scopes: []
+            end
+          end
+        end
+
+        scopes
+      end
+
+      def absolute_type_name(name, namespace:)
+        env.absolute_type_name(name, namespace: namespace) do
+          raise
+        end
+      end
+    end
+  end
+end

data/vendor/ruby-signature/lib/ruby/signature/definition.rb

@@ -0,0 +1,172 @@
+module Ruby
+  module Signature
+    class Definition
+      class Variable
+        attr_reader :parent_variable
+        attr_reader :type
+        attr_reader :declared_in
+
+        def initialize(parent_variable:, type:, declared_in:)
+          @parent_variable = parent_variable
+          @type = type
+          @declared_in = declared_in
+        end
+      end
+
+      class Method
+        attr_reader :super_method
+        attr_reader :method_types
+        attr_reader :defined_in
+        attr_reader :implemented_in
+        attr_reader :accessibility
+        attr_reader :attributes
+        attr_reader :annotations
+        attr_reader :comment
+
+        def initialize(super_method:, method_types:, defined_in:, implemented_in:, accessibility:, attributes:, annotations:, comment:)
+          @super_method = super_method
+          @method_types = method_types
+          @defined_in = defined_in
+          @implemented_in = implemented_in
+          @accessibility = accessibility
+          @attributes = attributes
+          @annotations = annotations
+          @comment = comment
+        end
+
+        def public?
+          @accessibility == :public
+        end
+
+        def private?
+          @accessibility == :private
+        end
+
+        def sub(s)
+          self.class.new(
+            super_method: super_method&.sub(s),
+            method_types: method_types.map {|ty| ty.sub(s) },
+            defined_in: defined_in,
+            implemented_in: implemented_in,
+            accessibility: @accessibility,
+            attributes: attributes,
+            annotations: annotations,
+            comment: comment
+          )
+        end
+
+        def map_type(&block)
+          self.class.new(
+            super_method: super_method&.map_type(&block),
+            method_types: method_types.map do |ty|
+              ty.map_type(&block)
+            end,
+            defined_in: defined_in,
+            implemented_in: implemented_in,
+            accessibility: @accessibility,
+            attributes: attributes,
+            annotations: annotations,
+            comment: comment
+          )
+        end
+      end
+
+      module Ancestor
+        Instance = Struct.new(:name, :args, keyword_init: true)
+        Singleton = Struct.new(:name, keyword_init: true)
+        ExtensionInstance = Struct.new(:name, :extension_name, :args, keyword_init: true)
+        ExtensionSingleton = Struct.new(:name, :extension_name, keyword_init: true)
+      end
+
+      attr_reader :declaration
+      attr_reader :self_type
+      attr_reader :methods
+      attr_reader :instance_variables
+      attr_reader :class_variables
+      attr_reader :ancestors
+
+      def initialize(declaration:, self_type:, ancestors:)
+        unless declaration.is_a?(AST::Declarations::Class) ||
+          declaration.is_a?(AST::Declarations::Module) ||
+          declaration.is_a?(AST::Declarations::Interface) ||
+          declaration.is_a?(AST::Declarations::Extension)
+          raise "Declaration should be a class, module, or interface: #{declaration.name}"
+        end
+
+        unless (self_type.is_a?(Types::ClassSingleton) || self_type.is_a?(Types::Interface) || self_type.is_a?(Types::ClassInstance)) && self_type.name == declaration.name.absolute!
+          raise "self_type should be the type of declaration: #{self_type}"
+        end
+
+        @self_type = self_type
+        @declaration = declaration
+        @methods = {}
+        @instance_variables = {}
+        @class_variables = {}
+        @ancestors = ancestors
+      end
+
+      def name
+        declaration.name
+      end
+
+      def class?
+        declaration.is_a?(AST::Declarations::Class)
+      end
+
+      def module?
+        declaration.is_a?(AST::Declarations::Module)
+      end
+
+      def class_type?
+        @self_type.is_a?(Types::ClassSingleton)
+      end
+
+      def instance_type?
+        @self_type.is_a?(Types::ClassInstance)
+      end
+
+      def interface_type?
+        @self_type.is_a?(Types::Interface)
+      end
+
+      def type_params
+        @self_type.args.map(&:name)
+      end
+
+      def type_params_decl
+        case declaration
+        when AST::Declarations::Extension
+          nil
+        else
+          declaration.type_params
+        end
+      end
+
+      def each_type(&block)
+        if block_given?
+          methods.each_value do |method|
+            if method.defined_in == self.declaration
+              method.method_types.each do |method_type|
+                method_type.each_type(&block)
+              end
+            end
+          end
+
+          instance_variables.each_value do |var|
+            if var.declared_in == self.declaration
+              yield var.type
+            end
+          end
+
+          class_variables.each_value do |var|
+            if var.declared_in == self.declaration
+              yield var.type
+            end
+          end
+        else
+          enum_for :each_type
+        end
+      end
+    end
+  end
+end

data/vendor/ruby-signature/lib/ruby/signature/definition_builder.rb

@@ -0,0 +1,921 @@
+module Ruby
+  module Signature
+    class DefinitionBuilder
+      attr_reader :env
+      attr_reader :instance_cache
+      attr_reader :singleton_cache
+
+      def initialize(env:)
+        @env = env
+        @instance_cache = {}
+        @singleton_cache = {}
+      end
+
+      def build_ancestors(self_ancestor, ancestors: [], building_ancestors: [], location: nil)
+        decl = env.find_class(self_ancestor.name)
+        namespace = self_ancestor.name.absolute!.to_namespace
+
+        RecursiveAncestorError.check!(self_ancestor,
+                                      ancestors: building_ancestors,
+                                      location: location || decl.location)
+        building_ancestors.push self_ancestor
+
+        case self_ancestor
+        when Definition::Ancestor::Instance
+          args = self_ancestor.args
+          param_names = decl.type_params.each.map(&:name)
+
+          InvalidTypeApplicationError.check!(
+            type_name: self_ancestor.name,
+            args: args,
+            params: decl.type_params,
+            location: location || decl.location
+          )
+
+          sub = Substitution.build(param_names, args)
+
+          case decl
+          when AST::Declarations::Class
+            unless self_ancestor.name == BuiltinNames::BasicObject.name
+              super_ancestor = decl.super_class&.yield_self do |super_class|
+                Definition::Ancestor::Instance.new(
+                  name: absolute_type_name(super_class.name, namespace: namespace, location: location || decl.location),
+                  args: super_class.args.map {|ty| absolute_type(ty.sub(sub), namespace: namespace) }
+                )
+              end || Definition::Ancestor::Instance.new(name: BuiltinNames::Object.name, args: [])
+
+              build_ancestors(super_ancestor, ancestors: ancestors, building_ancestors: building_ancestors)
+            end
+          end
+
+          decl.members.each do |member|
+            case member
+            when AST::Members::Include
+              if member.name.class?
+                ancestor = Definition::Ancestor::Instance.new(
+                  name: absolute_type_name(member.name, namespace: namespace, location: member.location),
+                  args: member.args.map {|ty| absolute_type(ty.sub(sub), namespace: namespace) }
+                )
+                build_ancestors ancestor, ancestors: ancestors, building_ancestors: building_ancestors, location: member.location
+              end
+            end
+          end
+
+          ancestors.unshift(self_ancestor)
+
+          env.each_extension(self_ancestor.name).sort_by {|e| e.extension_name.to_s }.each do |extension|
+            InvalidExtensionParameterError.check!(
+              type_name: self_ancestor.name,
+              extension_name: extension.extension_name,
+              extension_params: extension.type_params,
+              class_params: self_ancestor.args.map(&:name),
+              location: extension.location
+            )
+
+            sub = Substitution.build(extension.type_params, self_ancestor.args)
+
+            extension.members.each do |member|
+              case member
+              when AST::Members::Include
+                if member.name.class?
+                  ancestor = Definition::Ancestor::Instance.new(
+                    name: absolute_type_name(member.name, namespace: namespace, location: member.location),
+                    args: member.args.map {|ty| absolute_type(ty.sub(sub), namespace: namespace) }
+                  )
+                  build_ancestors ancestor, ancestors: ancestors, building_ancestors: building_ancestors, location: member.location
+                end
+              end
+            end
+
+            extension_ancestor = Definition::Ancestor::ExtensionInstance.new(
+              name: extension.name.absolute!,
+              extension_name: extension.extension_name,
+              args: self_ancestor.args,
+            )
+            ancestors.unshift(extension_ancestor)
+
+            extension.members.each do |member|
+              case member
+              when AST::Members::Prepend
+                if member.name.class?
+                  ancestor = Definition::Ancestor::Instance.new(
+                    name: absolute_type_name(member.name, namespace: namespace, location: member.location),
+                    args: member.args.map {|ty| absolute_type(ty.sub(sub), namespace: namespace) }
+                  )
+                  build_ancestors ancestor, ancestors: ancestors, building_ancestors: building_ancestors, location: member.location
+                end
+              end
+            end
+          end
+
+          decl.members.each do |member|
+            case member
+            when AST::Members::Prepend
+              ancestor = Definition::Ancestor::Instance.new(
+                name: absolute_type_name(member.name, namespace: namespace, location: member.location),
+                args: member.args.map {|ty| absolute_type(ty.sub(sub), namespace: namespace) }
+              )
+              build_ancestors ancestor, ancestors: ancestors, building_ancestors: building_ancestors, location: member.location
+            end
+          end
+        when Definition::Ancestor::Singleton
+          case decl
+          when AST::Declarations::Class
+            if self_ancestor.name == BuiltinNames::BasicObject.name
+              class_ancestor = Definition::Ancestor::Instance.new(
+                name: BuiltinNames::Class.name,
+                args: []
+              )
+              build_ancestors class_ancestor, ancestors: ancestors, building_ancestors: building_ancestors
+            else
+              super_ancestor = decl.super_class&.yield_self do |super_class|
+                Definition::Ancestor::Singleton.new(
+                  name: absolute_type_name(super_class.name, namespace: namespace, location: location || decl.location)
+                )
+              end || Definition::Ancestor::Singleton.new(name: BuiltinNames::Object.name)
+
+              build_ancestors(super_ancestor, ancestors: ancestors, building_ancestors: building_ancestors)
+            end
+          when AST::Declarations::Module
+            module_ancestor = Definition::Ancestor::Instance.new(
+              name: BuiltinNames::Module.name,
+              args: []
+            )
+            build_ancestors module_ancestor, ancestors: ancestors, building_ancestors: building_ancestors
+          end
+
+          decl.members.each do |member|
+            case member
+            when AST::Members::Extend
+              if member.name.class?
+                ancestor = Definition::Ancestor::Instance.new(
+                  name: absolute_type_name(member.name, namespace: namespace, location: member.location),
+                  args: member.args.map {|ty| absolute_type(ty.sub(sub), namespace: namespace) }
+                )
+                build_ancestors ancestor, ancestors: ancestors, building_ancestors: building_ancestors, location: member.location
+              end
+            end
+          end
+
+          ancestors.unshift(self_ancestor)
+
+          env.each_extension(self_ancestor.name).sort_by {|e| e.extension_name.to_s }.each do |extension|
+            extension.members.each do |member|
+              case member
+              when AST::Members::Extend
+                if member.name.class?
+                  ancestor = Definition::Ancestor::Instance.new(
+                    name: absolute_type_name(member.name, namespace: namespace, location: member.location),
+                    args: member.args.map {|ty| absolute_type(ty, namespace: namespace) }
+                  )
+                  build_ancestors ancestor, ancestors: ancestors, building_ancestors: building_ancestors, location: member.location
+                end
+              end
+            end
+
+            extension_ancestor = Definition::Ancestor::ExtensionSingleton.new(
+              name: extension.name.absolute!,
+              extension_name: extension.extension_name
+            )
+            ancestors.unshift(extension_ancestor)
+          end
+        end
+
+        building_ancestors.pop
+
+        ancestors
+      end
+
+      def each_member_with_accessibility(members, accessibility: :public)
+        members.each do |member|
+          case member
+          when AST::Members::Public
+            accessibility = :public
+          when AST::Members::Private
+            accessibility = :private
+          else
+            yield member, accessibility
+          end
+        end
+      end
+
+      def build_instance(type_name)
+        try_cache type_name, cache: instance_cache do
+          decl = env.find_class(type_name)
+          self_ancestor = Definition::Ancestor::Instance.new(name: type_name,
+                                                             args: Types::Variable.build(decl.type_params.each.map(&:name)))
+          self_type = Types::ClassInstance.new(name: type_name, args: self_ancestor.args, location: nil)
+
+          case decl
+          when AST::Declarations::Class, AST::Declarations::Module
+            ancestors = build_ancestors(self_ancestor)
+            definition_pairs = ancestors.map do |ancestor|
+              case ancestor
+              when Definition::Ancestor::Instance
+                [ancestor, build_one_instance(ancestor.name)]
+              when Definition::Ancestor::Singleton
+                [ancestor, build_one_singleton(ancestor.name)]
+              when Definition::Ancestor::ExtensionInstance
+                [ancestor, build_one_instance(ancestor.name, extension_name: ancestor.extension_name)]
+              when Definition::Ancestor::ExtensionSingleton
+                [ancestor, build_one_extension_singleton(ancestor.name, extension_name: ancestor.extension_name)]
+              end
+            end
+
+            if decl.is_a?(AST::Declarations::Module)
+              if decl.self_type
+                self_interface = absolute_type(decl.self_type, namespace: type_name.to_namespace)
+                ancestor = Definition::Ancestor::Instance.new(name: self_interface.name,
+                                                              args: self_interface.args)
+
+                definition_pairs.push [ancestor, build_one_instance(ancestor.name)]
+              end
+            end
+
+            merge_definitions(definition_pairs, decl: decl, self_type: self_type, ancestors: ancestors)
+          end
+        end
+      end
+
+      def build_singleton(type_name)
+        try_cache type_name, cache: singleton_cache do
+          decl = env.find_class(type_name)
+          self_ancestor = Definition::Ancestor::Singleton.new(name: type_name)
+          self_type = Types::ClassSingleton.new(name: type_name, location: nil)
+
+          case decl
+          when AST::Declarations::Class, AST::Declarations::Module
+            ancestors = build_ancestors(self_ancestor)
+            definition_pairs = ancestors.map do |ancestor|
+              case ancestor
+              when Definition::Ancestor::Instance
+                [ancestor, build_one_instance(ancestor.name)]
+              when Definition::Ancestor::Singleton
+                [ancestor, build_one_singleton(ancestor.name)]
+              when Definition::Ancestor::ExtensionInstance
+                [ancestor, build_one_instance(ancestor.name, extension_name: ancestor.extension_name)]
+              when Definition::Ancestor::ExtensionSingleton
+                [ancestor, build_one_singleton(ancestor.name, extension_name: ancestor.extension_name)]
+              end
+            end
+
+            if decl.is_a?(AST::Declarations::Class)
+              definition_pairs.find {|ancestor, _| ancestor == self_ancestor }.tap do |_, definition|
+                unless definition.methods[:new]&.implemented_in == decl
+                  instance_definition = build_instance(type_name)
+                  class_params = decl.type_params.each.map(&:name)
+                  initialize_method = instance_definition.methods[:initialize]
+                  method_types = initialize_method.method_types.map do |method_type|
+                    case method_type
+                    when MethodType
+                      fvs = method_type.free_variables + class_params
+                      unless fvs.empty?
+                        param_name_set = Set.new(class_params)
+                        bound_variables = method_type.type_params
+                        renamed_types = bound_variables.map do |x|
+                          if param_name_set.member?(x)
+                            Types::Variable.fresh(x)
+                          else
+                            Types::Variable.new(name: x, location: nil)
+                          end
+                        end
+                        sub = Substitution.build(bound_variables, renamed_types)
+                        method_type_params = renamed_types.unshift(*class_params)
+                      else
+                        sub = Substitution.build([], [])
+                        method_type_params = method_type.type_params
+                      end
+
+                      MethodType.new(
+                        type_params: method_type_params,
+                        type: method_type.type.sub(sub).with_return_type(instance_definition.self_type),
+                        block: method_type.block&.yield_self {|ty| ty.sub(sub) },
+                        location: method_type.location
+                      )
+                    end
+                  end.compact
+
+                  definition.methods[:new] = Definition::Method.new(
+                    super_method: nil,
+                    defined_in: nil,
+                    implemented_in: env.find_class(Ruby::Signature::BuiltinNames::Class.name),
+                    method_types: method_types,
+                    accessibility: :public,
+                    attributes: [:incompatible],
+                    annotations: [],
+                    comment: nil
+                  )
+                end
+              end
+            end
+
+            merge_definitions(definition_pairs, decl: decl, self_type: self_type, ancestors: ancestors)
+          end
+        end
+      end
+
+      def build_one_instance(type_name, extension_name: nil)
+        decl = if extension_name
+                 env.each_extension(type_name).find {|ext| ext.extension_name == extension_name } or
+                   raise "Unknown extension: #{type_name} (#{extension_name})"
+               else
+                 env.find_class(type_name)
+               end
+
+        case decl
+        when AST::Declarations::Interface
+          build_interface type_name, decl
+        else
+          namespace = type_name.to_namespace
+
+          case decl
+          when AST::Declarations::Class, AST::Declarations::Module
+            self_type = Types::ClassInstance.new(name: type_name,
+                                                 args: Types::Variable.build(decl.type_params.each.map(&:name)),
+                                                 location: nil)
+            ancestors = [Definition::Ancestor::Instance.new(name: type_name, args: self_type.args)]
+          when AST::Declarations::Extension
+            self_type = Types::ClassInstance.new(name: type_name, args: Types::Variable.build(decl.type_params), location: nil)
+            ancestors = [Definition::Ancestor::ExtensionInstance.new(name: type_name,
+                                                                     extension_name: extension_name,
+                                                                     args: self_type.args)]
+          end
+
+          Definition.new(declaration: decl, self_type: self_type, ancestors: ancestors).tap do |definition|
+            alias_members = []
+
+            each_member_with_accessibility(decl.members) do |member, accessibility|
+              case member
+              when AST::Members::MethodDefinition
+                if member.instance?
+                  name = member.name
+                  method_types = member.types.map do |method_type|
+                    case method_type
+                    when MethodType
+                      method_type.map_type do |type|
+                        absolute_type(type, namespace: namespace)
+                      end
+                    when :super
+                      :super
+                    end
+                  end
+
+                  DuplicatedMethodDefinitionError.check!(
+                    decl: decl,
+                    methods: definition.methods,
+                    name: name,
+                    location: member.location
+                  )
+
+                  attrs = if name == :initialize
+                            (member.attributes + [:incompatible]).uniq
+                          else
+                            member.attributes
+                          end
+
+                  definition.methods[name] = Definition::Method.new(super_method: nil,
+                                                                    method_types: method_types,
+                                                                    defined_in: decl,
+                                                                    implemented_in: decl,
+                                                                    accessibility: accessibility,
+                                                                    attributes: attrs,
+                                                                    annotations: member.annotations,
+                                                                    comment: member.comment)
+                end
+              when AST::Members::AttrReader, AST::Members::AttrAccessor, AST::Members::AttrWriter
+                name = member.name
+                type = absolute_type(member.type, namespace: namespace)
+                ivar_name = case member.ivar_name
+                            when false
+                              nil
+                            else
+                              member.ivar_name || :"@#{member.name}"
+                            end
+
+                if member.is_a?(AST::Members::AttrReader) || member.is_a?(AST::Members::AttrAccessor)
+                  definition.methods[name] = Definition::Method.new(
+                    super_method: nil,
+                    method_types: [
+                      MethodType.new(
+                        type_params: [],
+                        type: Types::Function.empty(type),
+                        block: nil,
+                        location: nil
+                      )
+                    ],
+                    defined_in: decl,
+                    implemented_in: decl,
+                    accessibility: accessibility,
+                    attributes: [],
+                    annotations: member.annotations,
+                    comment: member.comment
+                  )
+                end
+
+                if member.is_a?(AST::Members::AttrWriter) || member.is_a?(AST::Members::AttrAccessor)
+                  definition.methods[:"#{name}="] = Definition::Method.new(
+                    super_method: nil,
+                    method_types: [
+                      MethodType.new(
+                        type_params: [],
+                        type: Types::Function.new(required_positionals: [Types::Function::Param.new(name: name, type: type)],
+                                                  optional_positionals: [],
+                                                  rest_positionals: nil,
+                                                  trailing_positionals: [],
+                                                  required_keywords: {},
+                                                  optional_keywords: {},
+                                                  rest_keywords: nil,
+                                                  return_type: type),
+                        block: nil,
+                        location: nil
+                      )
+                    ],
+                    defined_in: decl,
+                    implemented_in: decl,
+                    accessibility: accessibility,
+                    attributes: [],
+                    annotations: member.annotations,
+                    comment: member.comment
+                  )
+                end
+
+                if ivar_name
+                  definition.instance_variables[ivar_name] = Definition::Variable.new(
+                    parent_variable: nil,
+                    type: type,
+                    declared_in: decl
+                  )
+                end
+
+              when AST::Members::Alias
+                if member.instance?
+                  alias_members << member
+                end
+              when AST::Members::Include
+                if member.name.interface?
+                  absolute_name = absolute_type_name(member.name, namespace: namespace, location: member.location)
+                  interface_definition = build_one_instance(absolute_name)
+                  absolute_args = member.args.map {|ty| absolute_type(ty, namespace: namespace) }
+
+                  InvalidTypeApplicationError.check!(
+                    type_name: absolute_name,
+                    args: absolute_args,
+                    params: interface_definition.type_params_decl,
+                    location: member.location
+                  )
+
+                  sub = Substitution.build(interface_definition.type_params, absolute_args)
+                  interface_definition.methods.each do |name, method|
+                    method_types = method.method_types.map do |method_type|
+                      method_type.sub(sub).map_type do |type|
+                        absolute_type(type, namespace: namespace)
+                      end
+                    end
+
+                    DuplicatedMethodDefinitionError.check!(
+                      decl: decl,
+                      methods: definition.methods,
+                      name: name,
+                      location: member.location
+                    )
+
+                    definition.methods[name] = Definition::Method.new(
+                      super_method: nil,
+                      method_types: method_types,
+                      defined_in: method.defined_in,
+                      implemented_in: decl,
+                      accessibility: method.accessibility,
+                      attributes: [],
+                      annotations: method.annotations,
+                      comment: member.comment
+                    )
+                  end
+                end
+              when AST::Members::InstanceVariable
+                definition.instance_variables[member.name] = Definition::Variable.new(
+                  type: absolute_type(member.type, namespace: namespace),
+                  parent_variable: nil,
+                  declared_in: decl
+                )
+              when AST::Members::ClassVariable
+                definition.class_variables[member.name] = Definition::Variable.new(
+                  type: absolute_type(member.type, namespace: namespace),
+                  parent_variable: nil,
+                  declared_in: decl
+                )
+              end
+            end
+
+            alias_members.each do |member|
+              UnknownMethodAliasError.check!(
+                methods: definition.methods,
+                original_name: member.old_name,
+                aliased_name: member.new_name,
+                location: member.location
+              )
+
+              DuplicatedMethodDefinitionError.check!(
+                decl: decl,
+                methods: definition.methods,
+                name: member.new_name,
+                location: member.location
+              )
+
+              # FIXME: may cause a problem if #old_name has super type
+              definition.methods[member.new_name] = definition.methods[member.old_name]
+            end
+
+            validate_parameter_variance(
+              decl: decl,
+              methods: definition.methods
+            )
+          end
+        end
+      end
+
+      def validate_params_with(type_params, result:)
+        type_params.each do |param|
+          unless param.skip_validation
+            unless result.compatible?(param.name, with_annotation: param.variance)
+              yield param
+            end
+          end
+        end
+      end
+
+      def validate_parameter_variance(decl:, methods:)
+        type_params = case decl
+                      when AST::Declarations::Extension
+                        env.find_class(decl.name.absolute!).type_params.rename_to(decl.type_params)
+                      else
+                        decl.type_params
+                      end
+
+        namespace = decl.name.absolute!.to_namespace
+        calculator = VarianceCalculator.new(builder: self)
+        param_names = type_params.each.map(&:name)
+
+        errors = []
+
+        if decl.is_a?(AST::Declarations::Class)
+          if decl.super_class
+            absolute_super_name = absolute_type_name(decl.super_class.name, namespace: namespace, location: decl.location)
+            absolute_args = decl.super_class.args.map {|type| absolute_type(type, namespace: namespace) }
+            result = calculator.in_inherit(name: absolute_super_name, args: absolute_args, variables: param_names)
+
+            validate_params_with type_params, result: result do |param|
+              errors.push InvalidVarianceAnnotationError::InheritanceError.new(
+                param: param
+              )
+            end
+          end
+        end
+
+        decl.members.each do |member|
+          case member
+          when AST::Members::Include
+            if member.name.class?
+              absolute_module_name = absolute_type_name(member.name, namespace: namespace, location: decl.location)
+              absolute_args = member.args.map {|type| absolute_type(type, namespace: namespace) }
+              result = calculator.in_inherit(name: absolute_module_name, args: absolute_args, variables: param_names)
+
+              validate_params_with type_params, result: result do |param|
+                errors.push InvalidVarianceAnnotationError::MixinError.new(
+                  include_member: member,
+                  param: param
+                )
+              end
+            end
+          end
+        end
+
+        methods.each do |name, method|
+          method.method_types.each do |method_type|
+            case method_type
+            when MethodType
+              result = calculator.in_method_type(method_type: method_type, variables: param_names)
+
+              validate_params_with type_params, result: result do |param|
+                errors.push InvalidVarianceAnnotationError::MethodTypeError.new(
+                  method_name: name,
+                  method_type: method_type,
+                  param: param
+                )
+              end
+            end
+          end
+        end
+
+        unless errors.empty?
+          raise InvalidVarianceAnnotationError.new(decl: decl, errors: errors)
+        end
+      end
+
+      def build_one_singleton(type_name, extension_name: nil)
+        decl = if extension_name
+                 env.each_extension(type_name).find {|ext| ext.extension_name == extension_name } or
+                   raise "Unknown extension: #{type_name} (#{extension_name})"
+               else
+                 env.find_class(type_name)
+               end
+
+        namespace = type_name.to_namespace
+
+        case decl
+        when AST::Declarations::Module, AST::Declarations::Class
+          self_type = Types::ClassSingleton.new(name: type_name, location: nil)
+          ancestors = [Definition::Ancestor::Singleton.new(name: type_name)]
+        when AST::Declarations::Extension
+          self_type = Types::ClassSingleton.new(name: type_name, location: nil)
+          ancestors = [Definition::Ancestor::ExtensionSingleton.new(name: type_name, extension_name: extension_name)]
+        end
+
+        Definition.new(declaration: decl, self_type: self_type, ancestors: ancestors).tap do |definition|
+          alias_members = []
+
+          each_member_with_accessibility(decl.members) do |member, accessibility|
+            case member
+            when AST::Members::MethodDefinition
+              if member.singleton?
+                name = member.name
+                method_types = member.types.map do |method_type|
+                  method_type.map_type do |type|
+                    absolute_type(type, namespace: namespace)
+                  end
+                end
+
+                DuplicatedMethodDefinitionError.check!(
+                  decl: decl,
+                  methods: definition.methods,
+                  name: name,
+                  location: member.location
+                )
+
+                definition.methods[name] = Definition::Method.new(super_method: nil,
+                                                                  method_types: method_types,
+                                                                  defined_in: decl,
+                                                                  implemented_in: decl,
+                                                                  accessibility: accessibility,
+                                                                  attributes: member.attributes,
+                                                                  annotations: member.annotations,
+                                                                  comment: member.comment)
+              end
+            when AST::Members::Alias
+              if member.singleton?
+                alias_members << member
+              end
+            when AST::Members::Extend
+              if member.name.interface?
+                absolute_name = absolute_type_name(member.name, namespace: namespace, location: member.location)
+                interface_definition = build_one_instance(absolute_name)
+                absolute_args = member.args.map {|ty| absolute_type(ty, namespace: namespace) }
+
+                InvalidTypeApplicationError.check!(
+                  type_name: absolute_name,
+                  args: absolute_args,
+                  params: interface_definition.type_params_decl,
+                  location: member.location
+                )
+
+                sub = Substitution.build(interface_definition.type_params, absolute_args)
+                interface_definition.methods.each do |name, method|
+                  method_types = method.method_types.map do |method_type|
+                    method_type.sub(sub).map_type do |type|
+                      absolute_type(type, namespace: namespace)
+                    end
+                  end
+
+                  DuplicatedMethodDefinitionError.check!(
+                    decl: decl,
+                    methods: definition.methods,
+                    name: name,
+                    location: member.location
+                  )
+
+                  definition.methods[name] = Definition::Method.new(
+                    super_method: nil,
+                    method_types: method_types,
+                    defined_in: method.defined_in,
+                    implemented_in: decl,
+                    accessibility: method.accessibility,
+                    attributes: method.attributes,
+                    annotations: method.annotations,
+                    comment: member.comment
+                  )
+                end
+              end
+            when AST::Members::ClassInstanceVariable
+              definition.instance_variables[member.name] = Definition::Variable.new(
+                type: absolute_type(member.type, namespace: namespace),
+                parent_variable: nil,
+                declared_in: decl
+              )
+            when AST::Members::ClassVariable
+              definition.class_variables[member.name] = Definition::Variable.new(
+                type: absolute_type(member.type, namespace: namespace),
+                parent_variable: nil,
+                declared_in: decl
+              )
+            end
+          end
+
+          alias_members.each do |member|
+            UnknownMethodAliasError.check!(
+              methods: definition.methods,
+              original_name: member.old_name,
+              aliased_name: member.new_name,
+              location: member.location
+            )
+
+            DuplicatedMethodDefinitionError.check!(
+              decl: decl,
+              methods: definition.methods,
+              name: member.new_name,
+              location: member.location
+            )
+
+            # FIXME: may cause a problem if #old_name has super type
+            definition.methods[member.new_name] = definition.methods[member.old_name]
+          end
+        end
+      end
+
+      def merge_definitions(pairs, decl:, self_type:, ancestors:)
+        Definition.new(declaration: decl, self_type: self_type, ancestors: ancestors).tap do |definition|
+          pairs.reverse_each do |(ancestor, current_definition)|
+            sub = case ancestor
+                  when Definition::Ancestor::Instance, Definition::Ancestor::ExtensionInstance
+                    Substitution.build(current_definition.type_params, ancestor.args)
+                  when Definition::Ancestor::Singleton, Definition::Ancestor::ExtensionSingleton
+                    Substitution.build([], [])
+                  end
+            namespace = current_definition.name.absolute!.to_namespace
+
+            current_definition.methods.each do |name, method|
+              merge_method definition.methods, name, method, sub, namespace
+            end
+
+            current_definition.instance_variables.each do |name, variable|
+              merge_variable definition.instance_variables, name, variable
+            end
+
+            current_definition.class_variables.each do |name, variable|
+              merge_variable definition.class_variables, name, variable
+            end
+          end
+        end
+      end
+
+      def merge_variable(variables, name, variable)
+        super_variable = variables[name]
+
+        variables[name] = Definition::Variable.new(
+          parent_variable: super_variable,
+          type: variable.type,
+          declared_in: variable.declared_in
+        )
+      end
+
+      def merge_method(methods, name, method, sub, namespace)
+        super_method = methods[name]
+
+        methods[name] = Definition::Method.new(
+          method_types: method.method_types.flat_map do |method_type|
+            case method_type
+            when MethodType
+              [absolute_type(method_type.sub(sub), namespace: namespace)]
+            when :super
+              super_method.method_types
+            end
+          end,
+          super_method: super_method,
+          defined_in: method.defined_in,
+          implemented_in: method.implemented_in,
+          accessibility: method.accessibility,
+          attributes: method.attributes,
+          annotations: method.annotations,
+          comment: method.comment
+        )
+      end
+
+      def try_cache(type_name, cache:)
+        cached = cache[type_name]
+
+        case cached
+        when Definition
+          cached
+        when false
+          raise
+        when nil
+          cache[type_name] = false
+          begin
+            cache[type_name] = yield
+          rescue => ex
+            cache[type_name] = nil
+            raise ex
+          end
+        end
+      end
+
+      def build_interface(type_name, declaration)
+        self_type = Types::Interface.new(
+          name: type_name,
+          args: declaration.type_params.each.map {|p| Types::Variable.new(name: p.name, location: nil) },
+          location: nil
+        )
+
+        namespace = type_name.to_namespace
+
+        Definition.new(declaration: declaration, self_type: self_type, ancestors: []).tap do |definition|
+          alias_members = []
+
+          declaration.members.each do |member|
+            case member
+            when AST::Members::Include
+              mixin_name = env.absolute_interface_name(member.name, namespace: namespace) || member.name.absolute!
+              mixin = build_one_instance(mixin_name)
+
+              args = member.args.map {|type| absolute_type(type, namespace: namespace) }
+              type_params = mixin.declaration.type_params
+
+              InvalidTypeApplicationError.check!(
+                type_name: type_name,
+                args: args,
+                params: type_params,
+                location: member.location
+              )
+
+              sub = Substitution.build(type_params.each.map(&:name), args)
+              mixin.methods.each do |name, method|
+                definition.methods[name] = method.sub(sub)
+              end
+            end
+          end
+
+          declaration.members.each do |member|
+            case member
+            when AST::Members::MethodDefinition
+              DuplicatedMethodDefinitionError.check!(
+                decl: declaration,
+                methods: definition.methods,
+                name: member.name,
+                location: member.location
+              )
+
+              method = Definition::Method.new(
+                super_method: nil,
+                method_types: member.types.map do |method_type|
+                  method_type.map_type {|ty| absolute_type(ty, namespace: namespace) }
+                end,
+                defined_in: declaration,
+                implemented_in: nil,
+                accessibility: :public,
+                attributes: member.attributes,
+                annotations: member.annotations,
+                comment: member.comment
+              )
+              definition.methods[member.name] = method
+            when AST::Members::Alias
+              alias_members << member
+            end
+          end
+
+          alias_members.each do |member|
+            UnknownMethodAliasError.check!(
+              methods: definition.methods,
+              original_name: member.old_name,
+              aliased_name: member.new_name,
+              location: member.location
+            )
+
+            DuplicatedMethodDefinitionError.check!(
+              decl: declaration,
+              methods: definition.methods,
+              name: member.new_name,
+              location: member.location
+            )
+
+            # FIXME: may cause a problem if #old_name has super type
+            definition.methods[member.new_name] = definition.methods[member.old_name]
+          end
+        end
+      end
+
+      def absolute_type(type, namespace:)
+        env.absolute_type(type, namespace: namespace) do |type|
+          NoTypeFoundError.check!(type.name.absolute!, env: env, location: type.location)
+        end
+      end
+
+      def absolute_type_name(type_name, namespace:, location:)
+        env.absolute_type_name(type_name, namespace: namespace) do |type_name|
+          NoTypeFoundError.check!(type_name.absolute!, env: env, location: location)
+        end
+      end
+
+      def expand_alias(type_name)
+        absolute_type(env.find_alias(type_name).type, namespace: type_name.namespace)
+      end
+    end
+  end
+end