Let environment use Resolver::context directly

Author: soutaro

lib/rbs/environment.rb

@@ -13,29 +13,8 @@ class Environment
 
     attr_reader :signatures
 
-    module ContextUtil
-      def calculate_context(decls)
-        decls.inject(nil) do |context, decl| #$ Resolver::context
-          if (_, last = context)
-            last or raise
-            [context, last + decl.name]
-          else
-            [nil, decl.name.absolute!]
-          end
-        end
-      end
-    end
-
     class MultiEntry
-      D = _ = Struct.new(:decl, :outer, keyword_init: true) do
-        # @implements D[M]
-
-        include ContextUtil
-
-        def context
-          @context ||= calculate_context(outer + [decl])
-        end
-      end
+      D = _ = Struct.new(:decl, :context, keyword_init: true)
 
       attr_reader :name
       attr_reader :decls
@@ -45,8 +24,8 @@ def initialize(name:)
         @decls = []
       end
 
-      def insert(decl:, outer:)
-        decls << D.new(decl: decl, outer: outer)
+      def insert(decl:, context:)
+        decls << D.new(decl: decl, context: context)
         @primary = nil
       end
 
@@ -108,19 +87,13 @@ def primary
 
     class SingleEntry
       attr_reader :name
-      attr_reader :outer
+      attr_reader :context
       attr_reader :decl
 
-      def initialize(name:, decl:, outer:)
+      def initialize(name:, decl:, context:)
         @name = name
         @decl = decl
-        @outer = outer
-      end
-
-      include ContextUtil
-
-      def context
-        @context ||= calculate_context(outer)
+        @context = context
       end
     end
 
@@ -370,7 +343,7 @@ def normalize_module_name?(name)
       @normalize_module_name_cache[name] = normalized_type_name
     end
 
-    def insert_decl(decl, outer:, namespace:)
+    def insert_decl(decl, context:, namespace:)
       case decl
       when AST::Declarations::Class, AST::Declarations::Module
         name = decl.name.with_prefix(namespace)
@@ -394,17 +367,17 @@ def insert_decl(decl, outer:, namespace:)
 
         case
         when decl.is_a?(AST::Declarations::Module) && existing_entry.is_a?(ModuleEntry)
-          existing_entry.insert(decl: decl, outer: outer)
+          existing_entry.insert(decl: decl, context: context)
         when decl.is_a?(AST::Declarations::Class) && existing_entry.is_a?(ClassEntry)
-          existing_entry.insert(decl: decl, outer: outer)
+          existing_entry.insert(decl: decl, context: context)
         else
           raise DuplicatedDeclarationError.new(name, decl, existing_entry.decls[0].decl)
         end
 
-        prefix = outer + [decl]
-        ns = name.to_namespace
+        inner_context = [context, name] #: Resolver::context
+        inner_namespace = name.to_namespace
         decl.each_decl do |d|
-          insert_decl(d, outer: prefix, namespace: ns)
+          insert_decl(d, context: inner_context, namespace: inner_namespace)
         end
 
       when AST::Declarations::Interface
@@ -414,7 +387,7 @@ def insert_decl(decl, outer:, namespace:)
           raise DuplicatedDeclarationError.new(name, decl, interface_entry.decl)
         end
 
-        interface_decls[name] = InterfaceEntry.new(name: name, decl: decl, outer: outer)
+        interface_decls[name] = InterfaceEntry.new(name: name, decl: decl, context: context)
 
       when AST::Declarations::TypeAlias
         name = decl.name.with_prefix(namespace)
@@ -423,7 +396,7 @@ def insert_decl(decl, outer:, namespace:)
           raise DuplicatedDeclarationError.new(name, decl, entry.decl)
         end
 
-        type_alias_decls[name] = TypeAliasEntry.new(name: name, decl: decl, outer: outer)
+        type_alias_decls[name] = TypeAliasEntry.new(name: name, decl: decl, context: context)
 
       when AST::Declarations::Constant
         name = decl.name.with_prefix(namespace)
@@ -437,14 +410,14 @@ def insert_decl(decl, outer:, namespace:)
           end
         end
 
