Class: RBS::Definition

Inherits:

Object

• Object
• RBS::Definition

Defined in:

lib/rbs/definition.rb,
sig/definition.rbs

Defined Under Namespace

Classes: InstanceAncestors, Method, SingletonAncestors, Variable

Constant Summary

Ancestor =

Returns:

• (:Instance,)

Instance Attribute Summary

• #ancestors ⇒ InstanceAncestors, ... readonly

  Returns the value of attribute ancestors.

• #class_variables ⇒ Hash[Symbol, Variable] readonly

  Returns the value of attribute class_variables.

• #entry ⇒ definition_entry readonly

  Returns the value of attribute entry.

• #instance_variables ⇒ Hash[Symbol, Variable] readonly

  Returns the value of attribute instance_variables.

• #methods ⇒ Hash[Symbol, Method] readonly

  Returns the value of attribute methods.

• #self_type ⇒ self_type readonly

  Returns the value of attribute self_type.

• #type_name ⇒ TypeName readonly

  Returns the value of attribute type_name.

Instance Method Summary

• #class? ⇒ Boolean
• #class_type? ⇒ Boolean
• #each_type {|arg0| ... } ⇒ Object
• #initialize(type_name:, entry:, self_type:, ancestors:) ⇒ Definition constructor

  A new instance of Definition.

• #instance_type? ⇒ Boolean
• #interface? ⇒ Boolean
• #interface_type? ⇒ Boolean
• #map_method_type {|arg0| ... } ⇒ Definition
• #module? ⇒ Boolean
• #sub(s) ⇒ Definition
• #type_params ⇒ Array[Symbol]
• #type_params_decl ⇒ Array[AST::TypeParam]

Constructor Details

#initialize(type_name:, entry:, self_type:, ancestors:) ⇒ Definition

Returns a new instance of Definition.

Parameters:

• type_name: (TypeName)
• entry: (definition_entry)
• self_type: (self_type)
• ancestors: (InstanceAncestors, SingletonAncestors, nil)

# File 'lib/rbs/definition.rb', line 302

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)
    raise "self_type should be the type of declaration: #{self_type}"
  end

  @type_name = type_name
  @self_type = self_type
  @entry = entry
  @methods = {}
  @instance_variables = {}
  @class_variables = {}
  @ancestors = ancestors
end

Instance Attribute Details

#ancestors ⇒ InstanceAncestors, ... (readonly)

Returns the value of attribute ancestors.

Returns:

• (InstanceAncestors, SingletonAncestors, nil)

# File 'lib/rbs/definition.rb', line 296

def ancestors
  @ancestors
end

#class_variables ⇒ Hash[Symbol, Variable] (readonly)

Returns the value of attribute class_variables.

Returns:

• (Hash[Symbol, Variable])

# File 'lib/rbs/definition.rb', line 300

def class_variables
  @class_variables
end

#entry ⇒ definition_entry (readonly)

Returns the value of attribute entry.

Returns:

• (definition_entry)

# File 'lib/rbs/definition.rb', line 295

def entry
  @entry
end

#instance_variables ⇒ Hash[Symbol, Variable] (readonly)

Returns the value of attribute instance_variables.

Returns:

• (Hash[Symbol, Variable])

# File 'lib/rbs/definition.rb', line 299

def instance_variables
  @instance_variables
end

#methods ⇒ Hash[Symbol, Method] (readonly)

Returns the value of attribute methods.

Returns:

• (Hash[Symbol, Method])

# File 'lib/rbs/definition.rb', line 298

def methods
  @methods
end

#self_type ⇒ self_type (readonly)

Returns the value of attribute self_type.

Returns:

• (self_type)

# File 'lib/rbs/definition.rb', line 297

def self_type
  @self_type
end

#type_name ⇒ TypeName (readonly)

Returns the value of attribute type_name.

Returns:

• (TypeName)

# File 'lib/rbs/definition.rb', line 294

def type_name
  @type_name
end

Instance Method Details

#class? ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/rbs/definition.rb', line 325

def class?
  entry.is_a?(Environment::ClassEntry)
end

#class_type? ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/rbs/definition.rb', line 342

def class_type?
  self_type.is_a?(Types::ClassSingleton)
end

#each_type ⇒ void #each_type ⇒ Enumerator[Types::t, void]

Overloads:

• #each_type ⇒ void

  This method returns an undefined value.
• #each_type ⇒ Enumerator[Types::t, void]

  Returns:

  • (Enumerator[Types::t, void])

Yields:

Yield Parameters:

• arg0 (Types::t)

Yield Returns:

• (void)

# File 'lib/rbs/definition.rb', line 389

def each_type(&block)
  if block
    methods.each_value do |method|
      if method.defined_in == type_name
        method.method_types.each do |method_type|
          method_type.each_type(&block)
        end
      end
    end

    instance_variables.each_value do |var|
      if var.declared_in == type_name
        yield var.type
      end
    end

    class_variables.each_value do |var|
      if var.declared_in == type_name
        yield var.type
      end
    end
  else
    enum_for :each_type
  end
end

#instance_type? ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/rbs/definition.rb', line 346

def instance_type?
  self_type.is_a?(Types::ClassInstance)
end

#interface? ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/rbs/definition.rb', line 333

def interface?
  case en = entry
  when Environment::SingleEntry
    en.decl.is_a?(AST::Declarations::Interface)
  else
    false
  end
end

#interface_type? ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/rbs/definition.rb', line 350

def interface_type?
  self_type.is_a?(Types::Interface)
end

#map_method_type {|arg0| ... } ⇒ Definition

Yields:

Yield Parameters:

• arg0 (MethodType)

Yield Returns:

• (MethodType)

Returns:

• (Definition)

# File 'lib/rbs/definition.rb', line 379

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

#module? ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/rbs/definition.rb', line 329

def module?
  entry.is_a?(Environment::ModuleEntry)
end

#sub(s) ⇒ Definition

Parameters:

• (Substitution)

Returns:

• (Definition)

# File 'lib/rbs/definition.rb', line 367

def sub(s)
  return self if s.empty?

  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

#type_params ⇒ Array[Symbol]

Returns:

• (Array[Symbol])

# File 'lib/rbs/definition.rb', line 354

def type_params
  type_params_decl.each.map(&:name)
end

#type_params_decl ⇒ Array[AST::TypeParam]

Returns:

• (Array[AST::TypeParam])

# File 'lib/rbs/definition.rb', line 358

def type_params_decl
  case en = entry
  when Environment::ClassEntry, Environment::ModuleEntry
    en.type_params
  when Environment::SingleEntry
    en.decl.type_params
  end
end