libshit/gen_binding/lua.rb

# frozen_string_literal: true

require_relative 'aliaser'
require_relative 'cpp_info'
require_relative 'template'
require_relative 'util'

class LuaBinding
  include RecursiveClassDiscovery
  def initialize parser
    @parser = parser
    @ret_lua_classes = []
    @templates = {}
  end
  alias inspect to_s

  def parse
    @parser.init_cpp_info
    c = @parser.tu.cursor
    c.visit_children &method(:real_parse)
    parse_templates c unless @templates.empty?

    @ret_lua_classes.each do |cls|
      cls.entries.select{|_,m| m.info_type == :function }.each do |_,m|
        # stable sort, because ruby still can't be assed to implement something
        # such basic
        m.overloads.sort_by&.with_index {|x,i| [x.order, i] }
      end
    end
  end

  TEMPLATE_STR = <<EOS
#if LIBSHIT_WITH_LUA
#include <libshit/lua/user_type.hpp>

//$ classes.each do |cls|
//$   if cls.cpp_info.enum?
const char ::Libshit::Lua::TypeName</*$= cls.cpp_info.name */>::TYPE_NAME[] =
  /*$= Util.cpp_inspect cls.name */;
//$   else
/*$ if cls.template_args */template <>/*$ end */
const char /*$= cls.cpp_info.name */::TYPE_NAME[] =
  /*$= Util.cpp_inspect cls.name */;
//$   end
//$ end

namespace Libshit::Lua
{
//$ classes.each do |cls|

