Class: Yoda::Typing::Types::Converter

Inherits:
Object
  • Object
show all
Defined in:
lib/yoda/typing/types/converter.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(generator, self_type: nil) ⇒ Converter

Returns a new instance of Converter.



11
12
13
14
 
# File 'lib/yoda/typing/types/converter.rb', line 11

def initialize(generator, self_type: nil)
  @generator = generator
  @self_type = self_type
end

Instance Attribute Details

#generator ⇒ Generator (readonly)

Returns:



6
7
8
 
# File 'lib/yoda/typing/types/converter.rb', line 6

def generator
  @generator
end

#self_type ⇒ Types::Base? (readonly)

Returns:



9
10
11
 
# File 'lib/yoda/typing/types/converter.rb', line 9

def self_type
  @self_type
end

Instance Method Details

#convert_from_expression(type_expression) ⇒ Base

Parameters:

Returns:



18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
# File 'lib/yoda/typing/types/converter.rb', line 18

def convert_from_expression(type_expression)
  case type_expression
  when Model::TypeExpressions::AnyType, Model::TypeExpressions::UnknownType
    Any.new
  when Model::TypeExpressions::InstanceType
    Instance.new(
      klass: generator.find_or_build(type_expression.path),
    )
  when Model::TypeExpressions::ModuleType
    is_class = %i(class meta_class).include?(generator.find(type_expression.path)&.kind)
    Instance.new(
      klass: generator.find_or_build_meta_class(type_expression.path),
    )
  when Model::TypeExpressions::SequenceType
    # @todo Implement sequence type
    generator.array_type
  when Model::TypeExpressions::DuckType
    # @todo Implement duck type
    generator.any_type
  when Model::TypeExpressions::SelfType
    self_type || generator.any_type
  when Model::TypeExpressions::ValueType
    value_class = type_expression.value_class
    value_class ? Instance.new(klass: generator.find_or_build(value_class)) : generator.any_type
  when Model::TypeExpressions::UnionType
    Union.new(*type_expression.types.map(&method(:convert_from_expression)))
  when Model::TypeExpressions::GenericType
    Generic.new(
      base: convert_from_expression(type_expression.base_type),
      type_args: type_expression.type_arguments.map(&method(:convert_from_expression)),
    )
  when Model::TypeExpressions::FunctionType
    Function.new(
      context: type_expression.context && convert_from_expression(type_expression.context),
      return_type: convert_from_expression(type_expression.return_type),
      parameters: type_expression.required_parameters.map(&:type).map(&method(:convert_from_expression)),
      rest_parameter: type_expression.rest_parameter && convert_from_expression(type_expression.rest_parameter.type),
      post_parameters: type_expression.post_parameters.map(&:type).map(&method(:convert_from_expression)),
      keyword_parameters: (type_expression.required_keyword_parameters + type_expression.optional_keyword_parameters).map { |param| [param.name, convert_from_expression(param.type)] },
      keyword_rest_parameter: type_expression.keyword_rest_parameter && convert_from_expression(type_expression.keyword_rest_parameter.type),
      block_parameter: type_expression.block_parameter && convert_from_expression(type_expression.block_parameter.type),
    )
  else
    fail ArgumentError, type_expression
  end
end