rbs 0.2.0 → 0.6.0

data/lib/rbs/constant.rb

@@ -4,23 +4,23 @@ module RBS
     attr_reader :type
     attr_reader :declaration
 
-    def initialize(name:, type:, declaration:)
+    def initialize(name:, type:, entry:)
       @name = name
       @type = type
-      @declaration = declaration
+      @entry = entry
     end
 
     def ==(other)
       other.is_a?(Constant) &&
         other.name == name &&
         other.type == type &&
-        other.declaration == declaration
+        other.entry == entry
     end
 
     alias eql? ==
 
     def hash
-      self.class.hash ^ name.hash ^ type.hash ^ declaration.hash
+      self.class.hash ^ name.hash ^ type.hash ^ entry.hash
     end
   end
 end

data/lib/rbs/constant_table.rb

@@ -7,21 +7,34 @@ module RBS
       definition_builder.env
     end
 
+    def resolver
+      @resolver ||= TypeNameResolver.from_env(env)
+    end
+
     def initialize(builder:)
       @definition_builder = builder
       @constant_scopes_cache = {}
     end
 
+    def absolute_type(type, context:)
+      type.map_type_name do |type_name, location|
+        absolute_type_name(type_name, context: context, location: location)
+      end
+    end
+
+    def absolute_type_name(type_name, context:, location:)
+      resolver.resolve(type_name, context: context) or
+        raise NoTypeFoundError.new(type_name: type_name, location: location)
+    end
+
     def name_to_constant(name)
       case
-      when env.name_to_constant.key?(name)
-        decl = env.name_to_constant[name]
-        type = env.absolute_type(decl.type, namespace: name.namespace) {|type| type.name.absolute! }
-        Constant.new(name: name, type: type, declaration: decl)
-      when env.class?(name)
-        decl = env.name_to_decl[name]
+      when entry = env.constant_decls[name]
+        type = absolute_type(entry.decl.type, context: entry.context)
+        Constant.new(name: name, type: type, entry: entry)
+      when entry = env.class_decls[name]
         type = Types::ClassSingleton.new(name: name, location: nil)
-        Constant.new(name: name, type: type, declaration: decl)
+        Constant.new(name: name, type: type, entry: entry)
       end
     end
 
@@ -30,17 +43,18 @@ module RBS
     end
 
     def resolve_constant_reference(name, context:)
+      raise "Context cannot be empty: Specify `[Namespace.root]`" if context.empty?
+
       head, *tail = split_name(name)
 
       head_constant = case
                       when name.absolute?
                         name_to_constant(TypeName.new(name: head, namespace: Namespace.root))
-                      when !context || context.empty?
+                      when context == [Namespace.root]
                         name_to_constant(TypeName.new(name: head, namespace: Namespace.root))
                       else
                         resolve_constant_reference_context(head, context: context) ||
-                          resolve_constant_reference_inherit(head,
-                                                             scopes: constant_scopes(context.to_type_name))
+                          resolve_constant_reference_inherit(head, scopes: constant_scopes(context.first.to_type_name))
                       end
 
       if head_constant
@@ -53,11 +67,15 @@ module RBS
     end
 
     def resolve_constant_reference_context(name, context:)
-      if context.empty?
-        nil
-      else
-        name_to_constant(TypeName.new(name: name, namespace: context)) ||
-          resolve_constant_reference_context(name, context: context.parent)
+      head, *tail = context
+
+      if head
+        if head.path.last == name
+          name_to_constant(head.to_type_name)
+        else
+          name_to_constant(TypeName.new(name: name, namespace: head)) ||
+            resolve_constant_reference_context(name, context: tail)
+        end
       end
     end
 
@@ -83,14 +101,18 @@ module RBS
     end
 
     def constant_scopes_module(name, scopes:)
-      decl = env.find_class(name)
+      entry = env.class_decls[name]
       namespace = name.to_namespace
 
