steep 0.5.1 → 0.6.0

data/lib/steep/ast/types/literal.rb

@@ -42,16 +42,18 @@ module Steep
         end
 
         def back_type
-          case value
-          when Integer
-            Name.new_instance(name: "::Integer")
-          when String
-            Name.new_instance(name: "::String")
-          when Symbol
-            Name.new_instance(name: "::Symbol")
-          else
-            raise "Unexpected literal type: #{value.inspect}"
-          end
+          klass = case value
+                  when Integer
+                    Builtin::Integer
+                  when String
+                    Builtin::String
+                  when Symbol
+                    Builtin::Symbol
+                  else
+                    raise "Unexpected literal type: #{value.inspect}"
+                  end
+
+          Name::Instance.new(name: klass.module_name, args: [], location: location)
         end
       end
     end

data/lib/steep/ast/types/name.rb

@@ -1,126 +1,167 @@
 module Steep
   module AST
     module Types
-      class Name
-        attr_reader :location
-        attr_reader :name
-        attr_reader :args
-
-        def initialize(name:, args:, location: nil)
-          @location = location
-          @name = name
-          @args = args
-        end
+      module Name
+        class Base
+          attr_reader :location
+          attr_reader :name
+
+          def initialize(name:, location: nil)
+            @location = location
+            @name = name
+          end
 
-        def ==(other)
-          other.is_a?(Name) &&
-            other.name == name &&
-            other.args == args
-        end
+          def free_variables
+            Set.new
+          end
+
+          def subst(s)
+            self
+          end
 
-        def hash
-          self.class.hash ^ name.hash ^ args.hash
+          def level
+            [0]
+          end
         end
 
-        alias eql? ==
+        class Applying < Base
+          attr_reader :args
 
-        def to_s
-          if args.empty?
-            "#{name}"
-          else
-            "#{name}<#{args.join(", ")}>"
+          def initialize(name:, args:, location: nil)
+            super(name: name, location: location)
+            @args = args
           end
-        end
 
-        def with_location(new_location)
-          self.class.new(name: name, args: args, location: new_location)
-        end
+          def ==(other)
+            other.class == self.class &&
+              other.name == name &&
+              other.args == args
+          end
 
-        def self.new_module(location: nil, name:, args: [])
-          name = ModuleName.parse(name) unless name.is_a?(ModuleName)
-          new(location: location,
-              name: TypeName::Module.new(name: name),
-              args: args)
-        end
+          alias eql? ==
 
-        def self.new_class(location: nil, name:, constructor:, args: [])
-          name = ModuleName.parse(name) unless name.is_a?(ModuleName)
-          new(location: location,
-              name: TypeName::Class.new(name: name, constructor: constructor),
-              args: args)
-        end
+          def hash
+            self.class.hash ^ name.hash ^ args.hash
+          end
 
-        def self.new_instance(location: nil, name:, args: [])
-          name = ModuleName.parse(name) unless name.is_a?(ModuleName)
-          new(location: location,
-              name: TypeName::Instance.new(name: name),
-              args: args)
-        end
+          def to_s
+            if args.empty?
+              "#{name}"
+            else
+              "#{name}<#{args.join(", ")}>"
+            end
+          end
 
-        def self.new_interface(location: nil, name:, args: [])
-          new(location: location, name: TypeName::Interface.new(name: name), args: args)
-        end
+          def with_location(new_location)
+            self.class.new(name: name, args: args, location: new_location)
+          end
 
-        def subst(s)
-          self.class.new(location: location,
-                         name: name,
-                         args: args.map {|a| a.subst(s) })
-        end
+          def subst(s)
+            self.class.new(location: location,
+                           name: name,
+                           args: args.map {|a| a.subst(s) })
+          end
 
-        def instance_type
-          case name
-          when TypeName::Interface, TypeName::Instance
-            self
-          when TypeName::Module, TypeName::Class
-            self.class.new_instance(location: location,
-                                    name: name.name,
-                                    args: args)
-          else
-            raise "Unknown name: #{name.inspect}"
+          def free_variables
+            args.each.with_object(Set.new) do |type, vars|
+              vars.merge(type.free_variables)
+            end
+          end
+
+          include Helper::ChildrenLevel
+
+          def level
+            [0] + level_of_children(args)
           end
         end
 
