rbs-relaxed 3.9.0.1

data/lib/rbs/type_alias_dependency.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module RBS
+  class TypeAliasDependency
+    attr_reader :env
+
+    # Direct dependencies corresponds to a directed graph
+    # with vertices as types and directions based on assignment of types
+    attr_reader :direct_dependencies
+    # A hash which stores the transitive closure
+    # of the directed graph
+    attr_reader :dependencies
+
+    def initialize(env:)
+      @env = env
+    end
+
+    # Check if an alias type definition is circular & prohibited
+    def circular_definition?(alias_name)
+      # Construct transitive closure, if not constructed already
+      transitive_closure() unless @dependencies
+
+      alias_name = env.normalize_type_name!(alias_name)
+      @dependencies[alias_name][alias_name]
+    end
+
+    def build_dependencies
+      return if @direct_dependencies
+
+      # Initialize hash(a directed graph)
+      @direct_dependencies = {}
+      # Initialize dependencies as an empty hash
+      @dependencies = {}
+      # Iterate over alias declarations inserted into environment
+      env.type_alias_decls.each do |name, entry|
+        # Construct a directed graph by recursively extracting type aliases
+        @direct_dependencies[name] = direct_dependency(entry.decl.type)
+        # Initialize dependencies with an empty hash
+        @dependencies[name] = {}
+      end
+    end
+
+    def transitive_closure
+      # Construct a graph of direct dependencies
+      build_dependencies()
+      # Construct transitive closure by using DFS(recursive technique)
+      @direct_dependencies.each_key do |name|
+        dependency(name, name)
+      end
+    end
+
+    def direct_dependencies_of(name)
+      name = env.normalize_type_name!(name)
+      @direct_dependencies[name]
+    end
+
+    def dependencies_of(name)
+      name = env.normalize_type_name!(name)
+      @dependencies[name].each_key.to_set
+    end
+
+    private
+
+    # Constructs directed graph recursively
+    def direct_dependency(type, result = Set[])
+      case type
+      when RBS::Types::Union, RBS::Types::Intersection, RBS::Types::Optional
+        # Iterate over nested types & extract type aliases recursively
+        type.each_type do |nested_type|
+          direct_dependency(nested_type, result)
+        end
+      when RBS::Types::Alias
+        # Append type name if the type is an alias
+        result << env.normalize_type_name(type.name)
+      end
+
+      result
+    end
+
+    # Recursive function to construct transitive closure
+    def dependency(start, vertex, nested = nil)
+      if (start == vertex)
+        if (@direct_dependencies[start].include?(vertex) || nested)
+          # Mark a vertex as connected to itself
+          # if it is connected as an edge || a path(traverse multiple edges)
+          @dependencies[start][vertex] = true
+        end
+      else
+        # Mark a pair of vertices as connected while recursively performing DFS
+        @dependencies[start][vertex] = true
+      end
+
+      # Iterate over the direct dependencies of the vertex
+      @direct_dependencies[vertex]&.each do |type_name|
+        # Invoke the function unless it is already checked
+        dependency(start, type_name, start == type_name) unless @dependencies[start][type_name]
+      end
+    end
+  end
+end

