cpp_declarator_converter.cpp

/*******************************************************************\

Module: C++ Language Type Checking

Author: Daniel Kroening, kroening@cs.cmu.edu

\*******************************************************************/

/// \file
/// C++ Language Type Checking

#include "cpp_declarator_converter.h"

#include <util/c_types.h>
#include <util/mathematical_types.h>
#include <util/source_location.h>
#include <util/std_types.h>
#include <util/symbol_table_base.h>

#include "cpp_type2name.h"
#include "cpp_typecheck.h"
#include "cpp_typecheck_fargs.h"

cpp_declarator_convertert::cpp_declarator_convertert(
  class cpp_typecheckt &_cpp_typecheck):
  is_typedef(false),
  is_template(false),
  is_template_parameter(false),
  is_friend(false),
  linkage_spec(_cpp_typecheck.current_linkage_spec),
  cpp_typecheck(_cpp_typecheck),
  is_code(false)
{
}

symbolt &cpp_declarator_convertert::convert(
  const typet &declaration_type,
  const cpp_storage_spect &storage_spec,
  const cpp_member_spect &member_spec,
  cpp_declaratort &declarator)
{
  PRECONDITION(declaration_type.is_not_nil());

  if(declaration_type.id()=="cpp-cast-operator")
  {
    typet type;
    type.swap(declarator.name().get_sub().back());
    declarator.type().add_subtype() = type;
    cpp_typecheck.typecheck_type(type);
    cpp_namet::namet name("(" + cpp_type2name(type) + ")");
    declarator.name().get_sub().back().swap(name);
  }

  PRECONDITION(declarator.id() == ID_cpp_declarator);
  final_type=declarator.merge_type(declaration_type);
  CHECK_RETURN(final_type.is_not_nil());

  cpp_storage_spect final_storage_spec = storage_spec;
  final_storage_spec |= cpp_storage_spect(final_type);

  cpp_template_args_non_tct template_args;

  // run resolver on scope
  {
    cpp_save_scopet save_scope(cpp_typecheck.cpp_scopes);

    cpp_typecheck_resolvet cpp_typecheck_resolve(cpp_typecheck);

    cpp_typecheck_resolve.resolve_scope(
      declarator.name(), base_name, template_args);

    cpp_scopet *friend_scope = nullptr;

    if(is_friend)
    {
      friend_scope = &cpp_typecheck.cpp_scopes.current_scope();
      save_scope.restore();
    }

    scope=&cpp_typecheck.cpp_scopes.current_scope();

    // check the declarator-part of the type, in the current scope
    if(declarator.value().is_nil() || !cpp_typecheck.has_auto(final_type))
      cpp_typecheck.typecheck_type(final_type);

    if(friend_scope)
      scope = friend_scope;
  }

  is_code=is_code_type(final_type);

  // global-scope arrays must have fixed size
  if(scope->is_global_scope())
    cpp_typecheck.check_fixed_size_array(final_type);

  get_final_identifier();

  if(is_typedef)
    final_type.set(ID_C_typedef, final_identifier);

  // first see if it is a member
  if(scope->id_class == cpp_idt::id_classt::CLASS)
  {
    // it's a member! it must be declared already, unless it's a friend

    typet &method_qualifier=
      static_cast<typet &>(declarator.method_qualifier());

    // adjust template type
    if(final_type.id()==ID_template)
    {
      UNREACHABLE;
      typet tmp;
      tmp.swap(to_template_type(final_type).subtype());
      final_type.swap(tmp);
    }

    // try static first
    auto maybe_symbol=
      cpp_typecheck.symbol_table.get_writeable(final_identifier);

    if(!maybe_symbol)
    {
      // adjust type if it's a non-static member function
      if(final_type.id()==ID_code)
      {
        cpp_save_scopet save_scope(cpp_typecheck.cpp_scopes);
        cpp_typecheck.cpp_scopes.go_to(*scope);

        cpp_typecheck.add_this_to_method_type(
          cpp_typecheck.lookup(scope->identifier),
          to_code_type(final_type),
          method_qualifier);
      }

      get_final_identifier();

      // try again
      maybe_symbol=cpp_typecheck.symbol_table.get_writeable(final_identifier);
      if(!maybe_symbol && is_friend)
      {
        symbolt &friend_symbol =
          convert_new_symbol(final_storage_spec, member_spec, declarator);
        // mark it as weak so that the full declaration can replace the symbol
        friend_symbol.is_weak = true;
        return friend_symbol;
      }
      else if(!maybe_symbol)
      {
        cpp_typecheck.error().source_location=
          declarator.name().source_location();
        cpp_typecheck.error()
          << "member '" << base_name << "' not found in scope '"
          << scope->identifier << "'" << messaget::eom;
        throw 0;
      }
    }

    symbolt &symbol=*maybe_symbol;

    combine_types(declarator.name().source_location(), final_type, symbol);
    enforce_rules(symbol);

    // If it is a constructor, we take care of the
    // object initialization
    if(
      final_type.id() == ID_code &&
      to_code_type(final_type).return_type().id() == ID_constructor)
    {
      const cpp_namet &name=declarator.name();

      exprt symbol_expr=
        cpp_typecheck.resolve(
          name,
          cpp_typecheck_resolvet::wantt::TYPE,
          cpp_typecheck_fargst());

      if(symbol_expr.id() != ID_type)
      {
        cpp_typecheck.error().source_location=name.source_location();
        cpp_typecheck.error() << "expected type" << messaget::eom;
        throw 0;
      }

      irep_idt identifier=symbol_expr.type().get(ID_identifier);
      const symbolt &symb=cpp_typecheck.lookup(identifier);
      const struct_typet &type = to_struct_type(symb.type);

      if(declarator.find(ID_member_initializers).is_nil())
        declarator.set(ID_member_initializers, ID_member_initializers);

      cpp_typecheck.check_member_initializers(
        type.bases(), type.components(), declarator.member_initializers());

      cpp_typecheck.full_member_initialization(
        type, declarator.member_initializers());
    }

    if(!final_storage_spec.is_extern())
      symbol.is_extern=false;

    // initializer?
    handle_initializer(symbol, declarator);

    return symbol;
  }
  else
  {
    // no, it's no way a method

    // we won't allow the constructor/destructor type
    if(final_type.id()==ID_code &&
       to_code_type(final_type).return_type().id()==ID_constructor)
    {
      cpp_typecheck.error().source_location=declarator.name().source_location();
      cpp_typecheck.error() << "function must have return type"
                            << messaget::eom;
      throw 0;
    }

    // already there?
    const auto maybe_symbol=
      cpp_typecheck.symbol_table.get_writeable(final_identifier);
    if(!maybe_symbol)
      return convert_new_symbol(final_storage_spec, member_spec, declarator);
    symbolt &symbol=*maybe_symbol;

    if(!final_storage_spec.is_extern())
      symbol.is_extern = false;

    if(declarator.get_bool(ID_C_template_case))
      return symbol;

    combine_types(declarator.name().source_location(), final_type, symbol);
    enforce_rules(symbol);

    // initializer?
    handle_initializer(symbol, declarator);

    if(symbol.type.id()=="cpp-template-type")
    {
      const auto id_set = scope->lookup_identifier(
        symbol.name, cpp_idt::id_classt::TEMPLATE_PARAMETER);

      if(id_set.empty())
      {
        cpp_idt &identifier=
          cpp_typecheck.cpp_scopes.put_into_scope(symbol, *scope);
        identifier.id_class=cpp_idt::id_classt::TEMPLATE_PARAMETER;
      }
    }

    return symbol;
  }
}