-      decl.members.each do |member|
-        case member
-        when AST::Members::Include
-          constant_scopes_module absolute_type_name(member.name, namespace: namespace),
-                                 scopes: scopes
+      entry.decls.each do |d|
+        d.decl.members.each do |member|
+          case member
+          when AST::Members::Include
+            if member.name.class?
+              constant_scopes_module absolute_type_name(member.name, context: d.context, location: member.location),
+                                     scopes: scopes
+            end
+          end
         end
       end
 
@@ -98,53 +120,42 @@ module RBS
     end
 
     def constant_scopes0(name, scopes: [])
-      decl = env.find_class(name)
+      entry = env.class_decls[name]
       namespace = name.to_namespace
 
-      case decl
-      when AST::Declarations::Module
-        constant_scopes0 BuiltinNames::Module.name, scopes: scopes
-        constant_scopes_module name, scopes: scopes
-
-      when AST::Declarations::Class
+      case entry
+      when Environment::ClassEntry
         unless name == BuiltinNames::BasicObject.name
-          super_name = decl.super_class&.yield_self {|super_class|
-            absolute_type_name(super_class.name, namespace: namespace)
-          } || BuiltinNames::Object.name
+          super_name = entry.primary.decl.super_class&.yield_self do |super_class|
+            absolute_type_name(super_class.name, context: entry.primary.context, location: entry.primary.decl.location)
+          end || BuiltinNames::Object.name
 
           constant_scopes0 super_name, scopes: scopes
         end
 
-        decl.members.each do |member|
-          case member
-          when AST::Members::Include
-            constant_scopes_module absolute_type_name(member.name, namespace: namespace),
-                                   scopes: scopes
+        entry.decls.each do |d|
+          d.decl.members.each do |member|
+            case member
+            when AST::Members::Include
+              if member.name.class?
+                constant_scopes_module absolute_type_name(member.name, context: d.context, location: member.location),
+                                       scopes: scopes
+              end
+            end
           end
         end
 
         scopes.unshift namespace
-      else
-        raise "Unexpected declaration: #{name}"
-      end
 
-      env.each_extension(name).sort_by {|e| e.extension_name.to_s }.each do |extension|
-        extension.members.each do |member|
-          case member
-          when AST::Members::Include
-            constant_scopes_module absolute_type_name(member.name, namespace: namespace),
-                                   scopes: []
-          end
-        end
+      when Environment::ModuleEntry
+        constant_scopes0 BuiltinNames::Module.name, scopes: scopes
+        constant_scopes_module name, scopes: scopes
+
+      else
+        raise "Unexpected declaration: #{name} (#{decl.class})"
       end
 
       scopes
     end
-
-    def absolute_type_name(name, namespace:)
-      env.absolute_type_name(name, namespace: namespace) do
-        raise
-      end
-    end
   end
 end

data/lib/rbs/definition.rb

@@ -10,27 +10,76 @@ module RBS
         @type = type
         @declared_in = declared_in
       end
+
+      def sub(s)
+        self.class.new(
+          parent_variable: parent_variable,
+          type: type.sub(s),
+          declared_in: declared_in
+        )
+      end
     end
 
     class Method
+      class TypeDef
+        attr_reader :type
+        attr_reader :member
+        attr_reader :defined_in
+        attr_reader :implemented_in
+
+        def initialize(type:, member:, defined_in:, implemented_in:)
+          @type = type
+          @member = member
+          @defined_in = defined_in
+          @implemented_in = implemented_in
+        end
+
+        def comment
+          member.comment
+        end
+
+        def annotations
+          member.annotations
+        end
+
+        def update(type: self.type, member: self.member, defined_in: self.defined_in, implemented_in: self.implemented_in)
+          TypeDef.new(type: type, member: member, defined_in: defined_in, implemented_in: implemented_in)
+        end
+      end
+
       attr_reader :super_method
-      attr_reader :method_types
-      attr_reader :defined_in
-      attr_reader :implemented_in
+      attr_reader :defs
       attr_reader :accessibility
-      attr_reader :attributes
-      attr_reader :annotations
-      attr_reader :comment
 