-        constant_decls[name] = ConstantEntry.new(name: name, decl: decl, outer: outer)
+        constant_decls[name] = ConstantEntry.new(name: name, decl: decl, context: context)
 
       when AST::Declarations::Global
         if entry = global_decls[decl.name]
           raise DuplicatedDeclarationError.new(decl.name, decl, entry.decl)
         end
 
-        global_decls[decl.name] = GlobalEntry.new(name: decl.name, decl: decl, outer: outer)
+        global_decls[decl.name] = GlobalEntry.new(name: decl.name, decl: decl, context: context)
 
       when AST::Declarations::ClassAlias, AST::Declarations::ModuleAlias
         name = decl.new_name.with_prefix(namespace)
@@ -460,16 +433,16 @@ def insert_decl(decl, outer:, namespace:)
 
         case decl
         when AST::Declarations::ClassAlias
-          class_alias_decls[name] = ClassAliasEntry.new(name: name, decl: decl, outer: outer)
+          class_alias_decls[name] = ClassAliasEntry.new(name: name, decl: decl, context: context)
         when AST::Declarations::ModuleAlias
-          class_alias_decls[name] = ModuleAliasEntry.new(name: name, decl: decl, outer: outer)
+          class_alias_decls[name] = ModuleAliasEntry.new(name: name, decl: decl, context: context)
         end
       end
     end
 
     def <<(decl)
       declarations << decl
-      insert_decl(decl, outer: [], namespace: Namespace.root)
+      insert_decl(decl, context: nil, namespace: Namespace.root)
       self
     end
 
@@ -501,7 +474,7 @@ def resolve_signature(resolver, table, dirs, decls, only: nil)
         if only && !only.member?(decl)
           decl
         else
-          resolve_declaration(resolver, map, decl, outer: [], prefix: Namespace.root)
+          resolve_declaration(resolver, map, decl, context: nil, prefix: Namespace.root)
         end
       end
 
@@ -545,7 +518,7 @@ def append_context(context, decl)
       end
     end
 
-    def resolve_declaration(resolver, map, decl, outer:, prefix:)
+    def resolve_declaration(resolver, map, decl, context:, prefix:)
       if decl.is_a?(AST::Declarations::Global)
         # @type var decl: AST::Declarations::Global
         return AST::Declarations::Global.new(
@@ -557,14 +530,11 @@ def resolve_declaration(resolver, map, decl, outer:, prefix:)
         )
       end
 
-      context = resolver_context(*outer)
-
       case decl
       when AST::Declarations::Class
         outer_context = context
         inner_context = append_context(outer_context, decl)
 
-        outer_ = outer + [decl]
         prefix_ = prefix + decl.name.to_namespace
         AST::Declarations::Class.new(
           name: decl.name.with_prefix(prefix),
@@ -585,7 +555,7 @@ def resolve_declaration(resolver, map, decl, outer:, prefix:)
                 resolver,
                 map,
                 member,
-                outer: outer_,
+                context: inner_context,
                 prefix: prefix_
               )
             else
@@ -601,7 +571,6 @@ def resolve_declaration(resolver, map, decl, outer:, prefix:)
         outer_context = context
         inner_context = append_context(outer_context, decl)
 
-        outer_ = outer + [decl]
         prefix_ = prefix + decl.name.to_namespace
         AST::Declarations::Module.new(
           name: decl.name.with_prefix(prefix),
@@ -622,7 +591,7 @@ def resolve_declaration(resolver, map, decl, outer:, prefix:)
                 resolver,
                 map,
                 member,
-                outer: outer_,
+                context: inner_context,
                 prefix: prefix_
               )
             else

sig/environment.rbs

@@ -12,24 +12,14 @@ module RBS
       def name: () -> TypeName
     end
 
-    module ContextUtil
-      def calculate_context: (Array[_NamedDecl]) -> Resolver::context
-    end
-
     # Name of object, it's (multiple) declarations with the outer module declarations
     #
     class MultiEntry[M < _ModuleOrClass]
       class D[M < _ModuleOrClass]
         attr_reader decl: M
-        attr_reader outer: Array[module_decl]
-
-        def initialize: (decl: M, outer: Array[module_decl]) -> void
-
-        include ContextUtil
+        attr_reader context: Resolver::context
 
-        @context: Resolver::context
-
-        def context: () -> Resolver::context
+        def initialize: (decl: M, context: Resolver::context) -> void
       end
 
       attr_reader name: TypeName