void cpp_declarator_convertert::combine_types(
  const source_locationt &source_location,
  const typet &decl_type,
  symbolt &symbol)
{
  if(symbol.type.id()==decl_type.id() &&
     decl_type.id()==ID_code)
  {
    // functions need special treatment due
    // to argument names, default values, and inlined-ness
    const code_typet &decl_code_type=to_code_type(decl_type);
    code_typet &symbol_code_type=to_code_type(symbol.type);

    if(decl_code_type.get_inlined())
      symbol_code_type.set_inlined(true);

    if(decl_code_type.return_type()==symbol_code_type.return_type() &&
       decl_code_type.parameters().size()==symbol_code_type.parameters().size())
    {
      for(std::size_t i=0; i<decl_code_type.parameters().size(); i++)
      {
        const code_typet::parametert &decl_parameter=
          decl_code_type.parameters()[i];
        code_typet::parametert &symbol_parameter=
          symbol_code_type.parameters()[i];

        // first check type
        if(decl_parameter.type()!=symbol_parameter.type())
        {
          // The 'this' parameter of virtual functions mismatches
          if(i != 0 || !symbol_code_type.get_bool(ID_C_is_virtual))
          {
            cpp_typecheck.error().source_location=source_location;
            cpp_typecheck.error()
              << "symbol '" << symbol.display_name() << "': parameter "
              << (i + 1) << " type mismatch\n"
              << "previous type: "
              << cpp_typecheck.to_string(symbol_parameter.type())
              << "\nnew type: "
              << cpp_typecheck.to_string(decl_parameter.type())
              << messaget::eom;
            throw 0;
          }
        }

        if(symbol.value.is_nil())
        {
          symbol_parameter.set_base_name(decl_parameter.get_base_name());
          // set an empty identifier when no body is available
          symbol_parameter.set_identifier(irep_idt());
          symbol_parameter.add_source_location()=
            decl_parameter.source_location();
        }
      }

      // ok
      return;
    }
  }
  else if(symbol.type==decl_type)
    return; // ok
  else if(
    symbol.type.id() == ID_array &&
    to_array_type(symbol.type).size().is_nil() && decl_type.id() == ID_array &&
    to_array_type(symbol.type).element_type() ==
      to_array_type(decl_type).element_type())
  {
    symbol.type = decl_type;
    return; // ok
  }

  cpp_typecheck.error().source_location=source_location;
  cpp_typecheck.error() << "symbol '" << symbol.display_name()
                        << "' already declared with different type:\n"
                        << "original: " << cpp_typecheck.to_string(symbol.type)
                        << "\n     new: " << cpp_typecheck.to_string(final_type)
                        << messaget::eom;
  throw 0;
}