-      def initialize(super_method:, method_types:, defined_in:, implemented_in:, accessibility:, attributes:, annotations:, comment:)
+      def initialize(super_method:, defs:, accessibility:)
         @super_method = super_method
-        @method_types = method_types
-        @defined_in = defined_in
-        @implemented_in = implemented_in
+        @defs = defs
         @accessibility = accessibility
-        @attributes = attributes
-        @annotations = annotations
-        @comment = comment
+      end
+
+      def defined_in
+        @defined_in ||= defs.last.defined_in
+      end
+
+      def implemented_in
+        @implemented_in ||= defs.last.implemented_in
+      end
+
+      def method_types
+        @method_types ||= defs.map(&:type)
+      end
+
+      def comments
+        @comments ||= defs.map(&:comment).compact
+      end
+
+      def annotations
+        @annotations ||= defs.flat_map(&:annotations)
+      end
+
+      # @deprecated
+      def attributes
+        []
       end
 
       def public?
@@ -44,28 +93,24 @@ module RBS
       def sub(s)
         self.class.new(
           super_method: super_method&.sub(s),
-          method_types: method_types.map {|ty| ty.sub(s) },
-          defined_in: defined_in,
-          implemented_in: implemented_in,
-          accessibility: @accessibility,
-          attributes: attributes,
-          annotations: annotations,
-          comment: comment
+          defs: defs.map {|defn| defn.update(type: defn.type.sub(s)) },
+          accessibility: @accessibility
         )
       end
 
       def map_type(&block)
         self.class.new(
           super_method: super_method&.map_type(&block),
-          method_types: method_types.map do |ty|
-            ty.map_type(&block)
-          end,
-          defined_in: defined_in,
-          implemented_in: implemented_in,
-          accessibility: @accessibility,
-          attributes: attributes,
-          annotations: annotations,
-          comment: comment
+          defs: defs.map {|defn| defn.update(type: defn.type.map_type(&block)) },
+          accessibility: @accessibility
+        )
+      end
+
+      def map_method_type(&block)
+        self.class.new(
+          super_method: super_method,
+          defs: defs.map {|defn| defn.update(type: yield(defn.type)) },
+          accessibility: @accessibility
         )
       end
     end
@@ -73,78 +118,149 @@ module RBS
     module Ancestor
       Instance = Struct.new(:name, :args, keyword_init: true)
       Singleton = Struct.new(:name, keyword_init: true)
-      ExtensionInstance = Struct.new(:name, :extension_name, :args, keyword_init: true)
-      ExtensionSingleton = Struct.new(:name, :extension_name, keyword_init: true)
     end
 
-    attr_reader :declaration
+    class InstanceAncestors
+      attr_reader :type_name
+      attr_reader :params
+      attr_reader :ancestors
+
+      def initialize(type_name:, params:, ancestors:)
+        @type_name = type_name
+        @params = params
+        @ancestors = ancestors
+      end
+
+      def apply(args, location:)
+        InvalidTypeApplicationError.check!(
+          type_name: type_name,
+          args: args,
+          params: params,
+          location: location
+        )
+
+        subst = Substitution.build(params, args)
+
+        ancestors.map do |ancestor|
+          case ancestor
+          when Ancestor::Instance
+            if ancestor.args.empty?
+              ancestor
+            else
+              Ancestor::Instance.new(
+                name: ancestor.name,
+                args: ancestor.args.map {|type| type.sub(subst) }
+              )
+            end
+          when Ancestor::Singleton
+            ancestor
+          end
+        end
+      end
+    end
+
+    class SingletonAncestors
+      attr_reader :type_name
+      attr_reader :ancestors
+
+      def initialize(type_name:, ancestors:)
+        @type_name = type_name
+        @ancestors = ancestors
+      end
+    end
+
+    attr_reader :type_name
+    attr_reader :entry
+    attr_reader :ancestors
     attr_reader :self_type
     attr_reader :methods
     attr_reader :instance_variables
     attr_reader :class_variables
-    attr_reader :ancestors
 
