rbs 0.5.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a5318ae7911a3e7e4e1bed761e0c7b8d1fc248e698b0d53f8a39d388da5617f0
-  data.tar.gz: d90f20d41372bcc852f49b844aa6b6b5367d9d88ec686a13ab00841f1cf1e2ed
+  metadata.gz: '094182e5d2602ec5ba9244068f67f854dfd5aa9c804fe48f2e943934da3e806b'
+  data.tar.gz: bbd2a02e2c79a092f3e3555337aebdb557301fd2dd712bc46bcfaaa3ae4f3ed5
 SHA512:
-  metadata.gz: 702ae082267eb6a087e19c5a37a83aaaeea0f76e83eba7cc984a15cca869745d1b934231bf6910dbbba972a06301948eca740aa2a8fc49c378487a030befe909
-  data.tar.gz: 8f467c52d50c25886965e1762f7c52f246cb90fa313c7d0a9400051f32c7f3603ada0142cf90ebfad4b56ccbaf57bacd5d1467cb8daf20247254c90937b9c599
+  metadata.gz: 8de689c6af71a94ef511cd5efc9b64d1277f99256e759ec58ad4185505831e3ca041a8555f454ea6700713a4f03a88caeed2104009b8915b9acf5c8b4e5ba53b
+  data.tar.gz: dec9ab30d0d1261897103b71c7203d3857c2cd4150ef145f3b8f3d005b7ba3f9daa947033a1db37c7f7aaf7530725f9129707d29def747fe9334a75acbcc9a16

data/CHANGELOG.md

@@ -2,6 +2,39 @@
 
 ## master
 
