Module: Jade::Codegen::FunctionDeclaration

Extended by:
FunctionDeclaration, Helpers
Included in:
FunctionDeclaration
Defined in:
lib/jade/codegen/function_declaration.rb

Constant Summary

Constants included from Helpers

Helpers::NATIVE_RUBY_CLASSES

Instance Method Summary collapse

Methods included from Helpers

data_define, dict_constraints, dict_synthetic_name, fn_constraints, fn_impl_synthetic_name, generate_many, generate_node, impl_synthetic_name, param_synthetic_name, resolve_callee_symbol, ruby_classes_for_type, to_qualified

Instance Method Details

#generate(node, registry) ⇒ Object 



32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
# File 'lib/jade/codegen/function_declaration.rb', line 32

def generate(node, registry)
  node => AST::FunctionDeclaration(name:, params:, body:, symbol:)

  var_cs      = dict_constraints(symbol, registry)
  param_names = params.map { generate_node(it, registry) }
  dict_params = var_cs.each_index.map { dict_synthetic_name(it) }

  body_code = build_dict_env(var_cs)
    .then { Codegen.with_dict_env(it) { emit_body(body, symbol, param_names, registry) } }

  target  = var_cs.empty? ? name : fn_impl_synthetic_name(name)
  sig     = (param_names + dict_params).join(', ')
  sig_str = sig.empty? ? '' : "(#{sig})"

  Pretty.block("def #{target}#{sig_str}", body_code)
end

#generate_boundary_wrapper(node, registry) ⇒ Object 



7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
# File 'lib/jade/codegen/function_declaration.rb', line 7

def generate_boundary_wrapper(node, registry)
  node => AST::FunctionDeclaration(name:, params:, symbol:)

  entry = registry.get(symbol.module_name)
  return nil unless entry&.exposed_value(name)

  if !dict_constraints(symbol, registry).empty?
    return not_exposed_stub(symbol, 'polymorphic — no extractable witness for type variable')
  end

  fn_type = fn_type_for(symbol, registry)
  unless Codegen::Boundary.eligible?(fn_type, registry)
    return not_exposed_stub(symbol, ineligibility_reason(fn_type, registry))
  end

  args, return_type = Type.signature(fn_type)
  param_names       = params.map(&:name)

  if task_return?(return_type)
    task_wrapper_pair(name, args, param_names, return_type, registry)
  else
    eligible_wrapper(name, args, param_names, return_type, registry)
  end
end