-        def class_type(constructor:)
-          case name
-          when TypeName::Instance
-            self.class.new_class(location: location,
-                                 name: name.name,
-                                 constructor: constructor,
-                                 args: [])
-          when TypeName::Class
-            self
-          when TypeName::Module, TypeName::Interface
-            raise "Cannot make class type: #{inspect}"
-          else
-            raise "Unknown name: #{name.inspect}"
+        class Class < Base
+          attr_reader :constructor
+
+          def initialize(name:, constructor:, location: nil)
+            raise "Name should be a module name: #{name.inspect}" unless name.is_a?(Names::Module)
+            super(name: name, location: location)
+            @constructor = constructor
+          end
+
+          def ==(other)
+            other.class == self.class &&
+              other.name == name &&
+              other.constructor == constructor
+          end
+
+          alias eql? ==
+
+          def hash
+            self.class.hash ^ name.hash ^ constructor.hash
+          end
+
+          def to_s
+            k = case constructor
+                when true
+                  " constructor"
+                when false
+                  " noconstructor"
+                when nil
+                  ""
+                end
+            "#{name.to_s}.class#{k}"
+          end
+
+          def with_location(new_location)
+            self.class.new(name: name, constructor: constructor, location: new_location)
+          end
+
+          def to_instance(*args)
+            Instance.new(name: name, args: args)
+          end
+
+          NOTHING = ::Object.new
+
+          def updated(constructor: NOTHING)
+            if NOTHING == constructor
+              constructor = self.constructor
+            end
+
+            self.class.new(name: name, constructor: constructor, location: location)
           end
         end
 
-        def module_type
-          case name
-          when TypeName::Instance,
-            self.class.new_module(location: location,
-                                  name: name.name,
-                                  args: args)
-          when TypeName::Module
-            self
-          when TypeName::Class, TypeName::Interface
-            raise "Cannot make module type: #{inspect}"
-          else
-            raise "Unknown name: #{name.inspect}"
+        class Module < Base
+          def ==(other)
+            other.class == self.class &&
+              other.name == name
+          end
+
+          alias eql? ==
+
+          def hash
+            self.class.hash ^ name.hash
+          end
+
+          def to_s
+            "#{name.to_s}.module"
+          end
+
+          def with_location(new_location)
+            self.class.new(name: name, location: new_location)
           end
         end
 
-        def free_variables
-          self.args.each.with_object(Set.new) do |type, vars|
-            vars.merge(type.free_variables)
+        class Instance < Applying
+          def to_class(constructor:)
+            Class.new(name: name, location: location, constructor: constructor)
+          end
+
+          def to_module
+            Module.new(name: name, location: location)
           end
         end
 
-        include Helper::ChildrenLevel
+        class Interface < Applying
+        end
 
-        def level
-          [0] + level_of_children(args)
+        class Alias < Applying
         end
       end
     end

data/lib/steep/ast/types/nil.rb

@@ -39,7 +39,9 @@ module Steep
         end
 
         def back_type
-          Name.new_instance(name: "::NilClass", location: location)
+          Name::Instance.new(name: Builtin::NilClass.module_name,
+                             args: [],
+                             location: location)
         end
       end
     end

data/lib/steep/ast/types/proc.rb

@@ -71,7 +71,9 @@ module Steep
         end
 
         def back_type
-          Name.new_instance(name: "::Proc", location: location)
+          Name::Instance.new(name: Builtin::Proc.module_name,
+                             args: [],
+                             location: location)
         end
       end
     end

data/lib/steep/drivers/check.rb

@@ -63,11 +63,11 @@ module Steep
         sources.each do |source|
           Steep.logger.tagged source.path do
             Steep.logger.debug "Typechecking..."
-            annotations = source.annotations(block: source.node, builder: check.builder, current_module: nil)
+            annotations = source.annotations(block: source.node, builder: check.builder, current_module: AST::Namespace.root)
 
             pp annotations if verbose
 
