rbs 0.2.0

data/lib/rbs/constant.rb

@@ -0,0 +1,26 @@
+module RBS
+  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

data/lib/rbs/constant_table.rb

@@ -0,0 +1,150 @@
+module RBS
+  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

data/lib/rbs/definition.rb

@@ -0,0 +1,170 @@
+module RBS
+  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

data/lib/rbs/definition_builder.rb

@@ -0,0 +1,919 @@
+module RBS
+  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(RBS::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 = env.find_class(type_name))
+      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