class RBS::TypeAliasDependency - rbs: Ruby Standard Library Documentation

# class RBS::TypeAliasDependency

### Attributes

dependencies[R]

A hash which stores the transitive closure of the directed graph

direct_dependencies[R]

Direct dependencies corresponds to a directed graph with vertices as types and directions based on assignment of types

env[R]

### Public Class Methods

new(env:) click to toggle source

    # File rbs-3.8.0/lib/rbs/type_alias_dependency.rb, line 14
    def initialize(env:)
      @env = env
    end

### Public Instance Methods

build_dependencies() click to toggle source

    # File rbs-3.8.0/lib/rbs/type_alias_dependency.rb, line 27
    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

circular_definition?(alias_name) click to toggle source

Check if an alias type definition is circular & prohibited

    # File rbs-3.8.0/lib/rbs/type_alias_dependency.rb, line 19
    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

dependencies_of(name) click to toggle source

    # File rbs-3.8.0/lib/rbs/type_alias_dependency.rb, line 57
    def dependencies_of(name)
      name = env.normalize_type_name!(name)
      @dependencies[name].each_key.to_set
    end

direct_dependencies_of(name) click to toggle source

    # File rbs-3.8.0/lib/rbs/type_alias_dependency.rb, line 52
    def direct_dependencies_of(name)
      name = env.normalize_type_name!(name)
      @direct_dependencies[name]
    end

transitive_closure() click to toggle source

    # File rbs-3.8.0/lib/rbs/type_alias_dependency.rb, line 43
    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

### Private Instance Methods

dependency(start, vertex, nested = nil) click to toggle source

Recursive function to construct transitive closure

    # File rbs-3.8.0/lib/rbs/type_alias_dependency.rb, line 81
    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

direct_dependency(type, result = Set[]) click to toggle source

Constructs directed graph recursively

    # File rbs-3.8.0/lib/rbs/type_alias_dependency.rb, line 65
    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