Class: RBS::Validator

Inherits:
Object
  • Object
show all
Defined in:
lib/rbs/validator.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(env:, resolver:) ⇒ Validator

Returns a new instance of Validator.



6
7
8
9
 
# File 'lib/rbs/validator.rb', line 6

def initialize(env:, resolver:)
  @env = env
  @resolver = resolver
end

Instance Attribute Details

#env ⇒ Object (readonly)

Returns the value of attribute env.



3
4
5
 
# File 'lib/rbs/validator.rb', line 3

def env
  @env
end

#resolver ⇒ Object (readonly)

Returns the value of attribute resolver.



4
5
6
 
# File 'lib/rbs/validator.rb', line 4

def resolver
  @resolver
end

Instance Method Details

#absolute_type(type, context:) ⇒ Object 



11
12
13
14
15
 
# File 'lib/rbs/validator.rb', line 11

def absolute_type(type, context:)
  type.map_type_name do |type_name, _, type|
    resolver.resolve(type_name, context: context) || yield(type)
  end
end

#validate_type(type, context:) ⇒ Object

Validates presence of the relative type, and application arity match.



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
 
# File 'lib/rbs/validator.rb', line 18

def validate_type(type, context:)
  case type
  when Types::ClassInstance, Types::Interface
    # @type var type: Types::ClassInstance | Types::Interface
    if type.name.namespace.relative?
      type = _ = absolute_type(type, context: context) do |_|
        NoTypeFoundError.check!(type.name.absolute!, env: env, location: type.location)
      end
    end

    type_params = case type
                  when Types::ClassInstance
                    env.class_decls[type.name]&.type_params
                  when Types::Interface
                    env.interface_decls[type.name]&.decl&.type_params
                  end

    unless type_params
      raise NoTypeFoundError.new(type_name: type.name, location: type.location)
    end

    InvalidTypeApplicationError.check!(
      type_name: type.name,
      args: type.args,
      params: type_params.each.map(&:name),
      location: type.location
    )

  when Types::Alias, Types::ClassSingleton
    # @type var type: Types::Alias | Types::ClassSingleton
    type = _ = absolute_type(type, context: context) { type.name.absolute! }
    NoTypeFoundError.check!(type.name, env: env, location: type.location)
  end

  type.each_type do |type|
    validate_type(type, context: context)
  end
end