+## 0.9.1 (2020-08-04)
+
+* Ensure using Module#name [#354](https://github.com/ruby/rbs/pull/354)
+* Fix runtime test setup [#353](https://github.com/ruby/rbs/pull/353)
+
+## 0.9.0 (2020-08-03)
+
+* Fix signature validation [#351](https://github.com/ruby/rbs/pull/351), [#352](https://github.com/ruby/rbs/pull/352)
+* Parsing performance improvement [#350](https://github.com/ruby/rbs/pull/350)
+
+## 0.8.0 (2020-08-01)
+
+* Signature updates for `Enumerator` and `PTY`
+* Fix prototype rb/rbi error handling [#349](https://github.com/ruby/rbs/pull/349)
+* Runtime test improvements [#344](https://github.com/ruby/rbs/pull/344), [#343](https://github.com/ruby/rbs/pull/343)
+* Add `...` syntax [#342](https://github.com/ruby/rbs/pull/342)
+
+## 0.7.0 (2020-07-20)
+
+* Add `DefinitionBuilder#one_instance_ancestors` and `DefinitionBuilder#one_singleton_ancestors` [#341](https://github.com/ruby/rbs/pull/341)
+* Bug fix in ConstantTable [#340](https://github.com/ruby/rbs/pull/340)
+* Make `rbs validate` faster [#338](https://github.com/ruby/rbs/pull/338)
+* Dedup methods generated by `rbs prototype rb` [#334](https://github.com/ruby/rbs/pull/334)
+
+## 0.6.0 (2020-07-12)
+
+* Signature update for `Logger`.
+* Clean `Environment#inspect`. [#331](https://github.com/ruby/rbs/pull/331)
+* Module self type syntax update. [#329](https://github.com/ruby/rbs/pull/329)
+* Better validation. [#328](https://github.com/ruby/rbs/pull/328)
+* Parser performance improvement. [#327](https://github.com/ruby/rbs/pull/327)
+* Runtime type checking performance improvements with sampling [#323](https://github.com/ruby/rbs/pull/323)
+
 ## 0.5.0 (2020-07-04)
 
 * Signature updates for `Mutex_m`, `IO`, and `Enumerable`.

data/Gemfile

@@ -13,6 +13,8 @@ gem "minitest-reporters"
 gem "json"
 gem "json-schema"
 gem 'stackprof'
+gem "goodcheck"
 
 # Test gems
 gem "rbs-amber", path: "test/assets/test-gem"
+

data/Rakefile

@@ -78,11 +78,10 @@ namespace :generate do
       def call
         ERB.new(<<~ERB, trim_mode: "-").result(binding)
           require_relative "test_helper"
-          require 'rbs/test/test_helper'
 
           <%- unless class_methods.empty? -%>
           class <%= klass %>SingletonTest < Minitest::Test
-            include RBS::Test::TypeAssertions
+            include TypeAssertions
 
             # library "pathname", "set", "securerandom"     # Declare library signatures to load
             testing "singleton(::<%= klass %>)"
@@ -100,7 +99,7 @@ namespace :generate do
 
           <%- unless instance_methods.empty? -%>
           class <%= klass %>Test < Minitest::Test
-            include RBS::Test::TypeAssertions
+            include TypeAssertions
 
             # library "pathname", "set", "securerandom"     # Declare library signatures to load
             testing "::<%= klass %>"

data/docs/stdlib.md

@@ -120,7 +120,6 @@ The test scripts would look like the following:
 ```rb
 class StringTest < StdlibTest
   target String
-  using hook.refinement
 
   def test_gsub
     s = "string"
@@ -136,7 +135,6 @@ end
 
 You need two method calls, `target` and `using`.
 `target` method call tells which class is the subject of the class.
-`using hook.refinement` installs a special instrumentation for stdlib, based on refinements.
 And you write the sample programs which calls all of the patterns of overloads.
 
 Note that the instrumentation is based on refinements and you need to write all method calls in the unit class definitions.

data/docs/syntax.md

@@ -166,7 +166,7 @@ end
 
 ### Proc type
 
-Proc type denots type of procedures, `Proc` instances.
+Proc type denotes type of procedures, `Proc` instances.
 
 ```
 ^(Integer) -> String                  # A procedure with an `Integer` parameter and returns `String`
@@ -348,7 +348,7 @@ attr_reader id: Integer
 # @id: Integer
 # def id: () -> Integer
 
-# Defines `name=` method and `raw_name` instance variable.
+# Defines `name=` method and `@raw_name` instance variable.
 attr_writer name (@raw_name) : String
 # @raw_name: String
 # def name=: (String) -> String
@@ -408,7 +408,10 @@ _class-decl_ ::= `class` _class-name_ _module-type-parameters_ _members_ `end`
                | `class` _class-name_ _module-type-parameters_ `<` _class-name_ _type-arguments_ _members_ `end`
 
 _module-decl_ ::= `module` _module-name_ _module-type-parameters_ _members_ `end`
-                | `module` _module-name_ _module-type-parameters_ `:` _class-name_ _type-arguments_ _members_ `end`
+                | `module` _module-name_ _module-type-parameters_ `:` _module-self-types_ _members_ `end`
+
+_module-self-types_ ::= _class-name_ _type-arguments_ `,` _module-self-types_            (Class instance)
+                      | _interface-name_ _type-arguments_ `,` _module-self-types_        (Interface)
 
 _interface-decl_ ::= `interface` _interface-name_ _module-type-parameters_ _interface-members_ `end`
 

data/goodcheck.yml

@@ -0,0 +1,65 @@
+rules:
+  - id: rbs.no_mark
+    pattern: 💪👽🚨
+    message: Do you forget to delete `arglists` section?
+    glob:
+      - "stdlib/**/*.rbs"
+    fail:
+      - |
+        # arglists 💪👽🚨 << Delete this section   
+        #    File.absolute_path?(file_name)  ->  true or false    
+        #
+
+  - id: rbs.no_arg
+    pattern: 
+      regexp: arg\d+
+    message: |
+      Stop using parameter names like `arg0` or `arg1`
+
+      The parameter names like `arg0` or `arg1` is not informative enough.
+      Try finding good parameter names from documents or arglists.
+      If you cannot find a good name, just delete the name of the parameters.
+    justification:
+      - Documents (comments) may contain that pattern.
+    glob:
+      - "stdlib/**/*.rbs"
+    fail: 
+      - "def `send`: (String | Symbol arg0, *untyped arg1) -> untyped"
+    pass:
+      - "def `send`: (String | Symbol, *untyped) -> untyped"
+
+  - id: deprecate_stdlib_test
+    pattern:
+      token: < StdlibTest
+    message: |
+      StdlibTest is deprecated
+
+      We recommend writing tests based on `TypeAssertions` and `#assert_send_type`.
+    justification:
+      - When you are updating existing tests.
+      - When you are writing tests for callback, which cannot be done with `#assert_send_type`.
+    glob:
+      - "test/stdlib/**/*_test.rb"
+    fail:
+      - |
+        class IntegerTest < StdlibTest
+          target Integer
+
+          def test_plus
+            1 + 2
+          end
+        end
+    pass:
+      - |
+        class IntegerTest < Minitest::Test
+          include TypeAssertions
+
+          testing "Integer"
+
+          def test_plus
+            assert_send_type "(::Integer) -> ::Integer",
+                             1, :+, 2
+          end
+        end
+
+

data/lib/rbs.rb

@@ -36,6 +36,7 @@ require "rbs/type_name_resolver"
 require "rbs/environment_walker"
 require "rbs/vendorer"
 require "rbs/validator"
+require "rbs/factory"
 
 begin
   require "rbs/parser"

data/lib/rbs/ast/comment.rb

@@ -22,6 +22,12 @@ module RBS
       def to_json(*a)
         { string: string, location: location }.to_json(*a)
       end
+
+      def concat(string:, location:)  
+        @string.concat string
+        @location.concat location
+        self
+      end
     end
   end
 end

data/lib/rbs/ast/declarations.rb

@@ -204,6 +204,44 @@ module RBS
       end
 
       class Module < Base
+        class Self
+          attr_reader :name
+          attr_reader :args
+          attr_reader :location
+
+          def initialize(name:, args:, location:)
+            @name = name
+            @args = args
+            @location = location
+          end
+
+          def ==(other)
+            other.is_a?(Self) && other.name == name && other.args == args
+          end
+
+          alias eql? ==
+
+          def hash
+            self.class.hash ^ name.hash ^ args.hash ^ location.hash
+          end
+
+          def to_json(*a)
+            {
+              name: name,
+              args: args,
+              location: location
+            }.to_json(*a)
+          end
+
+          def to_s
+            if args.empty?
+              name.to_s
+            else
+              "#{name}[#{args.join(", ")}]"
+            end
+          end
+        end
+
         include NestedDeclarationHelper
         include MixinHelper
 
@@ -212,13 +250,13 @@ module RBS
         attr_reader :members
         attr_reader :location
         attr_reader :annotations
-        attr_reader :self_type
+        attr_reader :self_types
         attr_reader :comment
 
-        def initialize(name:, type_params:, members:, self_type:, annotations:, location:, comment:)
+        def initialize(name:, type_params:, members:, self_types:, annotations:, location:, comment:)
           @name = name
           @type_params = type_params
-          @self_type = self_type
+          @self_types = self_types
           @members = members
           @annotations = annotations
           @location = location
@@ -229,14 +267,14 @@ module RBS
           other.is_a?(Module) &&
             other.name == name &&
             other.type_params == type_params &&
-            other.self_type == self_type &&
+            other.self_types == self_types &&
             other.members == members
         end
 
         alias eql? ==
 
         def hash
-          self.class.hash ^ name.hash ^ type_params.hash ^ self_type.hash ^ members.hash
+          self.class.hash ^ name.hash ^ type_params.hash ^ self_types.hash ^ members.hash
         end
 
         def to_json(*a)
@@ -245,7 +283,7 @@ module RBS
             name: name,
             type_params: type_params,
             members: members,
-            self_type: self_type,
+            self_types: self_types,
             annotations: annotations,
             location: location,
             comment: comment

data/lib/rbs/cli.rb

@@ -66,6 +66,10 @@ module RBS
       opts
     end
 
+    def has_parser?
+      defined?(RubyVM::AbstractSyntaxTree)
+    end
+
     def run(args)
       options = LibraryOptions.new
 
@@ -409,6 +413,7 @@ EOU
       env.constant_decls.each do |name, const|
         stdout.puts "Validating constant: `#{name}`..."
         validator.validate_type const.decl.type, context: const.context
+        builder.ensure_namespace!(name.namespace, location: const.decl.location)
       end
 
       env.global_decls.each do |name, global|
@@ -418,7 +423,9 @@ EOU
 
       env.alias_decls.each do |name, decl|
         stdout.puts "Validating alias: `#{name}`..."
-        validator.validate_type decl.decl.type, context: decl.context
+        builder.expand_alias(name).tap do |type|
+          validator.validate_type type, context: [Namespace.root]
+        end
       end
     end
 
@@ -599,12 +606,18 @@ EOU
     end
 
     def run_prototype_file(format, args)
+      availability = unless has_parser?
+                       "\n** This command does not work on this interpreter (#{RUBY_ENGINE}) **\n"
+                     end
+
       opts = OptionParser.new
       opts.banner = <<EOU
 Usage: rbs prototype #{format} [options...] [files...]
-
+#{availability}
 Generate RBS prototype from source code.
-It parses specified Ruby code and and generates RBS prototypes. 
+It parses specified Ruby code and and generates RBS prototypes.
+
+It only works on MRI because it parses Ruby code with `RubyVM::AbstractSyntaxTree`.
 
 Examples:
 
@@ -613,6 +626,11 @@ Examples:
 EOU
       opts.parse!(args)
 
+      unless has_parser?
+        stdout.puts "Not supported on this interpreter (#{RUBY_ENGINE})."
+        exit 1
+      end
+
       if args.empty?
         stdout.puts opts
         return nil

data/lib/rbs/constant_table.rb

@@ -152,7 +152,7 @@ module RBS
         constant_scopes_module name, scopes: scopes
 
       else
-        raise "Unexpected declaration: #{name} (#{decl.class})"
+        raise "Unexpected declaration: #{name} (#{entry.class})"
       end
 
       scopes

data/lib/rbs/definition_builder.rb

@@ -13,6 +13,77 @@ module RBS
     attr_reader :instance_ancestors_cache
     attr_reader :singleton_ancestor_cache
 
+    attr_reader :one_instance_ancestors_cache
+    attr_reader :one_singleton_ancestors_cache
+
+    class OneAncestors
+      attr_reader :type_name
+      attr_reader :params
+      attr_reader :super_class
+      attr_reader :self_types
+      attr_reader :included_modules
+      attr_reader :prepended_modules
+      attr_reader :extended_modules
+
+      def initialize(type_name:, params:, super_class:, self_types:, included_modules:, prepended_modules:, extended_modules:)
+        @type_name = type_name
+        @params = params
+        @super_class = super_class
+        @self_types = self_types
+        @included_modules = included_modules
+        @prepended_modules = prepended_modules
+        @extended_modules = extended_modules
+      end
+
+      def each_ancestor(&block)
+        if block_given?
+          yield super_class if super_class
+          self_types&.each(&block)
+          included_modules&.each(&block)
+          prepended_modules&.each(&block)
+          extended_modules&.each(&block)
+        else
+          enum_for :each_ancestor
+        end
+      end
+
+      def self.class_instance(type_name:, params:, super_class:)
+        new(
+          type_name: type_name,
+          params: params,
+          super_class: super_class,
+          self_types: nil,
+          included_modules: [],
+          prepended_modules: [],
+          extended_modules: nil
+        )
+      end
+
+      def self.singleton(type_name:, super_class:)
+        new(
+          type_name: type_name,
+          params: nil,
+          super_class: super_class,
+          self_types: nil,
+          included_modules: nil,
+          prepended_modules: nil,
+          extended_modules: []
+        )
+      end
+
+      def self.module_instance(type_name:, params:)
+        new(
+          type_name: type_name,
+          params: params,
+          self_types: [],
+          included_modules: [],
+          prepended_modules: [],
+          super_class: nil,
+          extended_modules: nil
+        )
+      end
+    end
+
     def initialize(env:)
       @env = env
       @type_name_resolver = TypeNameResolver.from_env(env)
@@ -26,6 +97,9 @@ module RBS
 
       @instance_ancestors_cache = {}
       @singleton_ancestor_cache = {}
+
+      @one_instance_ancestors_cache = {}
+      @one_singleton_ancestors_cache = {}
     end
 
     def validate_super_class!(type_name, entry)
@@ -45,30 +119,19 @@ module RBS
       raise SuperclassMismatchError.new(name: type_name, super_classes: super_types, entry: entry)
     end
 
-    def instance_ancestors(type_name, building_ancestors: [])
-      as = instance_ancestors_cache[type_name] and return as
+    def one_instance_ancestors(type_name)
+      as = one_instance_ancestors_cache[type_name] and return as
 
-      entry = env.class_decls[type_name]
+      entry = env.class_decls[type_name] or raise "Unknown name for one_instance_ancestors: #{type_name}"
       params = entry.type_params.each.map(&:name)
-      args = Types::Variable.build(params)
-      self_ancestor = Definition::Ancestor::Instance.new(name: type_name, args: args)
-
-      RecursiveAncestorError.check!(self_ancestor,
-                                    ancestors: building_ancestors,
-                                    location: entry.primary.decl.location)
-      building_ancestors.push self_ancestor
-
-      ancestors = []
 
       case entry
       when Environment::ClassEntry
         validate_super_class!(type_name, entry)
+        primary = entry.primary
+        super_class = primary.decl.super_class
 
-        # Super class comes last
-        if self_ancestor.name != BuiltinNames::BasicObject.name
-          primary = entry.primary
-          super_class = primary.decl.super_class
-
+        if type_name != BuiltinNames::BasicObject.name
           if super_class
             super_name = super_class.name
             super_args = super_class.args
@@ -77,91 +140,88 @@ module RBS
             super_args = []
           end
 
-          super_ancestors = instance_ancestors(super_name, building_ancestors: building_ancestors)
-          ancestors.unshift(*super_ancestors.apply(super_args, location: primary.decl.location))
-        end
-
-        build_ancestors_mixin_self(self_ancestor, entry, ancestors: ancestors, building_ancestors: building_ancestors)
+          NoSuperclassFoundError.check!(super_name, env: env, location: primary.decl.location)
 
+          ancestors = OneAncestors.class_instance(
+            type_name: type_name,
+            params: params,
+            super_class: Definition::Ancestor::Instance.new(name: super_name, args: super_args)
+          )
+        else
+          ancestors = OneAncestors.class_instance(
+            type_name: type_name,
+            params: params,
+            super_class: nil
+          )
+        end
       when Environment::ModuleEntry
-        build_ancestors_mixin_self(self_ancestor, entry, ancestors: ancestors, building_ancestors: building_ancestors)
+        ancestors = OneAncestors.module_instance(type_name: type_name, params: params)
 
+        entry.self_types.each do |module_self|
+          NoSelfTypeFoundError.check!(module_self, env: env)
+          ancestors.self_types.push Definition::Ancestor::Instance.new(name: module_self.name, args: module_self.args)
+        end
+      else
+        raise "Unexpected entry for: #{type_name}"
       end
 
-      building_ancestors.pop
+      mixin_ancestors(entry,
+                      included_modules: ancestors.included_modules,
+                      prepended_modules: ancestors.prepended_modules,
+                      extended_modules: nil)
 
-      instance_ancestors_cache[type_name] = Definition::InstanceAncestors.new(
-        type_name: type_name,
-        params: params,
-        ancestors: ancestors
-      )
+      one_instance_ancestors_cache[type_name] = ancestors
     end
 
-    def singleton_ancestors(type_name, building_ancestors: [])
-      as = singleton_ancestor_cache[type_name] and return as
+    def one_singleton_ancestors(type_name)
+      as = one_singleton_ancestors_cache[type_name] and return as
 
-      entry = env.class_decls[type_name]
-      self_ancestor = Definition::Ancestor::Singleton.new(name: type_name)
-
-      RecursiveAncestorError.check!(self_ancestor,
-                                    ancestors: building_ancestors,
-                                    location: entry.primary.decl.location)
-      building_ancestors.push self_ancestor
-
-      ancestors = []
+      entry = env.class_decls[type_name] or raise "Unknown name for one_singleton_ancestors: #{type_name}"
 
       case entry
       when Environment::ClassEntry
-        # Super class comes last
-        if self_ancestor.name != BuiltinNames::BasicObject.name
-          primary = entry.primary
-          super_class = primary.decl.super_class
+        validate_super_class!(type_name, entry)
+        primary = entry.primary
+        super_class = primary.decl.super_class
 
+        if type_name != BuiltinNames::BasicObject.name
           if super_class
             super_name = super_class.name
           else
             super_name = BuiltinNames::Object.name
           end
 
-          super_ancestors = singleton_ancestors(super_name, building_ancestors: building_ancestors)
-          ancestors.unshift(*super_ancestors.ancestors)
+          NoSuperclassFoundError.check!(super_name, env: env, location: primary.decl.location)
+
+          ancestors = OneAncestors.singleton(
+            type_name: type_name,
+            super_class: Definition::Ancestor::Singleton.new(name: super_name)
+          )
         else
-          as = instance_ancestors(BuiltinNames::Class.name, building_ancestors: building_ancestors)
-          ancestors.unshift(*as.apply([], location: entry.primary.decl.location))
+          ancestors = OneAncestors.singleton(
+            type_name: type_name,
+            super_class: Definition::Ancestor::Instance.new(name: BuiltinNames::Class.name, args: [])
+          )
         end
-
       when Environment::ModuleEntry
-        as = instance_ancestors(BuiltinNames::Module.name, building_ancestors: building_ancestors)
-        ancestors.unshift(*as.apply([], location: entry.primary.decl.location))
-      end
-
-      # Extend comes next
-      entry.decls.each do |d|
-        decl = d.decl
+        ancestors = OneAncestors.singleton(
+          type_name: type_name,
+          super_class: Definition::Ancestor::Instance.new(name: BuiltinNames::Module.name, args: [])
+        )
 
-        decl.each_mixin do |member|
-          case member
-          when AST::Members::Extend
-            if member.name.class?
-              module_ancestors = instance_ancestors(member.name, building_ancestors: building_ancestors)
-              ancestors.unshift(*module_ancestors.apply(member.args, location: member.location))
-            end
-          end
-        end
+      else
+        raise "Unexpected entry for: #{type_name}"
       end
 
-      ancestors.unshift self_ancestor
-
-      building_ancestors.pop
+      mixin_ancestors(entry,
+                      included_modules: nil,
+                      prepended_modules: nil,
+                      extended_modules: ancestors.extended_modules)
 
-      singleton_ancestor_cache[type_name] = Definition::SingletonAncestors.new(
-        type_name: type_name,
-        ancestors: ancestors
-      )
+      one_singleton_ancestors_cache[type_name] = ancestors
     end
 
-    def build_ancestors_mixin_self(self_ancestor, entry, ancestors:, building_ancestors:)
-      # Include comes next
+    def mixin_ancestors(entry, included_modules:, extended_modules:, prepended_modules:)
       entry.decls.each do |d|
         decl = d.decl
 
@@ -173,38 +233,143 @@ module RBS
         decl.each_mixin do |member|
           case member
           when AST::Members::Include
-            if member.name.class?
+            if included_modules
+              NoMixinFoundError.check!(member.name, env: env, member: member)
+
+              module_name = member.name
+              module_args = member.args.map {|type| type.sub(align_params) }
+
+              included_modules << Definition::Ancestor::Instance.new(name: module_name, args: module_args)
+            end
+
+          when AST::Members::Prepend
+            if prepended_modules
+              NoMixinFoundError.check!(member.name, env: env, member: member)
+
               module_name = member.name
               module_args = member.args.map {|type| type.sub(align_params) }
 
-              module_ancestors = instance_ancestors(module_name, building_ancestors: building_ancestors)
-              ancestors.unshift(*module_ancestors.apply(module_args, location: member.location))
+              prepended_modules << Definition::Ancestor::Instance.new(name: module_name, args: module_args)
+            end
+
+          when AST::Members::Extend
+            if extended_modules
+              NoMixinFoundError.check!(member.name, env: env, member: member)
+
+              module_name = member.name
+              module_args = member.args
+
+              extended_modules << Definition::Ancestor::Instance.new(name: module_name, args: module_args)
             end
           end
         end
       end
+    end
+
+    def instance_ancestors(type_name, building_ancestors: [])
+      as = instance_ancestors_cache[type_name] and return as
+
+      entry = env.class_decls[type_name] or raise "Unknown name for instance_ancestors: #{type_name}"
+      params = entry.type_params.each.map(&:name)
+      args = Types::Variable.build(params)
+      self_ancestor = Definition::Ancestor::Instance.new(name: type_name, args: args)
+
+      RecursiveAncestorError.check!(self_ancestor,
+                                    ancestors: building_ancestors,
+                                    location: entry.primary.decl.location)
+      building_ancestors.push self_ancestor
+
+      one_ancestors = one_instance_ancestors(type_name)
+
+      ancestors = []
+
+      case entry
+      when Environment::ClassEntry
+        if one_ancestors.super_class
+          super_name = one_ancestors.super_class.name
+          super_args = one_ancestors.super_class.args
+
+          super_ancestors = instance_ancestors(super_name, building_ancestors: building_ancestors)
+          ancestors.unshift(*super_ancestors.apply(super_args, location: entry.primary.decl.location))
+        end
+      end
+
+      one_ancestors.included_modules.each do |mod|
+        if mod.name.class?
+          name = mod.name
+          args = mod.args
+          mod_ancestors = instance_ancestors(name, building_ancestors: building_ancestors)
+          ancestors.unshift(*mod_ancestors.apply(args, location: entry.primary.decl.location))
+        end
+      end
 
-      # Self
       ancestors.unshift(self_ancestor)
 
-      # Prepends
-      entry.decls.each do |d|
-        decl = d.decl
+      one_ancestors.prepended_modules.each do |mod|
+        if mod.name.class?
+          name = mod.name
+          args = mod.args
+          mod_ancestors = instance_ancestors(name, building_ancestors: building_ancestors)
+          ancestors.unshift(*mod_ancestors.apply(args, location: entry.primary.decl.location))
+        end
+      end
 
-        align_params = Substitution.build(decl.type_params.each.map(&:name),
-                                          Types::Variable.build(entry.type_params.each.map(&:name)))
+      building_ancestors.pop
 
-        decl.each_mixin do |member|
-          case member
-          when AST::Members::Prepend
-            module_name = member.name
-            module_args = member.args.map {|type| type.sub(align_params) }
+      instance_ancestors_cache[type_name] = Definition::InstanceAncestors.new(
+        type_name: type_name,
+        params: params,
+        ancestors: ancestors
+      )
+    end
 
-            module_ancestors = instance_ancestors(module_name, building_ancestors: building_ancestors)
-            ancestors.unshift(*module_ancestors.apply(module_args))
-          end
+    def singleton_ancestors(type_name, building_ancestors: [])
+      as = singleton_ancestor_cache[type_name] and return as
+
+      entry = env.class_decls[type_name] or raise "Unknown name for singleton_ancestors: #{type_name}"
+      self_ancestor = Definition::Ancestor::Singleton.new(name: type_name)
+
+      RecursiveAncestorError.check!(self_ancestor,
+                                    ancestors: building_ancestors,
+                                    location: entry.primary.decl.location)
+      building_ancestors.push self_ancestor
+
+      one_ancestors = one_singleton_ancestors(type_name)
+
+      ancestors = []
+
+      case one_ancestors.super_class
+      when Definition::Ancestor::Instance
+        super_name = one_ancestors.super_class.name
+        super_args = one_ancestors.super_class.args
+
+        super_ancestors = instance_ancestors(super_name, building_ancestors: building_ancestors)
+        ancestors.unshift(*super_ancestors.apply(super_args, location: entry.primary.decl.location))
+
+      when Definition::Ancestor::Singleton
+        super_name = one_ancestors.super_class.name
+
+        super_ancestors = singleton_ancestors(super_name, building_ancestors: [])
+        ancestors.unshift(*super_ancestors.ancestors)
+      end
+
+      one_ancestors.extended_modules.each do |mod|
+        if mod.name.class?
+          name = mod.name
+          args = mod.args
+          mod_ancestors = instance_ancestors(name, building_ancestors: building_ancestors)
+          ancestors.unshift(*mod_ancestors.apply(args, location: entry.primary.decl.location))
         end
       end
+
+      ancestors.unshift(self_ancestor)
+
+      building_ancestors.pop
+
+      singleton_ancestor_cache[type_name] = Definition::SingletonAncestors.new(
+        type_name: type_name,
+        ancestors: ancestors
+      )
     end
 
     def each_member_with_accessibility(members, accessibility: :public)
@@ -220,9 +385,18 @@ module RBS
       end
     end
 
+    def ensure_namespace!(namespace, location:)
+      namespace.ascend do |ns|
+        unless ns.empty?
+          NoTypeFoundError.check!(ns.to_type_name, env: env, location: location)
+        end
+      end
+    end
+
     def build_instance(type_name)
       try_cache type_name, cache: instance_cache do
-        entry = env.class_decls[type_name]
+        entry = env.class_decls[type_name] or raise "Unknown name for build_instance: #{type_name}"
+        ensure_namespace!(type_name.namespace, location: entry.decls[0].decl.location)
 
         case entry
         when Environment::ClassEntry, Environment::ModuleEntry
@@ -243,11 +417,18 @@ module RBS
           end
 
           if entry.is_a?(Environment::ModuleEntry)
-            if self_type_ancestor = module_self_ancestor(type_name, entry)
-              definition_pairs.push [
-                                      self_type_ancestor,
-                                      build_interface(self_type_ancestor.name)
-                                    ]
+            entry.self_types.each do |module_self|
+              ancestor = Definition::Ancestor::Instance.new(name: module_self.name, args: module_self.args)
+              definition_pairs.push(
+                [
+                  ancestor,
+                  if module_self.name.interface?
+                    build_interface(module_self.name)
+                  else
+                    build_instance(module_self.name)
+                  end
+                ]
+              )
             end
           end
 
@@ -259,32 +440,10 @@ module RBS
       end
     end
 
-    def module_self_ancestor(type_name, entry)
-      self_decls = entry.decls.select {|d| d.decl.self_type }
-
-      return if self_decls.empty?
-
-      selfs = self_decls.map do |d|
-        Definition::Ancestor::Instance.new(
-          name: d.decl.self_type.name,
-          args: d.decl.self_type.args
-        )
-      end
-
-      selfs.uniq!
-
-      return selfs[0] if selfs.size == 1
-
-      raise ModuleSelfTypeMismatchError.new(
-        name: type_name,
-        entry: entry,
-        location: self_decls[0].decl.location
-      )
-    end
-
     def build_singleton(type_name)
       try_cache type_name, cache: singleton_cache do
-        entry = env.class_decls[type_name]
+        entry = env.class_decls[type_name] or raise "Unknown name for build_singleton: #{type_name}"
+        ensure_namespace!(type_name.namespace, location: entry.decls[0].decl.location)
 
         case entry
         when Environment::ClassEntry, Environment::ModuleEntry
@@ -350,6 +509,8 @@ module RBS
           when AST::Members::Include, AST::Members::Extend
             if member.name.interface?
               if (kind == :instance && member.is_a?(AST::Members::Include)) || (kind == :singleton && member.is_a?(AST::Members::Extend))
+                NoMixinFoundError.check!(member.name, env: env, member: member)
+
                 interface_name = member.name
                 interface_args = member.args
 
@@ -842,7 +1003,7 @@ module RBS
       methods[name] = Definition::Method.new(
         super_method: super_method,
         accessibility: method.accessibility,
-        defs: method.defs.map {|defn| defn.update(type: defn.type.sub(sub)) }
+        defs: sub.mapping.empty? ? method.defs : method.defs.map {|defn| defn.update(type: defn.type.sub(sub)) }
       )
     end
 
@@ -867,8 +1028,9 @@ module RBS
 
     def build_interface(type_name)
       try_cache(type_name, cache: interface_cache) do
-        entry = env.interface_decls[type_name]
+        entry = env.interface_decls[type_name] or raise "Unknown name for build_interface: #{type_name}"
         declaration = entry.decl
+        ensure_namespace!(type_name.namespace, location: declaration.location)
 
         self_type = Types::Interface.new(
           name: type_name,
@@ -893,6 +1055,8 @@ module RBS
           end
 
           include_members.each do |member|
+            NoMixinFoundError.check!(member.name, env: env, member: member)
+
             mixin = build_interface(member.name)
 
             args = member.args
@@ -957,7 +1121,9 @@ module RBS
     end
 
     def expand_alias(type_name)
-      env.alias_decls[type_name].decl.type
+      entry = env.alias_decls[type_name] or raise "Unknown name for expand_alias: #{type_name}"
+      ensure_namespace!(type_name.namespace, location: entry.decl.location)
+      entry.decl.type
     end
   end
 end