steep 0.5.1 → 0.6.0

data/lib/steep/source.rb

@@ -38,7 +38,7 @@ module Steep
     end
 
     def self.parser
-      ::Parser::CurrentRuby.new(Builder.new).tap do |parser|
+      ::Parser::Ruby25.new(Builder.new).tap do |parser|
         parser.diagnostics.all_errors_are_fatal = true
         parser.diagnostics.ignore_warnings = true
       end
@@ -60,7 +60,7 @@ module Steep
       _, comments, _ = yield_self do
         buffer = ::Parser::Source::Buffer.new(path.to_s)
         buffer.source = source_code
-        parser = ::Parser::CurrentRuby.new
+        parser = ::Parser::Ruby25.new
 
         parser.tokenize(buffer)
       end

data/lib/steep/subtyping/check.rb

@@ -40,7 +40,7 @@ module Steep
       end
 
       def alias?(type)
-        type.is_a?(AST::Types::Name) && type.name.is_a?(TypeName::Alias)
+        type.is_a?(AST::Types::Name::Alias)
       end
 
       def cacheable?(relation)
@@ -75,7 +75,7 @@ module Steep
         when relation.super_type.is_a?(AST::Types::Boolean)
           success(constraints: constraints)
 
-        when relation.sub_type.is_a?(AST::Types::Name) && relation.sub_type.name.is_a?(TypeName::Alias)
+        when alias?(relation.sub_type)
           check0(
             Relation.new(sub_type: expand_alias(relation.sub_type), super_type: relation.super_type),
             assumption: assumption,
@@ -83,7 +83,7 @@ module Steep
             constraints: constraints
           )
 
-        when relation.super_type.is_a?(AST::Types::Name) && relation.super_type.name.is_a?(TypeName::Alias)
+        when alias?(relation.super_type)
           check0(
             Relation.new(super_type: expand_alias(relation.super_type), sub_type: relation.sub_type),
             assumption: assumption,
@@ -165,10 +165,9 @@ module Steep
                     trace: trace)
           end
 
-        when relation.sub_type.is_a?(AST::Types::Name) && relation.super_type.is_a?(AST::Types::Name)
-          case
-          when relation.sub_type.name == relation.super_type.name && relation.sub_type.args.size == relation.super_type.args.size
-            results = relation.sub_type.args.zip(relation.super_type.args).flat_map do |(sub, sup)|
+        when relation.sub_type.is_a?(AST::Types::Name::Base) && relation.super_type.is_a?(AST::Types::Name::Base)
+          if (pairs = extract_nominal_pairs(relation))
+            results = pairs.flat_map do |(sub, sup)|
               Relation.new(sub_type: sub, super_type: sup).yield_self do |rel|
                 [rel, rel.flip]
               end
@@ -185,8 +184,8 @@ module Steep
               results.find(&:failure?)
             end
           else
-            sub_interface = resolve(relation.sub_type, with_initialize: false)
-            super_interface = resolve(relation.super_type, with_initialize: false)
+            sub_interface = resolve(relation.sub_type)
+            super_interface = resolve(relation.super_type)
 
             check_interface(sub_interface, super_interface, assumption: assumption, trace: trace, constraints: constraints)
           end
@@ -223,8 +222,8 @@ module Steep
           end
 
         when relation.sub_type.is_a?(AST::Types::Tuple)
-          sub_interface = resolve(relation.sub_type, with_initialize: false)
-          super_interface = resolve(relation.super_type, with_initialize: false)
+          sub_interface = resolve(relation.sub_type)
+          super_interface = resolve(relation.super_type)
 
           check_interface(sub_interface,
                           super_interface,
@@ -237,6 +236,34 @@ module Steep
                   trace: trace)
         end
       end
+      
+      def extract_nominal_pairs(relation)
+        sub_type = relation.sub_type
+        super_type = relation.super_type
+        
+        case
+        when sub_type.is_a?(AST::Types::Name::Instance) && super_type.is_a?(AST::Types::Name::Instance)
+          if sub_type.name == super_type.name && sub_type.args.size == super_type.args.size
+            sub_type.args.zip(super_type.args)
+          end
+        when sub_type.is_a?(AST::Types::Name::Interface) && super_type.is_a?(AST::Types::Name::Interface)
+          if sub_type.name == super_type.name && sub_type.args.size == super_type.args.size
+            sub_type.args.zip(super_type.args)
+          end
+        when sub_type.is_a?(AST::Types::Name::Alias) && super_type.is_a?(AST::Types::Name::Alias)
+          if sub_type.name == super_type.name && sub_type.args.size == super_type.args.size
+            sub_type.args.zip(super_type.args)
+          end
+        when sub_type.is_a?(AST::Types::Name::Class) && super_type.is_a?(AST::Types::Name::Class)
+          if sub_type.name == super_type.name
+            []
+          end
+        when sub_type.is_a?(AST::Types::Name::Module) && super_type.is_a?(AST::Types::Name::Module)
+          if sub_type.name == super_type.name
+            []
+          end
+        end
+      end
 
       def same_type?(relation, assumption:)
         if assumption.include?(relation) && assumption.include?(relation.flip)
@@ -246,11 +273,13 @@ module Steep
         case
         when relation.sub_type == relation.super_type
           true
-        when relation.sub_type.is_a?(AST::Types::Name) && relation.super_type.is_a?(AST::Types::Name)
-          return false unless relation.sub_type.name == relation.super_type.name
-          return false unless relation.sub_type.args.size == relation.super_type.args.size
-          relation.sub_type.args.zip(relation.super_type.args).all? do |(s, t)|
-            same_type?(Relation.new(sub_type: s, super_type: t), assumption: assumption)
+        when relation.sub_type.is_a?(AST::Types::Name::Base) && relation.super_type.is_a?(AST::Types::Name::Base)
+          if (pairs = extract_nominal_pairs(relation))
+            pairs.all? do |(s, t)|
+              same_type?(Relation.new(sub_type: s, super_type: t), assumption: assumption)
+            end
+          else
+            false
           end
         else
           false
@@ -553,11 +582,16 @@ module Steep
       end
 
       def module_type(type)
-        case
-        when builder.signatures.class?(type.name)
-          type.class_type(constructor: nil)
-        when builder.signatures.module?(type.name)
-          type.module_type
+        case type.name
+        when TypeName::Instance
+          case
+          when builder.signatures.class_name?(type.name.name)
+            type.class_type(constructor: nil)
+          when builder.signatures.module_name?(type.name.name)
+            type.module_type
+          end
+        else
+          nil
         end
       end
 