void cpp_declarator_convertert::enforce_rules(const symbolt &symbol)
{
  // enforce rules for operator overloading
  operator_overloading_rules(symbol);

  // enforce rules about main()
  main_function_rules(symbol);
}

void cpp_declarator_convertert::handle_initializer(
  symbolt &symbol,
  cpp_declaratort &declarator)
{
  exprt &value=declarator.value();

  // moves member initializers into 'value' - only methods have these
  if(symbol.type.id() == ID_code)
    cpp_typecheck.move_member_initializers(
      declarator.member_initializers(), to_code_type(symbol.type), value);

  // any initializer to be done?
  if(value.is_nil())
    return;

  if(symbol.is_extern)
  {
    // the symbol is really located here
    symbol.is_extern=false;
  }

  if(symbol.value.is_nil())
  {
    // no initial value yet
    symbol.value.swap(value);

    if(!is_code)
      cpp_typecheck.convert_initializer(symbol);
  }
  else
  {
#if 0
    cpp_typecheck.error().source_location=source_location;

    if(is_code)
    {
      cpp_typecheck.error() << "body of function '"
                        << symbol.display_name()
                        << "' has already been defined" << messaget::eom;
    }
    else
    {
      cpp_typecheck.error() << "symbol '"
                        << symbol.display_name()
                        << "' already has an initializer" << messaget::eom;
    }

    throw 0;
#endif
  }
}

void cpp_declarator_convertert::get_final_identifier()
{
  std::string identifier=id2string(base_name);

  // main is always "C" linkage, as a matter of principle
  if(is_code && base_name == ID_main && scope->prefix.empty())
  {
    linkage_spec=ID_C;
  }

  if(is_code)
  {
    if(linkage_spec==ID_C)
    {
      // fine as is
    }
    else if(linkage_spec==ID_auto ||
            linkage_spec==ID_cpp)
    {
      // Is there already an `extern "C"' function with the same name
      // and the same signature?
      symbol_table_baset::symbolst::const_iterator c_it =
        cpp_typecheck.symbol_table.symbols.find(identifier);

      if(c_it!=cpp_typecheck.symbol_table.symbols.end() &&
         c_it->second.type.id()==ID_code &&
         cpp_typecheck.function_identifier(final_type)==
         cpp_typecheck.function_identifier(c_it->second.type))
      {
        // leave as is, no decoration
      }
      else
      {
        // add C++ decoration
        identifier+=id2string(cpp_typecheck.function_identifier(final_type));
      }
    }
  }

  final_identifier = scope->prefix + identifier;
}