-            const_env = TypeInference::ConstantEnv.new(builder: check.builder, current_namespace: nil)
+            const_env = TypeInference::ConstantEnv.new(builder: check.builder, context: nil)
             type_env = TypeInference::TypeEnv.build(annotations: annotations,
                                                     subtyping: check,
                                                     const_env: const_env,
@@ -77,13 +77,13 @@ module Steep
               checker: check,
               annotations: annotations,
               source: source,
-              self_type: AST::Types::Name.new_instance(name: "::Object"),
+              self_type: AST::Builtin::Object.instance_type,
               block_context: nil,
               module_context: TypeConstruction::ModuleContext.new(
                 instance_type: nil,
                 module_type: nil,
                 implement_name: nil,
-                current_namespace: nil,
+                current_namespace: AST::Namespace.root,
                 const_env: const_env
               ),
               method_context: nil,

data/lib/steep/drivers/utils/validator.rb

@@ -21,11 +21,10 @@ module Steep
             case sig
             when AST::Signature::Interface
               yield_self do
-                instance_name = TypeName::Interface.new(name: sig.name)
-                instance_interface = builder.build(instance_name)
+                instance_interface = builder.build_interface(sig.name)
 
                 args = instance_interface.params.map {|var| AST::Types::Var.fresh(var) }
-                instance_type = AST::Types::Name.new_interface(name: sig.name, args: args)
+                instance_type = AST::Types::Name::Interface.new(name: sig.name, args: args)
 
                 instance_interface.instantiate(type: instance_type,
                                                args: args,
@@ -35,16 +34,14 @@ module Steep
 
             when AST::Signature::Module
               yield_self do
-                instance_name = TypeName::Instance.new(name: sig.name)
-                instance_interface = builder.build(instance_name)
+                instance_interface = builder.build_instance(sig.name, with_initialize: true)
                 instance_args = instance_interface.params.map {|var| AST::Types::Var.fresh(var) }
 
-                module_name = TypeName::Module.new(name: sig.name)
-                module_interface = builder.build(module_name)
+                module_interface = builder.build_module(sig.name)
                 module_args = module_interface.params.map {|var| AST::Types::Var.fresh(var) }
 
-                instance_type = AST::Types::Name.new_instance(name: sig.name, args: instance_args)
-                module_type = AST::Types::Name.new_module(name: sig.name, args: module_args)
+                instance_type = AST::Types::Name::Instance.new(name: sig.name, args: instance_args)
+                module_type = AST::Types::Name::Module.new(name: sig.name)
 
                 stdout.puts "👀 Validating instance methods..." if verbose
                 instance_interface.instantiate(type: instance_type,
@@ -61,16 +58,14 @@ module Steep
 
             when AST::Signature::Class
               yield_self do
-                instance_name = TypeName::Instance.new(name: sig.name)
-                instance_interface = builder.build(instance_name)
+                instance_interface = builder.build_instance(sig.name, with_initialize: true)
                 instance_args = instance_interface.params.map {|var| AST::Types::Var.fresh(var) }
 
-                module_name = TypeName::Class.new(name: sig.name, constructor: nil)
-                module_interface = builder.build(module_name)
+                module_interface = builder.build_class(sig.name, constructor: true)
                 module_args = module_interface.params.map {|var| AST::Types::Var.fresh(var) }
 
-                instance_type = AST::Types::Name.new_instance(name: sig.name, args: instance_args)
-                module_type = AST::Types::Name.new_class(name: sig.name, args: module_args, constructor: nil)
+                instance_type = AST::Types::Name::Instance.new(name: sig.name, args: instance_args)
+                module_type = AST::Types::Name::Class.new(name: sig.name, constructor: true)
 
                 stdout.puts "👀 Validating instance methods..." if verbose
                 instance_interface.instantiate(type: instance_type,
@@ -94,7 +89,7 @@ module Steep
               when Interface::Method
                 stdout.puts "  #{s.name}(#{s.type_name}) <: #{t.name}(#{t.type_name})"
               when Interface::MethodType
-                stdout.puts "  #{s.location.source} <: #{t.location.source} (#{s.location.name}:#{s.location.start_line})"
+                stdout.puts "  #{s} <: #{t} (#{s.location&.name||"?"}:#{s.location&.start_line||"?"})"
               else
                 stdout.puts "  #{s} <: #{t}"
               end

data/lib/steep/interface/builder.rb

@@ -15,47 +15,53 @@ module Steep
       end
 
       attr_reader :signatures
-      attr_reader :cache
+      attr_reader :class_cache
+      attr_reader :module_cache
+      attr_reader :instance_cache
+      attr_reader :interface_cache
 
       def initialize(signatures:)
-        @cache = {}
         @signatures = signatures
-      end
-
-      def absolute_type_name(type_name, current:)
-        if current
-          begin
-            case type_name
-            when TypeName::Instance
-              type_name.map_module_name {|name|
-                signatures.find_class_or_module(name, current_module: current).name
-              }
-            when TypeName::Module
-              type_name.map_module_name {|name|
-                signatures.find_module(name, current_module: current).name
-              }
-            when TypeName::Class
-              type_name.map_module_name {|name|
-                signatures.find_class(name, current_module: current).name
-              }
-            else
-              type_name
-            end
-          rescue => exn
-            STDERR.puts "Cannot find absolute type name: #{exn.inspect}"
-            type_name
-          end
-        else
-          type_name.map_module_name(&:absolute!)
-        end
+        @class_cache = {}
+        @module_cache = {}
+        @instance_cache = {}
+        @interface_cache = {}
       end
 
       def absolute_type(type, current:)
         case type
-        when AST::Types::Name
-          AST::Types::Name.new(
-            name: absolute_type_name(type.name, current: current),
-            args: type.args.map {|ty| absolute_type(ty, current: current) },
+        when AST::Types::Name::Instance
+          signature = signatures.find_class_or_module(type.name, current_module: current)
+          AST::Types::Name::Instance.new(
+            name: signature.name,
+            args: type.args.map {|arg| absolute_type(arg, current: current) },
+            location: type.location
+          )
+        when AST::Types::Name::Class
+          signature = signatures.find_class(type.name, current_module: current)
+          AST::Types::Name::Class.new(
+            name: signature.name,
+            constructor: type.constructor,
+            location: type.location
+          )
+        when AST::Types::Name::Module
+          signature = signatures.find_class_or_module(type.name, current_module: current)
+          AST::Types::Name::Module.new(
+            name: signature.name,
+            location: type.location
+          )
+        when AST::Types::Name::Interface
+          signature = signatures.find_interface(type.name, namespace: current)
+          AST::Types::Name::Interface.new(
+            name: signature.name,
+            args: type.args.map {|arg| absolute_type(arg, current: current) },
+            location: type.location
+          )
+        when AST::Types::Name::Alias
+          signature = signatures.find_alias(type.name, namespace: current)
+          AST::Types::Name::Alias.new(
+            name: signature.name,
+            args: type.args.map {|arg| absolute_type(arg, current: current) },
             location: type.location
           )
         when AST::Types::Union
@@ -79,53 +85,72 @@ module Steep
             return_type: absolute_type(type.return_type, current: current),
             location: type.location
           )
+        when AST::Types::Hash
+          AST::Types::Hash.new(
+            elements: type.elements.transform_values {|ty| absolute_type(ty, current: current) },
+            location: type.location
+          )
         else
           type
         end
       end
 
-      def build(type_name, current: nil, with_initialize: false)
-        type_name = absolute_type_name(type_name, current: current)
-        cache_key = [type_name, with_initialize]
-        cached = cache[cache_key]
+      def cache_interface(cache, key:, &block)
+        cached = cache[key]
 
         case cached
         when nil
-          begin
-            cache[cache_key] = type_name
-
-            interface = case type_name
-                        when TypeName::Instance
-                          instance_to_interface(signatures.find_class_or_module(type_name.name), with_initialize: with_initialize)
-                        when TypeName::Module
-                          module_to_interface(signatures.find_module(type_name.name))
-                        when TypeName::Class
-                          class_to_interface(signatures.find_class_or_module(type_name.name),
-                                             constructor: type_name.constructor)
-                        when TypeName::Interface
-                          interface_to_interface(type_name.name,
-                                                 signatures.find_interface(type_name.name))
-                        else
-                          raise "Unexpected type_name: #{type_name.inspect}"
-                        end
-
-            cache[cache_key]= interface
-          rescue RecursiveDefinitionError => exn
-            exn.chain.unshift(type_name)
-            raise
-          end
-        when TypeName::Base
-          raise RecursiveDefinitionError, type_name
+          cache[key] = key
+          cache[key] = yield
+        when key
+          raise RecursiveDefinitionError, key
         else
           cached
         end
+      rescue RecursiveDefinitionError => exn
+        cache.delete key
+        raise exn
+      end
+
+      def assert_absolute_name!(name)
+        raise "Name should be absolute: #{name}" unless name.absolute?
+      end
+
+      def build_class(module_name, constructor:)
+        assert_absolute_name! module_name
+        signature = signatures.find_class(module_name, current_module: AST::Namespace.root)
+        cache_interface(class_cache, key: [signature.name, !!constructor]) do
+          class_to_interface(signature, constructor: constructor)
+        end
+      end
+
+      def build_module(module_name)
+        assert_absolute_name! module_name
+        signature = signatures.find_module(module_name, current_module: AST::Namespace.root)
+        cache_interface(module_cache, key: signature.name) do
+          module_to_interface(signature)
+        end
+      end
+
+      def build_instance(module_name, with_initialize:)
+        assert_absolute_name! module_name
+        signature = signatures.find_class_or_module(module_name, current_module: AST::Namespace.root)
+        cache_interface(instance_cache, key: [signature.name, with_initialize]) do
+          instance_to_interface(signature, with_initialize: with_initialize)
+        end
+      end
+
+      def build_interface(interface_name)
+        signature = signatures.find_interface(interface_name)
+        cache_interface(interface_cache, key: [signature.name]) do
+          interface_to_interface(nil, signature)
+        end
       end
 
-      def merge_mixin(type_name, args, methods:, ivars:, supers:, current:)
-        mixed = block_given? ? yield : build(type_name, current: current)
+      def merge_mixin(interface, args, methods:, ivars:, supers:, current:)
+        supers.push(*interface.supers)
 
-        supers.push(*mixed.supers)
-        instantiated = mixed.instantiate(
+        instantiated = interface.instantiate(
           type: AST::Types::Self.new,
           args: args,
           instance_type: AST::Types::Instance.new,
@@ -143,13 +168,13 @@ module Steep
         merge_ivars ivars, instantiated.ivars
       end
 
-      def add_method(type_name, method, methods:, extra_attributes: [])
+      def add_method(type_name, method, methods:, extra_attributes: [], current:)
         super_method = methods[method.name]
         new_method = Method.new(
           type_name: type_name,
           name: method.name,
           types: method.types.map do |method_type|
-            method_type_to_method_type(method_type, current: type_name.name)
+            method_type_to_method_type(method_type, current: current)
           end,
           super_method: super_method,
           attributes: method.attributes + extra_attributes
@@ -163,12 +188,13 @@ module Steep
       end
 
       def class_to_interface(sig, constructor:)
-        type_name = TypeName::Class.new(name: sig.name, constructor: constructor)
+        module_name = sig.name
+        namespace = module_name.namespace.append(module_name.name)
 
         supers = []
         methods = {
           new: Method.new(
-            type_name: TypeName::Class.new(name: "Builtin", constructor: true),
+            type_name: Names::Module.parse(name: "__Builtin__"),
             name: :new,
             types: [
               MethodType.new(type_params: [],
@@ -179,45 +205,47 @@ module Steep
               )
             ],
             super_method: nil,
-            attributes: []
+            attributes: [:incompatible]
           )
         }
 
-        klass = build(TypeName::Instance.new(name: ModuleName.parse("::Class")))
+        klass = build_instance(AST::Builtin::Class.module_name, with_initialize: false)
         instantiated = klass.instantiate(
           type: AST::Types::Self.new,
-          args: [AST::Types::Instance.new],
+          args: [],
           instance_type: AST::Types::Instance.new,
           module_type: AST::Types::Class.new
         )
         methods.merge!(instantiated.methods)
 
-        unless sig.name == ModuleName.parse("::BasicObject")
-          super_class_name = sig.super_class&.name&.absolute! || ModuleName.parse("::Object")
-          merge_mixin(TypeName::Class.new(name: super_class_name, constructor: constructor),
-                      [],
-                      methods: methods,
-                      ivars: {},
-                      supers: supers,
-                      current: sig.name)
+        unless module_name == AST::Builtin::BasicObject.module_name
+          super_class_name = sig.super_class&.name&.yield_self {|name| signatures.find_class(name, current_module: namespace).name } || AST::Builtin::Object.module_name
+          class_interface = build_class(super_class_name, constructor: constructor)
+          merge_mixin(class_interface, [], methods: methods, ivars: {}, supers: supers, current: namespace)
         end
 
         sig.members.each do |member|
           case member
           when AST::Signature::Members::Include
-            merge_mixin(TypeName::Module.new(name: member.name),
-                        [],
-                        methods: methods,
-                        supers: supers,
-                        ivars: {},
-                        current: sig.name)
+            member_name = signatures.find_module(member.name, current_module: AST::Namespace.root).name
+            build_module(member_name).yield_self do |module_interface|
+              merge_mixin(module_interface,
+                          [],
+                          methods: methods,
+                          supers: supers,
+                          ivars: {},
+                          current: namespace)
+            end
           when AST::Signature::Members::Extend
-            merge_mixin(TypeName::Instance.new(name: member.name),
-                        member.args.map {|type| absolute_type(type, current: sig.name) },
-                        methods: methods,
-                        ivars: {},
-                        supers: supers,
-                        current: sig.name)
+            member_name = signatures.find_module(member.name, current_module: AST::Namespace.root).name
+            build_instance(member_name, with_initialize: false).yield_self do |module_interface|
+              merge_mixin(module_interface,
+                          member.args.map {|type| absolute_type(type, current: namespace) },
+                          methods: methods,
+                          ivars: {},
+                          supers: supers,
+                          current: namespace)
+            end
           end
         end
 
@@ -226,14 +254,14 @@ module Steep
           when AST::Signature::Members::Method
             case
             when member.module_method?
-              add_method(type_name, member, methods: methods)
+              add_method(module_name, member, methods: methods, current: namespace)
             when member.instance_method? && member.name == :initialize
               if constructor
                 methods[:new] = Method.new(
-                  type_name: type_name,
+                  type_name: module_name,
                   name: :new,
                   types: member.types.map do |method_type_sig|
-                    method_type = method_type_to_method_type(method_type_sig, current: sig.name).with(return_type: AST::Types::Instance.new)
+                    method_type = method_type_to_method_type(method_type_sig, current: namespace).with(return_type: AST::Types::Instance.new)
                     args = (sig.params&.variables || []) + method_type.type_params
 
                     method_type.with(
@@ -242,7 +270,7 @@ module Steep
                     )
                   end,
                   super_method: nil,
-                  attributes: []
+                  attributes: [:incompatible]
                 )
               end
             end
@@ -254,18 +282,27 @@ module Steep
             case member
             when AST::Signature::Members::Method
               if member.module_method?
-                add_method(type_name, member, methods: methods)
+                add_method(module_name, member, methods: methods, current: namespace)
               end
             end
           end
         end
 
+        if methods[:new]&.type_name == AST::Builtin::Class.module_name
+          new_types = [MethodType.new(type_params: [],
+                                      params: Params.empty,
+                                      block: nil,
+                                      return_type: AST::Types::Instance.new,
+                                      location: nil)]
+          methods[:new] = methods[:new].with_types(new_types)
+        end
+
         unless constructor
           methods.delete(:new)
         end
 
         Abstract.new(
-          name: type_name,
+          name: module_name,
           params: [],
           methods: methods,
           supers: supers,
@@ -274,13 +311,14 @@ module Steep
       end
 
       def module_to_interface(sig)
-        type_name = TypeName::Module.new(name: sig.name)
+        module_name = sig.name
+        namespace = module_name.namespace.append(module_name.name)
 
-        supers = [sig.self_type].compact.map {|type| absolute_type(type, current: nil) }
+        supers = [sig.self_type].compact.map {|type| absolute_type(type, current: namespace) }
         methods = {}
         ivar_chains = {}
 
-        module_instance = build(TypeName::Instance.new(name: ModuleName.parse("::Module")))
+        module_instance = build_instance(AST::Builtin::Module.module_name, with_initialize: false)
         instantiated = module_instance.instantiate(
           type: AST::Types::Self.new,
           args: [],
@@ -292,19 +330,26 @@ module Steep
         sig.members.each do |member|
           case member
           when AST::Signature::Members::Include
-            merge_mixin(TypeName::Module.new(name: member.name),
-                        member.args.map {|type| absolute_type(type, current: sig.name) },
-                        methods: methods,
-                        ivars: ivar_chains,
-                        supers: supers,
-                        current: sig.name)
+            member_name = signatures.find_module(member.name, current_module: AST::Namespace.root).name
+            build_module(member_name).yield_self do |module_interface|
+              merge_mixin(module_interface,
+                          member.args.map {|type| absolute_type(type, current: namespace) },
+                          methods: methods,
+                          ivars: ivar_chains,
+                          supers: supers,
+                          current: namespace)
+            end
           when AST::Signature::Members::Extend
-            merge_mixin(TypeName::Instance.new(name: member.name),
-                        member.args.map {|type| absolute_type(type, current: sig.name) },
-                        methods: methods,
-                        ivars: ivar_chains,
-                        supers: supers,
-                        current: sig.name)
+            member_name = signatures.find_module(member.name, current_module: AST::Namespace.root).name
+            build_instance(member_name, with_initialize: false).yield_self do |module_interface|
+              merge_mixin(module_interface,
+                          member.args.map {|type| absolute_type(type, current: namespace) },
+                          methods: methods,
+                          ivars: ivar_chains,
+                          supers: supers,
+                          current: namespace)
+
+            end
           end
         end
 
@@ -312,29 +357,29 @@ module Steep
           case member
           when AST::Signature::Members::Method
             if member.module_method?
-              add_method(type_name, member, methods: methods)
+              add_method(module_name, member, methods: methods, current: namespace)
             end
           when AST::Signature::Members::Ivar
             merge_ivars(ivar_chains,
-                        { member.name => absolute_type(member.type, current: sig.name) })
+                        { member.name => absolute_type(member.type, current: namespace) })
           when AST::Signature::Members::Attr
-            merge_attribute(sig, ivar_chains, methods, type_name, member)
+            merge_attribute(sig, ivar_chains, methods, module_name, member)
           end
         end
 
-        signatures.find_extensions(sig.name).each do |ext|
+        signatures.find_extensions(module_name).each do |ext|
           ext.members.each do |member|
             case member
             when AST::Signature::Members::Method
               if member.module_method?
-                add_method(type_name, member, methods: methods)
+                add_method(module_name, member, methods: methods, current: namespace)
               end
             end
           end
         end
 
         Abstract.new(
-          name: type_name,
+          name: module_name,
           params: [],
           methods: methods,
           supers: supers,
@@ -343,7 +388,8 @@ module Steep
       end
 
       def instance_to_interface(sig, with_initialize:)
-        type_name = TypeName::Instance.new(name: sig.name)
+        module_name = sig.name
+        namespace = module_name.namespace.append(module_name.name)
 
         params = sig.params&.variables || []
         supers = []
@@ -351,14 +397,18 @@ module Steep
         ivar_chains = {}
 
         if sig.is_a?(AST::Signature::Class)
-          unless sig.name == ModuleName.parse("::BasicObject")
-            super_class_name = sig.super_class&.name || ModuleName.parse("::Object")
-            super_class_interface = build(TypeName::Instance.new(name: super_class_name), current: nil, with_initialize: with_initialize)
+          unless sig.name == AST::Builtin::BasicObject.module_name
+            super_class_name = sig.super_class&.name || AST::Builtin::Object.module_name
+            if super_class_name.relative?
+              super_class_name = signatures.find_class(super_class_name, current_module: namespace).name
+            end
+            super_class_interface = build_instance(super_class_name,
+                                                   with_initialize: with_initialize)
 
             supers.push(*super_class_interface.supers)
             instantiated = super_class_interface.instantiate(
               type: AST::Types::Self.new,
-              args: (sig.super_class&.args || []).map {|type| absolute_type(type, current: nil) },
+              args: (sig.super_class&.args || []).map {|type| absolute_type(type, current: namespace) },
               instance_type: AST::Types::Instance.new,
               module_type: AST::Types::Class.new
             )
@@ -370,19 +420,22 @@ module Steep
 
         if sig.is_a?(AST::Signature::Module)
           if sig.self_type
-            supers << sig.self_type
+            supers << absolute_type(sig.self_type, current: namespace)
           end
         end
 
         sig.members.each do |member|
           case member
           when AST::Signature::Members::Include
-            merge_mixin(TypeName::Instance.new(name: member.name),
-                        member.args.map {|type| absolute_type(type, current: sig.name) },
-                        methods: methods,
-                        ivars: ivar_chains,
-                        supers: supers,
-                        current: sig.name)
+            member_name = signatures.find_module(member.name, current_module: namespace).name
+            build_instance(member_name, with_initialize: false).yield_self do |module_interface|
+              merge_mixin(module_interface,
+                          member.args.map {|type| absolute_type(type, current: namespace) },
+                          methods: methods,
+                          ivars: ivar_chains,
+                          supers: supers,
+                          current: namespace)
+            end
           end
         end
 
@@ -392,14 +445,14 @@ module Steep
             if member.instance_method?
               if with_initialize || member.name != :initialize
                 extra_attrs = member.name == :initialize ? [:incompatible] : []
-                add_method(type_name, member, methods: methods, extra_attributes: extra_attrs)
+                add_method(module_name, member, methods: methods, extra_attributes: extra_attrs, current: namespace)
               end
             end
           when AST::Signature::Members::Ivar
             merge_ivars(ivar_chains,
-                        { member.name => absolute_type(member.type, current: sig.name) })
+                        { member.name => absolute_type(member.type, current: namespace) })
           when AST::Signature::Members::Attr
-            merge_attribute(sig, ivar_chains, methods, type_name, member)
+            merge_attribute(sig, ivar_chains, methods, module_name, member, current: namespace)
           end
         end
 
@@ -408,14 +461,14 @@ module Steep
             case member
             when AST::Signature::Members::Method
               if member.instance_method?
-                add_method(type_name, member, methods: methods)
+                add_method(module_name, member, methods: methods, current: namespace)
               end
             end
           end
         end
 
         Abstract.new(
-          name: type_name,
+          name: module_name,
           params: params,
           methods: methods,
           supers: supers,
@@ -423,11 +476,11 @@ module Steep
         )
       end
 
-      def merge_attribute(sig, ivar_chains, methods, type_name, member)
+      def merge_attribute(sig, ivar_chains, methods, type_name, member, current:)
         if member.ivar != false
           ivar_name = member.ivar || "@#{member.name}".to_sym
           merge_ivars(ivar_chains,
-                      { ivar_name => absolute_type(member.type, current: sig.name) })
+                      { ivar_name => absolute_type(member.type, current: current) })
         end
 
         reader_method = AST::Signature::Members::Method.new(
@@ -443,7 +496,7 @@ module Steep
           ],
           attributes: []
         )
-        add_method(type_name, reader_method, methods: methods)
+        add_method(type_name, reader_method, methods: methods, current: current)
 
         if member.accessor?
           writer_method = AST::Signature::Members::Method.new(
@@ -453,14 +506,16 @@ module Steep
             types: [
               AST::MethodType.new(location: member.type.location,
                                   type_params: nil,
-                                  params: AST::MethodType::Params::Required.new(location: member.type.location,
-                                                                                type: member.type),
+                                  params: AST::MethodType::Params::Required.new(
+                                    location: member.type.location,
+                                    type: member.type
+                                  ),
                                   block: nil,
                                   return_type: member.type)
             ],
             attributes: []
           )
-          add_method(type_name, writer_method, methods: methods)
+          add_method(type_name, writer_method, methods: methods, current: current)
         end
       end
 
@@ -471,7 +526,7 @@ module Steep
       end
 
       def interface_to_interface(_, sig)
-        type_name = TypeName::Interface.new(name: sig.name)
+        type_name = sig.name
 
         variables = sig.params&.variables || []
         methods = sig.methods.each.with_object({}) do |method, methods|
@@ -479,7 +534,7 @@ module Steep
             type_name: type_name,
             name: method.name,
             types: method.types.map do |method_type|
-              method_type_to_method_type(method_type, current: nil)
+              method_type_to_method_type(method_type, current: type_name.namespace)
             end,
             super_method: nil,
             attributes: []