@@ -601,48 +635,107 @@ module Steep
         end
       end
 
-      def resolve(type, self_type: type, instance_type: nil, module_type: nil, with_initialize:)
+      def resolve_instance(type, self_type:, instance_type:, module_type:, with_initialize: false)
+        abstract_interface = builder.build_instance(type.name, with_initialize: with_initialize)
+
+        module_type = module_type || case builder.signatures.find_class_or_module(type.name)
+                                     when AST::Signature::Class
+                                       AST::Types::Name::Class.new(name: type.name, constructor: nil)
+                                     when AST::Signature::Module
+                                       AST::Types::Name::Module.new(name: type.name)
+                                     end
+
+        abstract_interface.instantiate(
+          type: self_type,
+          args: type.args,
+          instance_type: instance_type || type,
+          module_type: module_type
+        )
+      end
+
+      def resolve(type, self_type: type, instance_type: nil, module_type: nil)
         Steep.logger.debug("Check#resolve: type=#{type}")
         case type
         when AST::Types::Any, AST::Types::Var, AST::Types::Class, AST::Types::Instance
           raise CannotResolveError.new(type: type)
+
         when AST::Types::Nil, AST::Types::Literal, AST::Types::Boolean
           resolve(type.back_type,
                   self_type: self_type,
                   instance_type: instance_type,
-                  module_type: module_type,
-                  with_initialize: with_initialize)
-        when AST::Types::Name
-          case type.name
-          when TypeName::Alias
-            resolve(expand_alias(type), self_type: self_type, instance_type: instance_type, module_type: module_type, with_initialize: with_initialize)
-          else
-            builder.build(type.name, with_initialize: with_initialize).yield_self do |abstract|
-              case type.name
-              when TypeName::Instance, TypeName::Interface
-                abstract.instantiate(
-                  type: self_type,
-                  args: type.args,
-                  instance_type: type,
-                  module_type: module_type || module_type(type)
-                )
-              when TypeName::Class, TypeName::Module
-                signature = builder.signatures.find_class_or_module(type.name.name)
-                args = signature.params&.variables&.map {|var| AST::Types::Var.new(name: var) } || []
-                abstract.instantiate(
-                  type: self_type,
-                  args: [],
-                  instance_type: AST::Types::Name.new_instance(name: type.name.name, args: args),
-                  module_type: module_type || module_type(type)
-                )
-              end
+                  module_type: module_type)
+
+        when AST::Types::Name::Instance
+          resolve_instance(type, self_type: self_type, instance_type: instance_type, module_type: module_type)
+
+        when AST::Types::Name::Class
+          yield_self do
+            abstract_interface = builder.build_class(type.name, constructor: type.constructor)
+
+            unless instance_type
+              type_params = builder.signatures.find_class(type.name).params&.variables || []
+              instance_type = AST::Types::Name::Instance.new(name: type.name,
+                                                             args: type_params.map {|var| AST::Types::Var.new(name: var) })
+            end
+
+            interface = abstract_interface.instantiate(
+              type: self_type,
+              args: [],
+              instance_type: instance_type,
+              module_type: AST::Builtin::Class.class_type
+            )
+
+            if type_params
+              interface.subst(Interface::Substitution.build(type_params, type_params.map { AST::Builtin.any_type }))
+            else
+              interface
+            end
+          end
+
+        when AST::Types::Name::Module
+          yield_self do
+            abstract_interface = builder.build_module(type.name)
+
+            unless instance_type
+              type_params = builder.signatures.find_module(type.name).params&.variables || []
+              instance_type = AST::Types::Name::Instance.new(name: type.name,
+                                                             args: type_params.map {|var| AST::Types::Var.new(name: var) })
+            end
+
+            interface = abstract_interface.instantiate(
+              type: self_type,
+              args: [],
+              instance_type: instance_type,
+              module_type: AST::Builtin::Module.class_type
+            )
+
+            if type_params
+              interface.subst(Interface::Substitution.build(type_params, type_params.map { AST::Builtin.any_type }))
+            else
+              interface
             end
           end
+
+        when AST::Types::Name::Interface
+          yield_self do
+            abstract_interface = builder.build_interface(type.name)
+
+            abstract_interface.instantiate(
+              type: self_type,
+              args: type.args,
+              instance_type: nil,
+              module_type: nil
+            )
+          end
+
+        when AST::Types::Name::Alias
+          resolve(expand_alias(type), self_type: self_type, instance_type: instance_type, module_type: module_type)
+
         when AST::Types::Union
           interfaces = type.types.map do |member_type|
             fresh = AST::Types::Var.fresh(:___)
 
-            resolve(member_type, self_type: type, instance_type: fresh, module_type: fresh, with_initialize: with_initialize).select_method_type do |method_type|
+            resolve(member_type, self_type: type, instance_type: fresh, module_type: fresh).select_method_type do |method_type|
               !method_type.each_type.include?(fresh)
             end
           end
@@ -711,7 +804,7 @@ module Steep
                                       ivar_chains: {})
 
         when AST::Types::Intersection
-          interfaces = type.types.map do |type| resolve(type, with_initialize: with_initialize) end
+          interfaces = type.types.map do |type| resolve(type) end
 
           methods = interfaces.inject(nil) do |methods, i|
             if methods
@@ -763,9 +856,8 @@ module Steep
         when AST::Types::Tuple
           yield_self do
             element_type = AST::Types::Union.build(types: type.types)