-    def initialize(declaration:, self_type:, ancestors:)
-      unless declaration.is_a?(AST::Declarations::Class) ||
-        declaration.is_a?(AST::Declarations::Module) ||
-        declaration.is_a?(AST::Declarations::Interface) ||
-        declaration.is_a?(AST::Declarations::Extension)
-        raise "Declaration should be a class, module, or interface: #{declaration.name}"
+    def initialize(type_name:, entry:, self_type:, ancestors:)
+      case entry
+      when Environment::ClassEntry, Environment::ModuleEntry
+        # ok
+      else
+        unless entry.decl.is_a?(AST::Declarations::Interface)
+          raise "Declaration should be a class, module, or interface: #{type_name}"
+        end
       end
 
-      unless (self_type.is_a?(Types::ClassSingleton) || self_type.is_a?(Types::Interface) || self_type.is_a?(Types::ClassInstance)) && self_type.name == declaration.name.absolute!
+      unless self_type.is_a?(Types::ClassSingleton) || self_type.is_a?(Types::Interface) || self_type.is_a?(Types::ClassInstance)
         raise "self_type should be the type of declaration: #{self_type}"
       end
 
+      @type_name = type_name
       @self_type = self_type
-      @declaration = declaration
+      @entry = entry
       @methods = {}
       @instance_variables = {}
       @class_variables = {}
       @ancestors = ancestors
     end
 
-    def name
-      declaration.name
-    end
-
     def class?
-      declaration.is_a?(AST::Declarations::Class)
+      entry.is_a?(Environment::ClassEntry)
     end
 
     def module?
-      declaration.is_a?(AST::Declarations::Module)
+      entry.is_a?(Environment::ModuleEntry)
+    end
+
+    def interface?
+      entry.is_a?(Environment::SingleEntry) && entry.decl.is_a?(AST::Declarations::Interface)
     end
 
     def class_type?
-      @self_type.is_a?(Types::ClassSingleton)
+      self_type.is_a?(Types::ClassSingleton)
     end
 
     def instance_type?
-      @self_type.is_a?(Types::ClassInstance)
+      self_type.is_a?(Types::ClassInstance)
     end
 
     def interface_type?
-      @self_type.is_a?(Types::Interface)
+      self_type.is_a?(Types::Interface)
     end
 
     def type_params
-      @self_type.args.map(&:name)
+      type_params_decl.each.map(&:name)
     end
 
     def type_params_decl
-      case declaration
-      when AST::Declarations::Extension
-        nil
-      else
-        declaration.type_params
+      case entry
+      when Environment::ClassEntry, Environment::ModuleEntry
+        entry.type_params
+      when Environment::SingleEntry
+        entry.decl.type_params
       end
     end
 
+    def sub(s)
+      definition = self.class.new(type_name: type_name, self_type: self_type.sub(s), ancestors: ancestors, entry: entry)
+
+      definition.methods.merge!(methods.transform_values {|method| method.sub(s) })
+      definition.instance_variables.merge!(instance_variables.transform_values {|v| v.sub(s) })
+      definition.class_variables.merge!(class_variables.transform_values {|v| v.sub(s) })
+
+      definition
+    end
+
+    def map_method_type(&block)
+      definition = self.class.new(type_name: type_name, self_type: self_type, ancestors: ancestors, entry: entry)
+
+      definition.methods.merge!(methods.transform_values {|method| method.map_method_type(&block) })
+      definition.instance_variables.merge!(instance_variables)
+      definition.class_variables.merge!(class_variables)
+
+      definition
+    end
+
     def each_type(&block)
       if block_given?
         methods.each_value do |method|
-          if method.defined_in == self.declaration
+          if method.defined_in == type_name
             method.method_types.each do |method_type|
               method_type.each_type(&block)
             end
@@ -152,13 +268,13 @@ module RBS
         end
 
         instance_variables.each_value do |var|
-          if var.declared_in == self.declaration
+          if var.declared_in == type_name
             yield var.type
           end
         end
 
         class_variables.each_value do |var|
-          if var.declared_in == self.declaration
+          if var.declared_in == type_name
             yield var.type
           end
         end