data/lib/rbs/type_alias_regularity.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module RBS
+  class TypeAliasRegularity
+    class Diagnostic
+      attr_reader :type_name, :nonregular_type
+
+      def initialize(type_name:, nonregular_type:)
+        @type_name = type_name
+        @nonregular_type = nonregular_type
+      end
+    end
+
+    attr_reader :env, :builder, :diagnostics
+
+    def initialize(env:)
+      @env = env
+      @builder = DefinitionBuilder.new(env: env)
+      @diagnostics = {}
+    end
+
+    def validate
+      diagnostics.clear
+
+      each_mutual_alias_defs do |names|
+        # Find the first generic type alias in strongly connected component.
+        # This is to skip the regularity check when the alias is not generic.
+        names.each do |name|
+          # @type break: nil
+          if type = build_alias_type(name)
+            # Running validation only once from the first generic type is enough, because they are mutual recursive definition.
+            validate_alias_type(type, names, {})
+            break
+          end
+        end
+      end
+    end
+
+    def validate_alias_type(alias_type, names, types)
+      alias_name = env.normalize_type_name?(alias_type.name) or return
+
+      if names.include?(alias_name)
+        if ex_type = types[alias_name]
+          unless compatible_args?(ex_type.args, alias_type.args)
+            diagnostics[alias_name] ||=
+              Diagnostic.new(type_name: alias_type.name, nonregular_type: alias_type)
+          end
+
+          return
+        else
+          types[alias_type.name] = alias_type
+        end
+
+        expanded = builder.expand_alias2(alias_name, alias_type.args)
+        each_alias_type(expanded) do |at|
+          validate_alias_type(at, names, types)
+        end
+      end
+    end
+
+    def build_alias_type(name)
+      entry = env.type_alias_decls[name] or return
+      unless entry.decl.type_params.empty?
+        as = entry.decl.type_params.each.map {|param| Types::Variable.new(name: param.name, location: nil) }
+        Types::Alias.new(name: name, args: as, location: nil)
+      end
+    end
+
+    def compatible_args?(args1, args2)
+      if args1.size == args2.size
+        args1.zip(args2).all? do |t1, t2|
+          t1.is_a?(Types::Bases::Any) ||
+            t2.is_a?(Types::Bases::Any) ||
+            t1 == t2
+        end
+      end
+    end
+
+    def nonregular?(type_name)
+      diagnostics[env.normalize_type_name!(type_name)]
+    end
+
+    def each_mutual_alias_defs(&block)
+      # @type var each_node: ^() { (TypeName) -> void } -> void
+      each_node = -> (&block) do
+        env.type_alias_decls.each_value do |decl|
+          if normalized = env.normalize_type_name?(decl.name)
+            block[normalized]
+          end
+        end
+      end
+
+      # @type var each_child: ^(TypeName) { (TypeName) -> void } -> void
+      each_child = -> (name, &block) do
+        if env.type_alias_decls.key?(name)
+          type = builder.expand_alias1(name)
+          each_alias_type(type) do |ty|
+            if normalized = env.normalize_type_name?(ty.name)
+              block[normalized]
+            end
+          end
+        end
+      end
+
+      TSort.each_strongly_connected_component(each_node, each_child) do |names|
+        yield Set.new(names)
+      end
+    end
+
+    def each_alias_type(type, &block)
+      if type.is_a?(RBS::Types::Alias)
+        yield type
+      end
+
+      type.each_type do |ty|
+        each_alias_type(ty, &block)
+      end
+    end
+
+    def self.validate(env:)
+      self.new(env: env).tap do |validator|
+        validator.validate()
+      end
+    end
+  end
+end

data/lib/rbs/type_name.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module RBS
+  class TypeName
+    attr_reader :namespace
+    attr_reader :name
+    attr_reader :kind
+
+    def initialize(namespace:, name:)
+      @namespace = namespace
+      @name = name
+      @kind = case
+              when name.match?(/\A[A-Z]/)
+                :class
+              when name.match?(/\A[a-z]/)
+                :alias
+              when name.start_with?("_")
+                :interface
+              else
+                # Defaults to :class
+                :class
+              end
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && other.namespace == namespace && other.name == name
+    end
+
+    alias eql? ==
+
+    def hash
+      namespace.hash ^ name.hash
+    end
+
+    def to_s
+      "#{namespace.to_s}#{name}"
+    end
+
+    def to_json(state = _ = nil)
+      to_s.to_json(state)
+    end
+
+    def to_namespace
+      namespace.append(self.name)
+    end
+
+    def class?
+      kind == :class
+    end
+
+    def alias?
+      kind == :alias
+    end
+
+    def absolute!
+      self.class.new(namespace: namespace.absolute!, name: name)
+    end
+
+    def absolute?
+      namespace.absolute?
+    end
+
+    def relative!
+      self.class.new(namespace: namespace.relative!, name: name)
+    end
+
+    def interface?
+      kind == :interface
+    end
+
+    def with_prefix(namespace)
+      self.class.new(namespace: namespace + self.namespace, name: name)
+    end
+
+    def split
+      namespace.path + [name]
+    end
+
+    def +(other)
+      if other.absolute?
+        other
+      else
+        TypeName.new(
+          namespace: self.to_namespace + other.namespace,
+          name: other.name
+        )
+      end
+    end
+    
+    def self.parse(string)
+      absolute = string.start_with?("::")
+
+      *path, name = string.delete_prefix("::").split("::").map(&:to_sym)
+      raise unless name
+
+      TypeName.new(
+        name: name,
+        namespace: RBS::Namespace.new(path: path, absolute: absolute)
+      )
+    end
+  end
+end
+
+module Kernel
+  def TypeName(string)
+    warn "Kernel#TypeName() is deprecated. Use RBS::TypeName.parse instead.", category: :deprecated
+    RBS::TypeName.parse(string)
+  end
+end