-            array_type = AST::Types::Name.new_instance(name: "::Array",
-                                                       args: [element_type])
-            array_interface = resolve(array_type, self_type: self_type, with_initialize: with_initialize)
+            array_type = AST::Builtin::Array.instance_type(element_type)
+            array_interface = resolve(array_type, self_type: self_type)
 
             array_interface.methods[:[]] = array_interface.methods[:[]].yield_self do |aref|
               types = type.types.map.with_index {|elem_type, index|
@@ -806,9 +898,56 @@ module Steep
             array_interface
           end
 
+        when AST::Types::Hash
+          yield_self do
+            key_type = AST::Types::Union.build(types: type.elements.keys.map {|val| AST::Types::Literal.new(value: val) })
+            value_type = AST::Types::Union.build(types: type.elements.values)
+            hash_interface = resolve(AST::Builtin::Hash.instance_type(key_type, value_type), self_type: self_type)
+
+            hash_interface.methods[:[]] = hash_interface.methods[:[]].yield_self do |ref|
+              types = type.elements.map do |key, value_type|
+                Interface::MethodType.new(
+                  type_params: [],
+                  params: Interface::Params.new(required: [AST::Types::Literal.new(value: key)],
+                                                optional: [],
+                                                rest: nil,
+                                                required_keywords: {},
+                                                optional_keywords: {},
+                                                rest_keywords: nil),
+                  return_type: value_type,
+                  block: nil,
+                  location: nil
+                )
+              end
+
+              ref.with_types(types + ref.types)
+            end
+
+            hash_interface.methods[:[]=] = hash_interface.methods[:[]=].yield_self do |method|
+              types = type.elements.map do |key, value_type|
+                Interface::MethodType.new(
+                  type_params: [],
+                  params: Interface::Params.new(required: [AST::Types::Literal.new(value: key), value_type],
+                                                optional: [],
+                                                rest: nil,
+                                                required_keywords: {},
+                                                optional_keywords: {},
+                                                rest_keywords: nil),
+                  return_type: value_type,
+                  block: nil,
+                  location: nil
+                )
+              end
+
+              method.with_types(types + method.types)
+            end
+
+            hash_interface
+          end
+
         when AST::Types::Proc
           yield_self do
-            proc_interface = resolve(type.back_type, self_type: self_type, with_initialize: with_initialize)
+            proc_interface = resolve(type.back_type, self_type: self_type)
             apply_type = Interface::MethodType.new(
               type_params: [],
               params: type.params,
@@ -842,15 +981,12 @@ module Steep
                        types: type.types.map {|ty| expand_alias(ty) },
                        location: type.location
                      )
-                   when AST::Types::Name
-                     if type.name.is_a?(TypeName::Alias)
-                       a = builder.signatures.find_alias(type.name.name) or raise "Unknown alias name: #{type.name.name}"
-                       args = type.args.map {|ty| expand_alias(ty) }
-                       s = Interface::Substitution.build(a.params&.variables || [], args)
-                       expand_alias(a.type.subst(s))
-                     else
-                       type
-                     end
+                   when AST::Types::Name::Alias
+                     alias_sig = builder.signatures.find_alias(type.name, namespace: AST::Namespace.root)
+                     expanded_alias = builder.absolute_type(alias_sig.type, current: alias_sig.name.namespace)
+                     args = type.args.map {|ty| expand_alias(ty) }
+                     s = Interface::Substitution.build(alias_sig.params&.variables || [], args)
+                     expand_alias(expanded_alias.subst(s))
                    else
                      type
                    end

data/lib/steep/subtyping/constraints.rb

@@ -133,14 +133,11 @@ module Steep
 
       def eliminate_variable(type, to:)
         case type
-        when AST::Types::Name
+        when AST::Types::Name::Instance, AST::Types::Name::Alias, AST::Types::Name::Interface
           type.args.map do |ty|
             eliminate_variable(ty, to: AST::Types::Any.new)
           end.yield_self do |args|
-            AST::Types::Name.new(
-              name: type.name,
-              args: args
-            )
+            type.class.new(name: type.name, args: args, location: type.location)
           end
         when AST::Types::Union
           type.types.map do |ty|

data/lib/steep/subtyping/variable_variance.rb

@@ -54,11 +54,11 @@ module Steep
             covariants << type.name
             contravariants << type.name
           end
-        when AST::Types::Union, AST::Types::Intersection
+        when AST::Types::Union, AST::Types::Intersection, AST::Types::Tuple
           type.types.each do |ty|
             add_type(ty, variance: variance, covariants: covariants, contravariants: contravariants)
           end
-        when AST::Types::Name
+        when AST::Types::Name::Interface, AST::Types::Name::Instance, AST::Types::Name::Alias
           type.args.each do |arg|
             add_type(arg, variance: :invariant, covariants: covariants, contravariants: contravariants)
           end

data/lib/steep/type_construction.rb

@@ -1,58 +1,5 @@
 module Steep
   class TypeConstruction
-    module Types
-      module_function
-
-      def any
-        AST::Types::Any.new
-      end
-
-      def symbol_instance
-        AST::Types::Name.new_instance(name: "::Symbol")
-      end
-
-      def nil_instance
-        AST::Types::Nil.new
-      end
-
-      def string_instance
-        AST::Types::Name.new_instance(name: "::String")
-      end
-
-      def array_instance(type)
-        AST::Types::Name.new_instance(name: "::Array", args: [type])
-      end
-
-      def hash_instance(key, value)
-        AST::Types::Name.new_instance(name: "::Hash", args: [key, value])
-      end
-
-      def range_instance(type)
-        AST::Types::Name.new_instance(name: "::Range", args: [type])
-      end
-
-      def boolean?(type)
-        type.is_a?(AST::Types::Boolean)
-      end
-
-      def optional(type)
-        AST::Types::Union.build(types: [type, nil_instance])
-      end
-
-      def hash_instance?(type)
-        case type
-        when AST::Types::Name
-          type.name.is_a?(TypeName::Instance) && type.name.name == ModuleName.new(name: "Hash", absolute: true)
-        else
-          false
-        end
-      end
-
-      def array_instance?(type)
-        type.is_a?(AST::Types::Name) && type.name.is_a?(TypeName::Instance) && type.name.name == ModuleName.new(name: "Array", absolute: true)
-      end
-    end
-
     class MethodContext
       attr_reader :name
       attr_reader :method
@@ -113,6 +60,10 @@ module Steep
         @current_namespace = current_namespace
         @const_env = const_env
       end
+
+      def const_context
+        const_env.context
+      end
     end
 
     attr_reader :checker
@@ -165,10 +116,22 @@ module Steep
 
       self_type = expand_alias(annots.self_type || self_type)
 
-      self_interface = self_type && (self_type != Types.any || nil) && checker.resolve(self_type, with_initialize: true)
+      self_interface = self_type && (self_type != AST::Builtin.any_type || nil) && case self_type
+                                                                                   when AST::Types::Name::Instance
+                                                                                     yield_self do
+                                                                                       class_type = AST::Types::Name::Class.new(name: self_type.name, constructor: false)
+                                                                                       checker.resolve_instance(self_type,
+                                                                                                                self_type: self_type,
+                                                                                                                instance_type: self_type,
+                                                                                                                module_type: class_type,
+                                                                                                                with_initialize: true)
+                                                                                     end
+                                                                                   else
+                                                                                     checker.resolve(self_type)
+                                                                                   end
       interface_method = self_interface&.yield_self do |interface|
         interface.methods[method_name]&.yield_self do |method|
-          if self_type.is_a?(AST::Types::Name) && method.type_name == self_type.name
+          if self_type.is_a?(AST::Types::Name::Base) && method.type_name == self_type.name
             method
           else
             Interface::Method.new(type_name: self_type,
@@ -243,7 +206,7 @@ module Steep
         if (block_arg = args.find {|arg| arg.type == :blockarg })
           if method_type.block
             block_type = if method_type.block.optional?
-                           AST::Types::Union.build(types: [method_type.block.type, Types.nil_instance])
+                           AST::Types::Union.build(types: [method_type.block.type, AST::Builtin.nil_type])
                          else
                            method_type.block.type
                          end
@@ -313,11 +276,11 @@ module Steep
     end
 
     def for_module(node)
-      new_module_name = ModuleName.from_node(node.children.first) or raise "Unexpected module name: #{node.children.first}"
-      new_namespace = nested_namespace(new_module_name)
+      new_module_name = Names::Module.from_node(node.children.first) or raise "Unexpected module name: #{node.children.first}"
+      new_namespace = nested_namespace_for_module(new_module_name)
 
       annots = source.annotations(block: node, builder: checker.builder, current_module: new_namespace)
-      module_type = AST::Types::Name.new_instance(name: "::Module")
+      module_type = AST::Builtin::Module.instance_type
 
       implement_module_name = yield_self do
         if (annotation = annots.implement_module_annotation)
@@ -345,19 +308,19 @@ module Steep
         module_name = implement_module_name.name
         module_args = implement_module_name.args.map {|x| AST::Types::Var.new(name: x) }
 
-        abstract = checker.builder.build(TypeName::Instance.new(name: module_name))
+        abstract = checker.builder.build_module(module_name)
 
-        instance_type = AST::Types::Name.new_instance(name: module_name, args: module_args)
+        instance_type = AST::Types::Name::Instance.new(name: module_name, args: module_args)
 
         unless abstract.supers.empty?
           instance_type = AST::Types::Intersection.build(
-            types: [instance_type, AST::Types::Name.new_instance(name: "::Object")] + abstract.supers.map {|x| absolute_type(x) }
+            types: [instance_type, AST::Builtin::Object.instance_type] + abstract.supers.map {|x| absolute_type(x) }
           )
         end
 
         module_type = AST::Types::Intersection.build(types: [
-          AST::Types::Name.new_instance(name: "::Module"),
-          absolute_type(AST::Types::Name.new_module(name: module_name, args: module_args))
+          AST::Builtin::Module.instance_type,
+          AST::Types::Name::Module.new(name: module_name)
         ])
       end
 
@@ -369,7 +332,12 @@ module Steep
         module_type = annots.module_type
       end
 
-      module_const_env = TypeInference::ConstantEnv.new(builder: checker.builder, current_namespace: new_namespace)
+      const_context = if new_namespace.empty?
+                        nil
+                      else
+                        Names::Module.new(name: new_namespace.path.last, namespace: new_namespace.parent)
+                      end
+      module_const_env = TypeInference::ConstantEnv.new(builder: checker.builder, context: const_context)
 
       module_context_ = ModuleContext.new(
         instance_type: instance_type,
@@ -399,8 +367,8 @@ module Steep
     end
 
     def for_class(node)
-      new_class_name = ModuleName.from_node(node.children.first) or raise "Unexpected class name: #{node.children.first}"
-      new_namespace = nested_namespace(new_class_name)
+      new_class_name = Names::Module.from_node(node.children.first) or raise "Unexpected class name: #{node.children.first}"
+      new_namespace = nested_namespace_for_module(new_class_name)
 
       annots = source.annotations(block: node, builder: checker.builder, current_module: new_namespace)
 
@@ -430,13 +398,18 @@ module Steep
         class_name = implement_module_name.name
         class_args = implement_module_name.args.map {|x| AST::Types::Var.new(name: x) }
 
-        _ = checker.builder.build(TypeName::Instance.new(name: class_name))
+        _ = checker.builder.build_instance(class_name, with_initialize: true)
 
-        instance_type = AST::Types::Name.new_instance(name: class_name, args: class_args)
-        module_type = AST::Types::Name.new_class(name: class_name, args: [], constructor: true)
+        instance_type = AST::Types::Name::Instance.new(name: class_name, args: class_args)
+        module_type = AST::Types::Name::Class.new(name: class_name, constructor: true)
       end
 
-      class_const_env = TypeInference::ConstantEnv.new(builder: checker.builder, current_namespace: new_namespace)
+      const_context = if new_namespace.empty?
+                        nil
+                      else
+                        Names::Module.new(name: new_namespace.path.last, namespace: new_namespace.parent)
+                      end
+      class_const_env = TypeInference::ConstantEnv.new(builder: checker.builder, context: const_context)
 
       module_context = ModuleContext.new(
         instance_type: annots.instance_type || instance_type,
@@ -541,7 +514,7 @@ module Steep
             if last_node
               type = synthesize(last_node, hint: hint)
             else
-              type = Types.nil_instance
+              type = AST::Builtin.nil_type
             end
 
             typing.add_typing(node, type)
@@ -553,8 +526,8 @@ module Steep
             rhs = node.children[1]
 
             if var.name == :_
-              synthesize(rhs, hint: Types.any)
-              typing.add_typing(node, Types.any)
+              synthesize(rhs, hint: AST::Builtin.any_type)
+              typing.add_typing(node, AST::Builtin.any_type)
             else
               type_assignment(var, rhs, node, hint: hint)
             end
@@ -589,9 +562,8 @@ module Steep
           yield_self do
             if self_class?(node)
               module_type = expand_alias(module_context.module_type)
-              type = if module_type.is_a?(AST::Types::Name) && module_type.name.is_a?(TypeName::Class)
-                       AST::Types::Name.new(name: module_type.name.updated(constructor: method_context.constructor),
-                                            args: module_type.args)
+              type = if module_type.is_a?(AST::Types::Name::Class)
+                       AST::Types::Name::Class.new(name: module_type.name, constructor: method_context.constructor)
                      else
                        module_type
                      end
@@ -605,9 +577,8 @@ module Steep
           yield_self do
             type = if self_class?(node)
                      module_type = expand_alias(module_context.module_type)
-                     type = if module_type.is_a?(AST::Types::Name)
-                              AST::Types::Name.new(name: module_type.name.updated(constructor: method_context.constructor),
-                                                   args: module_type.args)
+                     type = if module_type.is_a?(AST::Types::Name::Class)
+                              AST::Types::Name::Class.new(name: module_type.name, constructor: method_context.constructor)
                             else
                               module_type
                             end
@@ -616,14 +587,14 @@ module Steep
                      type_send(node, send_node: node, block_params: nil, block_body: nil, unwrap: true)
                    end
 
-            union_type(type, Types.nil_instance)
+            union_type(type, AST::Builtin.nil_type)
           end
 
         when :match_with_lvasgn
           each_child_node(node) do |child|
             synthesize(child)
           end
-          typing.add_typing(node, Types.any)
+          typing.add_typing(node, AST::Builtin.any_type)
 
         when :op_asgn
           yield_self do
@@ -646,12 +617,12 @@ module Steep
                        end
 
             case
-            when lhs_type == Types.any
+            when lhs_type == AST::Builtin.any_type
               typing.add_typing(node, lhs_type)
             when !lhs_type
               fallback_to_any(node)
             else
-              lhs_interface = checker.resolve(lhs_type, with_initialize: false)
+              lhs_interface = checker.resolve(lhs_type)
               op_method = lhs_interface.methods[op]
 
               if op_method
@@ -718,7 +689,7 @@ module Steep
                 end
               end
             else
-              typing.add_typing node, Types.any
+              typing.add_typing node, AST::Builtin.any_type
             end
           end
 
@@ -758,13 +729,13 @@ module Steep
             return_type = expand_alias(new.method_context&.return_type)
             if return_type && !return_type.is_a?(AST::Types::Void)
               result = checker.check(
-                Subtyping::Relation.new(sub_type: Types.nil_instance, super_type: return_type),
+                Subtyping::Relation.new(sub_type: AST::Builtin.nil_type, super_type: return_type),
                 constraints: Subtyping::Constraints.empty
               )
               if result.failure?
                 typing.add_error(Errors::MethodBodyTypeMismatch.new(node: node,
                                                                     expected: new.method_context&.return_type,
-                                                                    actual: Types.nil_instance,
+                                                                    actual: AST::Builtin.nil_type,
                                                                     result: result))
               end
             end            
@@ -774,7 +745,7 @@ module Steep
             module_context.defined_instance_methods << node.children[0]
           end
 
-          typing.add_typing(node, Types.any)
+          typing.add_typing(node, AST::Builtin.any_type)
 
         when :defs
           synthesize(node.children[0]).tap do |self_type|
@@ -808,7 +779,7 @@ module Steep
             end
           end
 
-          typing.add_typing(node, Types.symbol_instance)
+          typing.add_typing(node, AST::Builtin::Symbol.instance_type)
 
         when :return
           yield_self do
@@ -820,7 +791,7 @@ module Steep
               value_type = if return_types.size == 1
                              return_types.first
                            else
-                             Types.array_instance(union_type(*return_types))
+                             AST::Builtin::Array.instance_type(union_type(*return_types))
                            end
 
               if (ret_type = expand_alias(method_context&.return_type))
@@ -841,7 +812,7 @@ module Steep
               end
             end
 
-            typing.add_typing(node, Types.any)
+            typing.add_typing(node, AST::Builtin.any_type)
           end
 
         when :break
@@ -867,7 +838,7 @@ module Steep
             typing.add_error Errors::UnexpectedJump.new(node: node)
           end
 
-          typing.add_typing(node, Types.any)
+          typing.add_typing(node, AST::Builtin.any_type)
 
         when :next
           value = node.children[0]
@@ -892,13 +863,13 @@ module Steep
             typing.add_error Errors::UnexpectedJump.new(node: node)
           end
 
-          typing.add_typing(node, Types.any)
+          typing.add_typing(node, AST::Builtin.any_type)
 
         when :retry
           unless break_context
             typing.add_error Errors::UnexpectedJump.new(node: node)
           end
-          typing.add_typing(node, Types.any)
+          typing.add_typing(node, AST::Builtin.any_type)
 
         when :arg, :kwarg, :procarg0
           yield_self do
@@ -921,7 +892,7 @@ module Steep
             var = node.children[0]
             type = type_env.get(lvar: var.name) do
               typing.add_error Errors::FallbackAny.new(node: node)
-              Types.array_instance(Types.any)
+              AST::Builtin::Array.instance_type(AST::Builtin.any_type)
             end
 
             typing.add_typing(node, type)
@@ -932,17 +903,17 @@ module Steep
             var = node.children[0]
             type = type_env.get(lvar: var.name) do
               typing.add_error Errors::FallbackAny.new(node: node)
-              Types.hash_instance(Types.symbol_instance, Types.any)
+              AST::Builtin::Hash.instance_type(AST::Builtin::Symbol.instance_type, AST::Builtin.any_type)
             end
 
             typing.add_typing(node, type)
           end
 
         when :float
-          typing.add_typing(node, AST::Types::Name.new_instance(name: "::Float"))
+          typing.add_typing(node, AST::Builtin::Float.instance_type)
 
         when :nil
-          typing.add_typing(node, Types.nil_instance)
+          typing.add_typing(node, AST::Builtin.nil_type)
 
         when :int
           yield_self do
@@ -951,7 +922,7 @@ module Steep
             if literal_type
               typing.add_typing(node, literal_type)
             else
-              typing.add_typing(node, AST::Types::Name.new_instance(name: "::Integer"))
+              typing.add_typing(node, AST::Builtin::Integer.instance_type)
             end
           end
 
@@ -962,7 +933,7 @@ module Steep
             if literal_type
               typing.add_typing(node, literal_type)
             else
-              typing.add_typing(node, Types.symbol_instance)
+              typing.add_typing(node, AST::Builtin::Symbol.instance_type)
             end
           end
 
@@ -973,7 +944,7 @@ module Steep
             if literal_type
               typing.add_typing(node, literal_type)
             else
-              typing.add_typing(node, Types.string_instance)
+              typing.add_typing(node, AST::Builtin::String.instance_type)
             end
           end
 
@@ -982,7 +953,9 @@ module Steep
 
         when :hash
           yield_self do
-            if Types.hash_instance?(hint)
+            ty = try_hash_type(node, hint) and return ty
+
+            if AST::Builtin::Hash.instance_type?(hint)
               key_hint = hint.args[0]
               value_hint = hint.args[1]
             end
@@ -1002,13 +975,13 @@ module Steep
                 end
               when :kwsplat
                 expand_alias(synthesize(child.children[0])) do |splat_type, original_type|
-                  if splat_type.is_a?(AST::Types::Name) && splat_type.name == TypeName::Instance.new(name: ModuleName.parse("::Hash"))
+                  if AST::Builtin::Hash.instance_type?(splat_type)
                     key_types << splat_type.args[0]
                     value_types << splat_type.args[1]
                   else
                     typing.add_error Errors::UnexpectedSplat.new(node: child, type: original_type)
-                    key_types << Types.any
-                    value_types << Types.any
+                    key_types << AST::Builtin.any_type
+                    value_types << AST::Builtin.any_type
                   end
                 end
               else
@@ -1016,14 +989,14 @@ module Steep
               end
             end
 
-            key_type = key_types.empty? ? Types.any : AST::Types::Union.build(types: key_types)
-            value_type = value_types.empty? ? Types.any : AST::Types::Union.build(types: value_types)
+            key_type = key_types.empty? ? AST::Builtin.any_type : AST::Types::Union.build(types: key_types)
+            value_type = value_types.empty? ? AST::Builtin.any_type : AST::Types::Union.build(types: value_types)
 
             if key_types.empty? && value_types.empty? && !hint
               typing.add_error Errors::FallbackAny.new(node: node)
             end
 
-            typing.add_typing(node, Types.hash_instance(key_type, value_type))
+            typing.add_typing(node, AST::Builtin::Hash.instance_type(key_type, value_type))
           end
 
         when :dstr, :xstr
@@ -1031,14 +1004,14 @@ module Steep
             synthesize(child)
           end
 
-          typing.add_typing(node, Types.string_instance)
+          typing.add_typing(node, AST::Builtin::String.instance_type)
 
         when :dsym
           each_child_node(node) do |child|
             synthesize(child)
           end
 
-          typing.add_typing(node, Types.symbol_instance)
+          typing.add_typing(node, AST::Builtin::Symbol.instance_type)
 
         when :class
           yield_self do
@@ -1050,7 +1023,7 @@ module Steep
               end
             end
 
-            typing.add_typing(node, Types.nil_instance)
+            typing.add_typing(node, AST::Builtin.nil_type)
           end
 
         when :module
@@ -1063,7 +1036,7 @@ module Steep
               end
             end
 
-            typing.add_typing(node, Types.nil_instance)
+            typing.add_typing(node, AST::Builtin.nil_type)
           end
 
         when :self
@@ -1074,7 +1047,7 @@ module Steep
           end
 
         when :const
-          const_name = ModuleName.from_node(node)
+          const_name = Names::Module.from_node(node)
           if const_name
             type = type_env.get(const: const_name) do
               fallback_to_any node
@@ -1086,7 +1059,7 @@ module Steep
 
         when :casgn
           yield_self do
-            const_name = ModuleName.from_node(node)
+            const_name = Names::Module.from_node(node)
             if const_name
               value_type = synthesize(node.children.last)
               type = type_env.assign(const: const_name, type: value_type) do |error|
@@ -1139,7 +1112,7 @@ module Steep
               if method_context.super_method
                 if method_context.method.incompatible?
                   typing.add_error Errors::IncompatibleZuper.new(node: node, method: method_context.name)
-                  typing.add_typing node, Types.any
+                  typing.add_typing node, AST::Builtin.any_type
                 else
                   types = method_context.super_method.types.map(&:return_type)
                   typing.add_typing(node, union_type(*types))
@@ -1159,7 +1132,7 @@ module Steep
               unless hint
                 typing.add_error Errors::FallbackAny.new(node: node)
               end
-              typing.add_typing(node, Types.array_instance(Types.any))
+              typing.add_typing(node, AST::Builtin::Array.instance_type(AST::Builtin.any_type))
             else
               is_tuple = nil
 
@@ -1180,7 +1153,7 @@ module Steep
                 array_type = hint
               else
                 element_hint = expand_alias(hint) do |hint|
-                  Types.array_instance?(hint) && hint.args[0]
+                  AST::Builtin::Array.instance_type?(hint) && hint.args[0]
                 end
 
                 element_types = node.children.flat_map do |e|
@@ -1197,9 +1170,9 @@ module Steep
                       end
                     end.map do |type|
                       case
-                      when Types.array_instance?(type)
+                      when AST::Builtin::Array.instance_type?(type)
                         type.args.first
-                      when type.is_a?(AST::Types::Name) && type.name.is_a?(TypeName::Instance) && type.name.name == ModuleName.new(name: "Range", absolute: true)
+                      when AST::Builtin::Range.instance_type?(type)
                         type.args.first
                       else
                         type
@@ -1209,7 +1182,7 @@ module Steep
                     [select_super_type(synthesize(e), element_hint)]
                   end
                 end
-                array_type = Types.array_instance(AST::Types::Union.build(types: element_types))
+                array_type = AST::Builtin::Array.instance_type(AST::Types::Union.build(types: element_types))
               end
 
               typing.add_typing(node, array_type)
@@ -1230,10 +1203,10 @@ module Steep
             type_env.join!([right_env, TypeInference::TypeEnv.new(subtyping: checker,
                                                                   const_env: nil)])
 
-            if Types.boolean?(left_type)
+            if left_type.is_a?(AST::Types::Boolean)
               typing.add_typing(node, union_type(left_type, right_type))
             else
-              typing.add_typing(node, union_type(right_type, Types.nil_instance))
+              typing.add_typing(node, union_type(right_type, AST::Builtin.nil_type))
             end
           end
 
@@ -1285,18 +1258,18 @@ module Steep
                 end
 
                 if (body = clause.children.last)
-                  if var_names && var_types && test_types.all? {|type| type.is_a?(AST::Types::Name) && type.name.is_a?(TypeName::Class) && type.args.empty? }
+                  if var_names && var_types && test_types.all? {|type| type.is_a?(AST::Types::Name::Class) }
                     var_types_in_body = test_types.flat_map {|test_type|
-                      filtered_types = var_types.select {|var_type| var_type.name.name == test_type.name.name }
+                      filtered_types = var_types.select {|var_type| var_type.name == test_type.name }
                       if filtered_types.empty?
-                        test_type.instance_type
+                        to_instance_type(test_type)
                       else
                         filtered_types
                       end
                     }
                     var_types.reject! {|type|
                       var_types_in_body.any? {|test_type|
-                        test_type.name.name == type.name.name
+                        test_type.name == type.name
                       }
                     }
 
@@ -1312,7 +1285,7 @@ module Steep
                     pairs << [type, body_construction.type_env]
                   end
                 else
-                  pairs << [Types.nil_instance, nil]
+                  pairs << [AST::Builtin.nil_type, nil]
                 end
               else
                 if clause
@@ -1325,7 +1298,7 @@ module Steep
                     else
                       typing.add_error Errors::ElseOnExhaustiveCase.new(node: node, type: cond_type)
                       type_case_override = var_names.each.with_object({}) do |var_name, hash|
-                        hash[var_name] = Types.any
+                        hash[var_name] = AST::Builtin.any_type
                       end
                     end
                   end
@@ -1343,7 +1316,7 @@ module Steep
 
             if var_types
               unless var_types.empty? || whens.last
-                types.push Types.nil_instance
+                types.push AST::Builtin.nil_type
               end
             end
 
@@ -1384,15 +1357,15 @@ module Steep
                 instance_types = exn_types.map do |type|
                   type = expand_alias(type)
                   case
-                  when type.is_a?(AST::Types::Name) && type.name.is_a?(TypeName::Class)
-                    type.instance_type
+                  when type.is_a?(AST::Types::Name::Class)
+                    to_instance_type(type)
                   else
-                    Types.any
+                    AST::Builtin.any_type
                   end
                 end
                 type_override[var_name] = AST::Types::Union.build(types: instance_types)
               when var_name
-                type_override[var_name] = Types.any
+                type_override[var_name] = AST::Builtin.any_type
               end
 
               resbody_construction = for_branch(resbody, type_case_override: type_override)
@@ -1400,7 +1373,7 @@ module Steep
               type = if body
                        resbody_construction.synthesize(body)
                      else
-                       Types.nil_instance
+                       AST::Builtin.nil_type
                      end
               [type, resbody_construction.type_env]
             end
@@ -1451,12 +1424,12 @@ module Steep
               type_env.join!([for_loop.type_env])
             end
 
-            typing.add_typing(node, Types.any)
+            typing.add_typing(node, AST::Builtin.any_type)
           end
 
         when :irange, :erange
           types = node.children.map {|n| synthesize(n) }
-          type = Types.range_instance(union_type(*types))
+          type = AST::Builtin::Range.instance_type(union_type(*types))
           typing.add_typing(node, type)
 
         when :regexp
@@ -1464,14 +1437,14 @@ module Steep
             synthesize(child)
           end
 
-          typing.add_typing(node, AST::Types::Name.new_instance(name: "::Regexp"))
+          typing.add_typing(node, AST::Builtin::Regexp.instance_type)
 
         when :regopt
           # ignore
-          typing.add_typing(node, Types.any)
+          typing.add_typing(node, AST::Builtin.any_type)
 
         when :nth_ref, :back_ref
-          typing.add_typing(node, Types.string_instance)
+          typing.add_typing(node, AST::Builtin::String.instance_type)
 
         when :or_asgn, :and_asgn
           yield_self do
@@ -1485,12 +1458,13 @@ module Steep
             synthesize(child)
           end
 
-          typing.add_typing(node, Types.any)
+          typing.add_typing(node, AST::Builtin.any_type)
 
         when :gvasgn
           yield_self do
             name, rhs = node.children
-            type = checker.builder.signatures.find_gvar(name)&.type
+            type = checker.builder.absolute_type(checker.builder.signatures.find_gvar(name)&.type,
+                                                 current: AST::Namespace.root)
 
             if type
               check(rhs, type) do |_, rhs_type, result|
@@ -1508,13 +1482,11 @@ module Steep
         when :gvar
           yield_self do
             name = node.children.first
-            type = checker.builder.signatures.find_gvar(name)&.type
-
-            if type
-              typing.add_typing(node, type)
-            else
-              fallback_to_any node
+            type = type_env.get(gvar: name) do
+              typing.add_error Errors::FallbackAny.new(node: node)
             end
+
+            typing.add_typing(node, type)
           end
 
         when :block_pass
@@ -1525,7 +1497,7 @@ module Steep
               if hint.one_arg?
                 # Assumes Symbol#to_proc implementation
                 param_type = hint.params.required[0]
-                interface = checker.resolve(param_type, with_initialize: false)
+                interface = checker.resolve(param_type)
                 method = interface.methods[value.children[0]]
                 if method
                   return_types = method.types.flat_map do |method_type|
@@ -1554,7 +1526,7 @@ module Steep
               synthesize(child)
             end
 
-            typing.add_typing node, Types.any
+            typing.add_typing node, AST::Builtin.any_type
           end
 
         when :splat, :sclass
@@ -1565,7 +1537,7 @@ module Steep
               synthesize(child)
             end
 
-            typing.add_typing node, Types.any
+            typing.add_typing node, AST::Builtin.any_type
           end
 
         else
@@ -1658,7 +1630,7 @@ module Steep
 
           case
           when asgn.type == :lvasgn && asgn.children[0].name != :_
-            type ||= Types.nil_instance
+            type ||= AST::Builtin.nil_type
             type_env.assign(lvar: asgn.children[0].name, type: type) do |result|
               var_type = type_env.get(lvar: asgn.children[0].name)
               typing.add_error(Errors::IncompatibleAssignment.new(node: node,
@@ -1667,7 +1639,7 @@ module Steep
                                                                   result: result))
             end
           when asgn.type == :ivasgn
-            type ||= Types.nil_instance
+            type ||= AST::Builtin.nil_type
             type_env.assign(ivar: asgn.children[0], type: type) do |result|
               var_type = type_env.get(ivar: asgn.children[0])
               typing.add_error(Errors::IncompatibleAssignment.new(node: node,
@@ -1683,7 +1655,7 @@ module Steep
       when rhs_type.is_a?(AST::Types::Any)
         fallback_to_any(node)
 
-      when rhs_type.is_a?(AST::Types::Name) && rhs_type.name.is_a?(TypeName::Instance) && rhs_type.name.name == ModuleName.new(name: "Array", absolute: true)
+      when AST::Builtin::Array.instance_type?(rhs_type)
         element_type = rhs_type.args.first
 
         lhs.children.each do |assignment|
@@ -1711,7 +1683,7 @@ module Steep
         typing.add_typing node, rhs_type
 
       when rhs_type.is_a?(AST::Types::Union) &&
-        rhs_type.types.all? {|type| type.is_a?(AST::Types::Name) && type.name.is_a?(TypeName::Instance) && type.name.name == ModuleName.new(name: "Array", absolute: true) }
+        rhs_type.types.all? {|type| AST::Builtin::Array.instance_type?(type) }
 
         types = rhs_type.types.flat_map do |type|
           type.args.first
@@ -1779,14 +1751,15 @@ module Steep
 
       case receiver_type
       when AST::Types::Any
-        typing.add_typing node, Types.any
+        typing.add_typing node, AST::Builtin.any_type
 
       when nil
         fallback_to_any node
 
       else
         begin
-          interface = checker.resolve(receiver_type, with_initialize: false)
+          interface = checker.resolve(receiver_type)
+
           method = interface.methods[method_name]
 
           if method
@@ -1820,7 +1793,7 @@ module Steep
           unless typing.has_type?(arg)
             if arg.type == :splat
               type = synthesize(arg.children[0])
-              typing.add_typing(arg, Types.array_instance(type))
+              typing.add_typing(arg, AST::Builtin::Array.instance_type(type))
             else
               synthesize(arg)
             end
@@ -1831,11 +1804,11 @@ module Steep
           unless typing.has_type?(block_body)
             block_annotations = source.annotations(block: node, builder: checker.builder, current_module: current_namespace)
             params = TypeInference::BlockParams.from_node(block_params, annotations: block_annotations)
-            pairs = params.each.map {|param| [param, Types.any] }
+            pairs = params.each.map {|param| [param, AST::Builtin.any_type] }
 
             for_block, _ = for_block(block_annotations: block_annotations,
                                      param_pairs: pairs,
-                                     method_return_type: Types.any,
+                                     method_return_type: AST::Builtin.any_type,
                                      typing: typing)
 
             for_block.synthesize(block_body)
@@ -1928,7 +1901,7 @@ module Steep
 
         case method_type.return_type
         when AST::Types::Var
-          Types.any
+          AST::Builtin.any_type
         else
           method_type.return_type
         end
@@ -2052,7 +2025,7 @@ module Steep
               relation = Subtyping::Relation.new(sub_type: block_type,
                                                  super_type: method_type.block.yield_self do |expected_block|
                                                    if expected_block.optional?
-                                                     Types.optional(expected_block.type)
+                                                     AST::Builtin.optional(expected_block.type)
                                                    else
                                                      expected_block.type
                                                    end
@@ -2114,7 +2087,7 @@ module Steep
       else
         block_params.each do |param|
           var_name = param.var.name
-          param_types_hash[var_name] = param.type || Types.any
+          param_types_hash[var_name] = param.type || AST::Builtin.any_type
         end
       end
 
@@ -2171,7 +2144,7 @@ module Steep
                         for_block_body.synthesize(block_body, hint: block_type_hint)
                       end
       else
-        return_type = Types.any
+        return_type = AST::Builtin.any_type
       end
 
       AST::Types::Proc.new(
@@ -2340,7 +2313,7 @@ module Steep
       if type.params.rest
         a = nodes.first
         if a&.type == :restarg
-          env[a.children.first] = Types.array_instance(type.params.rest)
+          env[a.children.first] = AST::Builtin::Array.instance_type(type.params.rest)
           nodes.shift
         end
       end
@@ -2361,7 +2334,7 @@ module Steep
         if node.type == :kwrestarg
           ty = type.params.rest_keywords
           if ty
-            env[node.children[0]] = Types.hash_instance(Types.symbol_instance, ty)
+            env[node.children[0]] = AST::Builtin::Hash.instance_type(AST::Builtin::Symbol.instance_type, ty)
           end
         end
       end
@@ -2374,23 +2347,20 @@ module Steep
     end
 
     def current_namespace
-      module_context&.current_namespace
+      module_context&.current_namespace || AST::Namespace.root
     end
 
-    def nested_namespace(new)
-      case
-      when !new.simple?
-        current_namespace
-      when current_namespace
-        current_namespace + new
+    def nested_namespace_for_module(module_name)
+      if module_name.relative? && module_name.namespace.empty?
+        current_namespace.append(module_name.name)
       else
-        new.absolute!
+        current_namespace
       end
     end
 
     def absolute_name(module_name)
       if current_namespace
-        current_namespace + module_name
+        module_name.in_namespace(current_namespace)
       else
         module_name.absolute!
       end
@@ -2495,7 +2465,7 @@ module Steep
         typing.add_error Errors::FallbackAny.new(node: node)
       end
 
-      typing.add_typing node, Types.any
+      typing.add_typing node, AST::Builtin.any_type
     end
 
     def self_class?(node)
@@ -2614,5 +2584,54 @@ module Steep
         sub_type
       end
     end
+
+    def to_instance_type(type, args: nil)
+      args = args || case type
+                     when AST::Types::Name::Class
+                       checker.builder.signatures.find_class(type.name).params&.variables || []
+                     when AST::Types::Name::Module
+                       checker.builder.signatures.find_module(type.name).params&.variables || []
+                     end
+
+      AST::Types::Name::Instance.new(name: type.name, args: args)
+    end
+
+    def try_hash_type(node, hint)
+      if hint.is_a?(AST::Types::Hash)
+        typing.new_child do |child_typing|
+          new_construction = with_new_typing(child_typing)
+          elem_types = hint.elements.dup
+
+          each_child_node(node) do |child|
+            case child.type
+            when :pair
+              key, value = child.children
+
+              key_value = case key.type
+                          when :str, :int, :sym
+                            key.children[0]
+                          else
+                            return nil
+                          end
+
+              return nil unless elem_types.key?(key_value)
+
+              key_hint = AST::Types::Literal.new(value: key_value)
+              value_hint = elem_types.delete(key_value)
+
+              new_construction.check(key, key_hint) { return nil }
+              new_construction.check(value, value_hint) { return nil }
+            else
+              return nil
+            end
+          end
+
+          return nil unless elem_types.empty?
+
+          child_typing.save!
+          return typing.add_typing(node, hint)
+        end
+      end
+    end
   end
 end