symbolt &cpp_declarator_convertert::convert_new_symbol(
  const cpp_storage_spect &storage_spec,
  const cpp_member_spect &member_spec,
  cpp_declaratort &declarator)
{
  irep_idt pretty_name=get_pretty_name();

  symbolt symbol{
    final_identifier,
    final_type,
    linkage_spec == ID_auto ? ID_cpp : linkage_spec};
  symbol.base_name=base_name;
  symbol.value=declarator.value();
  symbol.location=declarator.name().source_location();
  symbol.is_extern = storage_spec.is_extern();
  symbol.is_parameter = declarator.get_is_parameter();
  symbol.is_weak = storage_spec.is_weak();
  symbol.module=cpp_typecheck.module;
  symbol.is_type=is_typedef;
  symbol.is_macro =
    (is_typedef && !is_template_parameter) || storage_spec.is_constexpr();
  symbol.pretty_name=pretty_name;

  if(is_code && !symbol.is_type)
  {
    // it is a function
    symbol.is_static_lifetime = false;
    symbol.is_thread_local = false;

    symbol.is_file_local = storage_spec.is_static();

    if(member_spec.is_inline())
      to_code_type(symbol.type).set_inlined(true);

    if(symbol.value.is_nil())
    {
      // we don't need the identifiers
      for(auto &parameter : to_code_type(symbol.type).parameters())
        parameter.set_identifier(irep_idt());
    }
  }
  else
  {
    symbol.is_lvalue = !is_reference(symbol.type) &&
                       !(symbol.type.get_bool(ID_C_constant) &&
                         is_number(symbol.type) && symbol.value.is_constant());

    symbol.is_static_lifetime =
      !symbol.is_macro && !symbol.is_type &&
      (cpp_typecheck.cpp_scopes.current_scope().is_global_scope() ||
       storage_spec.is_static());

    symbol.is_thread_local =
      (!symbol.is_static_lifetime && !storage_spec.is_extern()) ||
      storage_spec.is_thread_local();

    symbol.is_file_local =
      (symbol.is_macro && !storage_spec.is_constexpr()) ||
      (!cpp_typecheck.cpp_scopes.current_scope().is_global_scope() &&
       !storage_spec.is_extern()) ||
      (cpp_typecheck.cpp_scopes.current_scope().is_global_scope() &&
       storage_spec.is_static()) ||
      symbol.is_parameter;
  }

  if(symbol.is_static_lifetime)
    cpp_typecheck.dynamic_initializations.push_back(symbol.name);

  // move early, it must be visible before doing any value
  symbolt *new_symbol;

  if(cpp_typecheck.symbol_table.move(symbol, new_symbol))
  {
    cpp_typecheck.error().source_location=symbol.location;
    cpp_typecheck.error()
      << "cpp_typecheckt::convert_declarator: symbol_table.move() failed"
      << messaget::eom;
    throw 0;
  }

  if(!is_code)
  {
    const auto id_set = cpp_typecheck.cpp_scopes.current_scope().lookup(
      base_name, cpp_scopet::SCOPE_ONLY);

    for(const auto &id_ptr : id_set)
    {
      const cpp_idt &id = *id_ptr;
      // the name is already in the scope
      // this is ok if they belong to different categories

      if(!id.is_class() && !id.is_enum())
      {
        cpp_typecheck.error().source_location=new_symbol->location;
        cpp_typecheck.error()
          << "'" << base_name << "' already in scope" << messaget::eom;
        throw 0;
      }
    }
  }

  // put into scope
  cpp_idt &identifier=
    cpp_typecheck.cpp_scopes.put_into_scope(*new_symbol, *scope, is_friend);

  if(is_template)
    identifier.id_class=cpp_idt::id_classt::TEMPLATE;
  else if(is_template_parameter)
    identifier.id_class=cpp_idt::id_classt::TEMPLATE_PARAMETER;
  else if(is_typedef)
    identifier.id_class=cpp_idt::id_classt::TYPEDEF;
  else
    identifier.id_class=cpp_idt::id_classt::SYMBOL;

  // do the value
  if(!new_symbol->is_type)
  {
    if(is_code)
    {
      if(new_symbol->is_macro)
        cpp_typecheck.convert_function(*new_symbol);
      else if(declarator.type().id() != ID_template)
        cpp_typecheck.add_method_body(new_symbol);
    }
    else
      cpp_typecheck.convert_initializer(*new_symbol);
  }

  enforce_rules(*new_symbol);

  return *new_symbol;
}

irep_idt cpp_declarator_convertert::get_pretty_name()
{
  if(is_code)
  {
    const irept::subt &parameters=
      final_type.find(ID_parameters).get_sub();

    std::string result=scope->prefix+id2string(base_name)+"(";

    for(auto it = parameters.begin(); it != parameters.end(); ++it)
    {
      const typet &parameter_type = ((exprt &)*it).type();

      if(it!=parameters.begin())
        result+=", ";

      result+=cpp_typecheck.to_string(parameter_type);
    }

    result+=')';

    return result;
  }

  return scope->prefix+id2string(base_name);
}

void cpp_declarator_convertert::operator_overloading_rules(
  const symbolt &)
{
}

void cpp_declarator_convertert::main_function_rules(
  const symbolt &symbol)
{
  if(symbol.name==ID_main)
  {
    if(symbol.type.id()!=ID_code)
    {
      cpp_typecheck.error().source_location=symbol.location;
      cpp_typecheck.error() << "main must be function" << messaget::eom;
      throw 0;
    }

    const typet &return_type=
      to_code_type(symbol.type).return_type();

    if(return_type!=signed_int_type())
    {
      // Too many embedded compilers ignore this rule.
      #if 0
      cpp_typecheck.error().source_location=symbol.location;
      throw "main must return int";
      #endif
    }
  }
}