@@ -39,7 +29,7 @@ module RBS
 
       def initialize: (name: TypeName) -> void
 
-      def insert: (decl: M, outer: Array[module_decl]) -> void
+      def insert: (decl: M, context: Resolver::context) -> void
 
       def validate_type_params: () -> void
 
@@ -62,15 +52,9 @@ module RBS
     class SingleEntry[N, D]
       attr_reader name: N
       attr_reader decl: D
-      attr_reader outer: Array[module_decl]
-
-      def initialize: (name: N, decl: D, outer: Array[module_decl]) -> void
-
-      include ContextUtil
-
-      @context: Resolver::context
+      attr_reader context: Resolver::context
 
-      def context: () -> Resolver::context
+      def initialize: (name: N, decl: D, context: Resolver::context) -> void
     end
 
     class ModuleAliasEntry < SingleEntry[TypeName, AST::Declarations::ModuleAlias]
@@ -131,7 +115,7 @@ module RBS
 
     # Insert a declaration into the environment
     #
-    private def insert_decl: (AST::Declarations::t, outer: Array[module_decl], namespace: Namespace) -> void
+    private def insert_decl: (AST::Declarations::t, context: Resolver::context, namespace: Namespace) -> void
 
     # Resolve all type names in the environment to absolute type names.
     # Relative type name will be left if absolute type name cannot be found.
@@ -264,7 +248,7 @@ module RBS
 
     def append_context: (Resolver::context, module_decl) -> Resolver::context
 
-    def resolve_declaration: (Resolver::TypeNameResolver resolver, UseMap map, AST::Declarations::t decl, outer: Array[module_decl], prefix: Namespace) -> AST::Declarations::t
+    def resolve_declaration: (Resolver::TypeNameResolver resolver, UseMap map, AST::Declarations::t decl, context: Resolver::context, prefix: Namespace) -> AST::Declarations::t
 
     def resolve_member: (Resolver::TypeNameResolver, UseMap map, AST::Members::t, context: Resolver::context) -> AST::Members::t
 

test/rbs/environment_test.rb

@@ -7,29 +7,6 @@ class RBS::EnvironmentTest < Test::Unit::TestCase
   Namespace = RBS::Namespace
   InvalidTypeApplicationError = RBS::InvalidTypeApplicationError
 
-  def test_entry_context
-    _, _, decls = RBS::Parser.parse_signature(<<EOF)
-class Foo
-  module Bar
-    module Baz
-    end
-  end
-end
-EOF
-
-    entry = Environment::SingleEntry.new(
-      name: type_name("::Foo::Bar::Baz"),
-      decl: decls[0].members[0].members[0],
-      outer: [
-        decls[0],
-        decls[0].members[0],
-      ]
-    )
-
-    assert_equal [[nil, type_name("::Foo")], type_name("::Foo::Bar")],
-                 entry.context
-  end
-
   def test_insert_decl_nested_modules
     env = Environment.new
 
@@ -248,24 +225,24 @@ module Foo[X, in Y]
 EOF
 
     Environment::ModuleEntry.new(name: type_name("::Foo")).tap do |entry|
-      entry.insert(decl: decls[0], outer: [])
-      entry.insert(decl: decls[1], outer: [])
+      entry.insert(decl: decls[0], context: nil)
+      entry.insert(decl: decls[1], context: nil)
 
       assert_instance_of Array, entry.type_params
     end
 
     Environment::ModuleEntry.new(name: type_name("::Foo")).tap do |entry|
-      entry.insert(decl: decls[0], outer: [])
-      entry.insert(decl: decls[2], outer: [])
+      entry.insert(decl: decls[0], context: nil)
+      entry.insert(decl: decls[2], context: nil)
 
       assert_raises RBS::GenericParameterMismatchError do
         entry.type_params
       end
     end
 
     Environment::ModuleEntry.new(name: type_name("::Foo")).tap do |entry|
-      entry.insert(decl: decls[0], outer: [])
-      entry.insert(decl: decls[3], outer: [])
+      entry.insert(decl: decls[0], context: nil)
+      entry.insert(decl: decls[3], context: nil)
 
       assert_raises RBS::GenericParameterMismatchError do
         entry.type_params