  // class /*$= cls.name */
  template<>
  void TypeRegisterTraits</*$= cls.cpp_info.name */>::Register(TypeBuilder& bld)
  {
//$   x = [ cls.cpp_info.name ]
//$   cls.parents.each do |v|
//$     x << v.cpp_info.name unless v.annot.no_inherit
//$   end
//$   if x.size > 1
    bld.Inherit</*$= x.join ', ' */>();
//$   end

//$   cls.entries.each do |k,v|
//$     if v.info_type == :constant
    bld.Add(/*$= Util.cpp_inspect k */, /*$= v.value_str */);
//$     else
    bld.AddFunction<
//$       v.overloads.each_with_index do |m,i|
      /*$= m.value_str *//*$= i == (v.overloads.size-1) ? '' : ',' */
//$       end
    >(/*$= Util.cpp_inspect k */);
//$     end
//$   end
/*$= Template.template (cls.annot.post_register || "").rstrip, cls */
  }
  static TypeRegister::StateRegister</*$= cls.cpp_info.name */> libshit_lua_statereg_/*$= cls.cpp_info.id */;
//$ end

}
#endif
EOS

  def generate dst
    dst.write Template.template TEMPLATE_STR, { classes: @ret_lua_classes }
  end

  private
  def default_name_class c
    Util.remove_anon_ns(c.spelling).gsub(/<.*/, ''). # eat template arguments
      gsub(/([[:upper:]])([[:upper:]][[:lower:]])/, '\1_\2').
      gsub(/([[:lower:]])([[:upper:]])/, '\1_\2').gsub('::', '.').downcase
  end

  def default_name_fun c
    if c.kind == :constructor
      'new'
    else
      c.spelling.gsub(/([[:lower:]])([[:upper:]])/, '\1_\2').downcase
    end
  end


  Annotation = Struct.new *CppFunction::ANNOTATIONS, *%i(
    name hidden get set post_register no_inherit smart_object const
    template_params fullname klass comparable wrap order implicit
  ), keyword_init: true
  ClassAnnotation = Annotation # TODO
  CLASS_ANNOTATION_KEY = 'libshit_luagen'

  def get_annotations c, env = {}
    Util.collect_annotations(c) do |annot|
      Util.map_annotation Annotation, CLASS_ANNOTATION_KEY, annot, env
    end
  end


  ClassInfo = Struct.new :cpp_info, :annot, :name, :entries, :smart_object,
                         :const, :parents, :has_push_lua, :template_alias,
                         :template_args, keyword_init: true
  def get_class_info c, annot
    return false if annot.hidden

    ClassInfo.new \
      cpp_info: CppClass.new(@parser, c.type),
      annot:, name: annot.name || default_name_class(c.type),
      entries: {}, smart_object: annot.smart_object, const: annot.const,
      parents: [], has_push_lua: false
  end

  def class_migrate_inheritable mod, ref
    return unless mod

    %i(smart_object const).each do |v|
      mod[v] = ref[v] if ref[v] != nil && mod[v] == nil
    end
  end


  # process lua methods inside classes
  def default_hidden c, annot, parent
    return false unless annot.implicit

    # special cases
    case c.kind
    when :function_decl
      return false
    when :constructor
      return true if parent.type.abstract_type?
    end

    acc = c.access_specifier
    (acc != :invalid && acc != :public) || c.deleted? || c.override? ||
      c.spelling.start_with?('operator')
  end

  # function handlers begin
  MemberInfo = Struct.new :annot, :lua_name, :info_klass, :info_type,
                          :value_str, :cpp_info, :order, :use_class,
                          :overloads, # TODO
                          keyword_init: true
  FunctionList = Struct.new :info_type, :overloads
  def func_common c, info
    info.cpp_info ||= CppFunction.new \
      cursor: c, aliaser: @parser.aliaser, annotation: info.annot,
      klass: info.info_klass&.cpp_info
    info.lua_name ||= default_name_fun(c)
    info.info_type = :function
  end

  def method_tmpl c, info
    # TODO deduplicate
    ci = info.cpp_info ||= CppFunction.new \
      cursor: c, aliaser: @parser.aliaser, annotation: info.annot,
      klass: info.info_klass.cpp_info

    tp = info.annot.template_params
    if !tp
      args = ci.template_arguments
      if args.size != 1 || args[0].spelling != 'Checker'
        Util.print_error 'Must specify template parameters', c
        return false
      end

      ci.template_arguments_map = ['Check::Throw']
    elsif tp.is_a? Array
      ci.template_arguments_map = tp
    else
      fail "Invalid template_params #{tp.class}"
    end
  end

  def freestanding_func c, info
    if info.annot.klass # user provided
      typ = class_by_name(info.annot.klass).cpp_info.type
    else
      typ = info.cpp_info.arguments.find do |x|
        x.type.canonical.spelling != 'Libshit::Lua::StateRef'
      end.type
      typ = typ.pointee || typ # get rid of &, *
      typ = typ.declaration.type # and const, whatever
    end

    fail 'Invalid base class' unless info.info_klass = class?(typ)

    info.value_str ||= info.cpp_info.ptr_value_str
  end

  def ctor c, info
    ci = info.cpp_info
    info.value_str ||= "&::Libshit::Lua::TypeTraits<#{ci.klass_name}>::" \
                       "Make<#{ci.arguments_str 'LuaGetRef'}>"
  end

  def general_method c, info
    ci = info.cpp_info
    ci.klass_name = info.use_class if info.use_class
    wrap = info.annot.wrap
    info.value_str ||=
      wrap ? "#{wrap}<#{ci.ptr_value_str}>::Wrap" : ci.ptr_value_str
  end

  def field c, info
    annot = info.annot
    fail 'Exactly one of get/set required' if !!annot.get == !!annot.set

    ci = info.cpp_info = CppVariable.new parser: @parser, cursor: c,
                                         klass: info.info_klass.cpp_info
    info.lua_name ||= "#{annot.get ? 'get' : 'set'}_#{default_name_fun c}"
    info.info_type = :function

    info.value_str =
      begin
        key = if annot.get
                annot.get == true ? '::Libshit::Lua::GetMember' : annot.get
              else
                annot.set == true ? '::Libshit::Lua::SetMember' : annot.set
              end
        "&#{key}<#{ci.klass_name}, #{ci.type_str}, #{ci.ptr_value_str}>"
      end
  end

  def constant c, info
    ci = info.cpp_info = CppEnumConstant.new \
      cursor: c, klass: info.info_klass.cpp_info
    info.lua_name ||= ci.qualified_name
    info.info_type = :constant
    info.value_str = ci.value_str
  end

  FUNC_TYPE_HANDLERS = {
    function_decl: %i(func_common freestanding_func),
    constructor: %i(func_common ctor),
    cxx_method: %i(func_common general_method),
    function_template: %i(method_tmpl func_common general_method),
    field_decl: %i(field),
    enum_constant_decl: %i(constant),
  }.freeze

  def lua_function c, annot, parent, info = MemberInfo.new
    return if annot.hidden.nil? ? default_hidden(c, annot, parent) : annot.hidden

    info.annot = annot
    info.lua_name = annot.name
    info.order = annot.order || 0
    FUNC_TYPE_HANDLERS[c.kind].each do |h|
      send h, c, info
    end

    fail unless info.info_klass
    fail unless info.value_str
    fail unless info.info_type

    ents = info.info_klass.entries
    name = info.lua_name
    case info.info_type
    when :constant
      ents[name].nil? or fail "Duplicate constant #{name}"
      ents[name] = info

    when :function
      ents[name] ||= FunctionList.new :function, []
      ents[name].info_type == :function or fail 'function&constant with same name?'
      ents[name].overloads << info

    else
      fail "Unknown info.info_type #{info.info_type.inspect}"
    end
  rescue
    Util.print_error $!, c
  end

  def parse_method c, kind, parent, parse_class_class
    annots = get_annotations c, cls: parse_class_class
    if annots.empty?
      if kind == :field_decl
        annots << Annotation.new(get: true, implicit: true).freeze
        # no setter if class or field const
        if !parse_class_class.const && !c.type.const_qualified?
          annots << Annotation.new(set: true, implicit: true).freeze
        end

      # only ctors/const methods in const classes. if class not const->everything
      elsif kind == :constructor || !parse_class_class.const || c.const? ||
            c.static?
        annots << Annotation.new(implicit: true).freeze
      end
    end

    annots.each do |a|
      lua_function c, a, parent, MemberInfo.new(info_klass: parse_class_class)
    end
  end

  # inside class
  def parse_class type, klass
    type.declaration.visit_children do |c, par|
      kind = c.kind
      case kind
      when :cxx_base_specifier
        if c.public? && (lc = class?(c.type))
          klass.parents << lc
        end

      when :using_declaration
        c.referenced.overloaded_decls.each do |v|
          if v.kind != :type_alias_decl
            parse_method v, v.kind, c.semantic_parent, klass
          end
        end
      end

      next :continue unless %i(cxx_method function_template constructor
                               field_decl enum_constant_decl).member? kind
      klass.has_push_lua = true if c.spelling == 'PushLua'

      parse_method c, kind, c.semantic_parent, klass
      :continue
    end

    if klass.smart_object && !type.abstract_type? && !klass.has_push_lua
      Util.print_warning 'Missing LIBSHIT_DYNAMIC_OBJECT', type.declaration
    end
    klass
  end

  # top level parse
  def real_parse c, parent
    return :continue unless @parser.filter[c, parent]
    case c.kind
    when :namespace; return :recurse
    when :class_decl, :struct_decl, :enum_decl
      # ignore fwd decls/templates
      if c.definition? && c.specialized_template.null?
        x = class? c.type
        @ret_lua_classes << parse_class(c.type, x) if x
        return :recurse # support inner classes
      end

    when :function_decl
      get_annotations(c).each {|a| lua_function c, a, c.semantic_parent }

    when :type_alias_decl
      get_annotations(c).each do |a|
        t = c.typedef_type

        if x = class?(t)
          @templates[t] = c.spelling
          x.name = a.fullname || "#{x.name}_#{a.name || c.spelling}"
          x.template_alias = a
          # hack!
          x.template_args =
            t.spelling.gsub(/^[:0-9a-zA-Z ]*</, '').gsub(/>[ *&]*$/, '')
          @ret_lua_classes << parse_class(t, x)
        else
          Util.print_error 'is not a lua class', c
        end
      end
    end

    :continue
  rescue
    Util.print_error $!, c
    :continue
  end

  def path_isbase base, o
    o[0, base.size] == base
  end

  def parse_templates c
    cwd = Pathname.pwd.cleanpath
    base = cwd.join('src').each_filename.to_a
    basetest = cwd.join('test').each_filename.to_a
    libshittest = cwd.join('libshit/test').each_filename.to_a

    cache = {}
    c.visit_children do |c2, par|
      file = c2.location.file
      if cache[file].nil?
        this = cwd.join(file).cleanpath.each_filename.to_a
        cache[file] = path_isbase(base, this) || path_isbase(basetest, this) ||
                      path_isbase(libshittest, this)
      end
      next :continue unless cache[file]

      case c2.kind
      when :namespace; next :recurse
      when :struct_decl
        fake_class = nil
        c2.visit_children do |c3, par3|
          kind = c3.kind
          next :continue if kind == :namespace_ref || kind == :type_ref
          if kind == :type_alias_decl && c3.spelling == 'FakeClass'
            fake_class = c3.typedef_type
            next :continue
          end
          next :break unless fake_class

          if kind == :cxx_method
            anns = get_annotations c3
            anns << Annotation.new(implicit: true).freeze if anns.empty?
            anns.each do |a|
              if klass = class?(fake_class)
                mi = MemberInfo.new info_klass: klass,
                                    use_class: @parser.aliaser.type_name(par3)
                lua_function c3, a, c3.semantic_parent, mi
              else
                Util.print_error 'FakeClass is not lua class', c
              end
            end
          end

          :continue
        rescue
          Util.print_error $!, c
          :continue
        end
      end
      :continue
    end
  end
end