Module: Carbon::Compiler::Visitor::Generation::Expressions::Calls

Included in:
Carbon::Compiler::Visitor::Generation::Expressions
Defined in:
lib/carbon/compiler/visitor/generation/expressions/calls.rb

Instance Method Summary collapse

Instance Method Details

#visit_expression_call_access(node, context) ⇒ Object 



12
13
14
15
16
17
18
19
20
21
 
# File 'lib/carbon/compiler/visitor/generation/expressions/calls.rb', line 12

def visit_expression_call_access(node, context)
  base = accept(node.expression, context)
  params = node.parameters.map { |p| accept(p, context) }
  ptypes = params.map(&:type)
  name = base.type.call(:[], [base.type, *ptypes],
    node.generics || [])
  func, gens = context.find(name)
  context.build.call(name, base, *params)
    .as(func.return.sub(gens))
end

#visit_expression_call_attribute(node, context) ⇒ Object 



25
26
27
28
29
30
31
 
# File 'lib/carbon/compiler/visitor/generation/expressions/calls.rb', line 25

def visit_expression_call_attribute(node, context)
  base = accept(node.expression, context)
  name = base.type.call(node.name.value, [base.type],
    node.generics || [])
  func, gens = context.find(name)
  context.build.call(name, base).as(func.return.sub(gens))
end

#visit_expression_call_enum(node, context) ⇒ Object 



35
36
37
38
39
40
41
42
43
 
# File 'lib/carbon/compiler/visitor/generation/expressions/calls.rb', line 35

def visit_expression_call_enum(node, context)
  base = node.module
  params = node.parameters.map { |p| accept(p, context) }
  generics = node.generics.map { |p| accept(p, context) }
  ptypes = params.map(&:type)
  name = base.call(node.name.value, ptypes, node.generics || [])
  func, gens = context.find(name)
  context.build.call(name, *params).as(func.return.sub(gens))
end

#visit_expression_call_module(node, context) ⇒ Object 



47
48
49
50
51
52
53
54
 
# File 'lib/carbon/compiler/visitor/generation/expressions/calls.rb', line 47

def visit_expression_call_module(node, context)
  base = node.module
  params = node.parameters.map { |p| accept(p, context) }
  ptypes = params.map(&:type)
  name = base.call(node.name.value, ptypes, node.generics || [])
  func, gens = context.find(name)
  context.build.call(name, *params).as(func.return.sub(gens))
end

#visit_expression_call_self(node, context) ⇒ Object 



58
59
60
61
62
63
64
65
66
67
68
69
 
# File 'lib/carbon/compiler/visitor/generation/expressions/calls.rb', line 58

def visit_expression_call_self(node, context)
  base = @name
  params = node.parameters.map { |p| accept(p, context) }
  ptypes = params.map(&:type)
  name = base.call(node.name.value, [base, *ptypes],
    node.generics || [])
  func, gens = context.find(name)
  thisp = context.current.fetch("self")
  this = context.build.load(thisp).as(base)
  context.build.call(name, this, *params)
    .as(func.return.sub(gens))
end

#visit_expression_call_unified(node, context) ⇒ Object 



73
74
75
76
77
78
79
80
81
82
83
 
# File 'lib/carbon/compiler/visitor/generation/expressions/calls.rb', line 73

def visit_expression_call_unified(node, context)
  base = accept(node.expression, context)
  params = node.parameters.map { |p| accept(p, context) }
  generics = node.generics.map { |p| accept(p, context) }
  ptypes = params.map(&:type)
  name = base.type.call(node.name.value, [base.type, *ptypes],
    node.generics || [])
  func, gens = context.find(name)
  context.build.call(name, base, *params)
    .as(func.return.sub(gens))
end