Class: RLSL::Prism::ExpressionInferer

Inherits:
Object
  • Object
show all
Defined in:
lib/rlsl/prism/type_inference/expression_inferer.rb

Instance Method Summary collapse

Constructor Details

#initialize(infer:, lookup:, call_type_resolver:, field_type_resolver:, collection_type_resolver:) ⇒ ExpressionInferer

Returns a new instance of ExpressionInferer.



6
7
8
9
10
11
12
 
# File 'lib/rlsl/prism/type_inference/expression_inferer.rb', line 6

def initialize(infer:, lookup:, call_type_resolver:, field_type_resolver:, collection_type_resolver:)
  @infer = infer
  @lookup = lookup
  @call_type_resolver = call_type_resolver
  @field_type_resolver = field_type_resolver
  @collection_type_resolver = collection_type_resolver
end

Instance Method Details

#infer_array_index(node) ⇒ Object 



84
85
86
87
88
89
 
# File 'lib/rlsl/prism/type_inference/expression_inferer.rb', line 84

def infer_array_index(node)
  @infer.call(node.array)
  @infer.call(node.index)
  node.type = @collection_type_resolver.resolve_array_index(node)
  node
end

#infer_array_literal(node) ⇒ Object 



78
79
80
81
82
 
# File 'lib/rlsl/prism/type_inference/expression_inferer.rb', line 78

def infer_array_literal(node)
  node.elements.each { |element| @infer.call(element) }
  node.type = @collection_type_resolver.resolve_array_literal(node)
  node
end

#infer_binary_op(node) ⇒ Object 



28
29
30
31
32
33
34
35
36
37
38
 
# File 'lib/rlsl/prism/type_inference/expression_inferer.rb', line 28

def infer_binary_op(node)
  @infer.call(node.left)
  @infer.call(node.right)

  node.type = Builtins.binary_op_result_type(
    node.operator,
    node.left.type,
    node.right.type
  )
  node
end

#infer_bool_literal(node) ⇒ Object 



23
24
25
26
 
# File 'lib/rlsl/prism/type_inference/expression_inferer.rb', line 23

def infer_bool_literal(node)
  node.type = :bool
  node
end

#infer_field_access(node) ⇒ Object 



60
61
62
63
64
 
# File 'lib/rlsl/prism/type_inference/expression_inferer.rb', line 60

def infer_field_access(node)
  @infer.call(node.receiver)
  node.type = @field_type_resolver.resolve(node)
  node
end

#infer_func_call(node) ⇒ Object 



52
53
54
55
56
57
58
 
# File 'lib/rlsl/prism/type_inference/expression_inferer.rb', line 52

def infer_func_call(node)
  node.args.each { |arg| @infer.call(arg) }
  @infer.call(node.receiver) if node.receiver

  node.type = @call_type_resolver.resolve(node)
  node
end

#infer_literal(node) ⇒ Object 



19
20
21
 
# File 'lib/rlsl/prism/type_inference/expression_inferer.rb', line 19

def infer_literal(node)
  node
end

#infer_parenthesized(node) ⇒ Object 



72
73
74
75
76
 
# File 'lib/rlsl/prism/type_inference/expression_inferer.rb', line 72

def infer_parenthesized(node)
  @infer.call(node.expression)
  node.type = node.expression.type
  node
end

#infer_swizzle(node) ⇒ Object 



66
67
68
69
70
 
# File 'lib/rlsl/prism/type_inference/expression_inferer.rb', line 66

def infer_swizzle(node)
  @infer.call(node.receiver)
  node.type = Builtins.swizzle_type(node.components)
  node
end

#infer_unary_op(node) ⇒ Object 



40
41
42
43
44
45
46
47
48
49
50
 
# File 'lib/rlsl/prism/type_inference/expression_inferer.rb', line 40

def infer_unary_op(node)
  @infer.call(node.operand)

  case node.operator.to_s
  when "-"
    node.type = node.operand.type
  when "!"
    node.type = :bool
  end
  node
end

#infer_var_ref(node) ⇒ Object 



14
15
16
17
 
# File 'lib/rlsl/prism/type_inference/expression_inferer.rb', line 14

def infer_var_ref(node)
  node.type ||= @lookup.call(node.name)
  node
end