Fix delayed method body conversion for templates

Author: peterschrammel

regression/cpp/Function_Overloading2/test.desc

@@ -1,4 +1,4 @@
-KNOWNBUG
+CORE
 main.cpp
 
 ^EXIT=0$

regression/cpp/Template_Instantiation5/test.desc

@@ -1,4 +1,4 @@
-KNOWNBUG
+CORE
 main.cpp
 
 ^EXIT=0$

src/cpp/cpp_instantiate_template.cpp

@@ -11,6 +11,10 @@ Author: Daniel Kroening, kroening@cs.cmu.edu
 
 #include "cpp_typecheck.h"
 
+#ifdef DEBUG
+#include <iostream>
+#endif
+
 #include <util/arith_tools.h>
 #include <util/base_exceptions.h>
 #include <util/simplify_expr.h>
@@ -220,6 +224,10 @@ const symbolt &cpp_typecheckt::instantiate_template(
   const cpp_template_args_tct &full_template_args,
   const typet &specialization)
 {
+#ifdef DEBUG
+  std::cout << "instantiate_template: " << template_symbol.name << std::endl;
+#endif
+
   if(instantiation_stack.size()==MAX_DEPTH)
   {
     error().source_location=source_location;
@@ -233,10 +241,10 @@ const symbolt &cpp_typecheckt::instantiate_template(
   instantiation_stack.back().identifier=template_symbol.name;
   instantiation_stack.back().full_template_args=full_template_args;
 
-  #if 0
+#ifdef DEBUG
   std::cout << "L: " << source_location << '\n';
   std::cout << "I: " << template_symbol.name << '\n';
-  #endif
+#endif
 
   cpp_save_scopet cpp_saved_scope(cpp_scopes);
   cpp_saved_template_mapt saved_map(template_map);
@@ -247,7 +255,7 @@ const symbolt &cpp_typecheckt::instantiate_template(
   assert(!specialization_template_args.has_unassigned());
   assert(!full_template_args.has_unassigned());
 
-  #if 0
+#ifdef DEBUG
   std::cout << "A: <";
   forall_expr(it, specialization_template_args.arguments())
   {
@@ -258,8 +266,8 @@ const symbolt &cpp_typecheckt::instantiate_template(
     else
       std::cout << to_string(*it);
   }
-  std::cout << ">\n";
-  #endif
+  std::cout << ">\n\n";
+#endif
 
   // do we have arguments?
   if(full_template_args.arguments().empty())
@@ -377,8 +385,8 @@ const symbolt &cpp_typecheckt::instantiate_template(
     instantiated_with.get_sub().push_back(specialization_template_args);
   }
 
-  #if 0
-  std::cout << "MAP:\n";
+  #ifdef DEBUG
+  std::cout << "CLASS MAP:" << std::endl;
   template_map.print(std::cout);
   #endif
 
@@ -436,15 +444,29 @@ const symbolt &cpp_typecheckt::instantiate_template(
 
       // mapping from template arguments to values/types
       template_map.build(method_type, specialization_template_args);
+#ifdef DEBUG
+      std::cout << "METHOD MAP:" << std::endl;
+      template_map.print(std::cout);
+#endif
 
       method_decl.remove(ID_template_type);
       method_decl.remove(ID_is_template);
 
       convert(method_decl);
     }
 
-    const symbolt &new_symb=
-      lookup(new_decl.type().get(ID_identifier));
+    const irep_idt& new_symb_id = new_decl.type().get(ID_identifier);
+    symbolt &new_symb = symbol_table.get_writeable_ref(new_symb_id);
+
+    //add template arguments to type in order to retrieve template map
+    //  when typechecking function body
+    new_symb.type.set(ID_C_template, template_type);
+    new_symb.type.set(ID_C_template_arguments, specialization_template_args);
+
+#ifdef DEBUG
+    std::cout << "instance symbol: " << new_symb.name << std::endl << std::endl;
+    std::cout << "template type: " << template_type << std::endl << std::endl;
+#endif
 
     return new_symb;
   }

src/cpp/cpp_typecheck.cpp

@@ -53,6 +53,8 @@ void cpp_typecheckt::typecheck()
   for(auto &item : cpp_parse_tree.items)
     convert(item);
 
+  typecheck_method_bodies();
+
   static_and_dynamic_initialization();
 
   do_not_typechecked();

src/cpp/cpp_typecheck.h

@@ -338,13 +338,10 @@ class cpp_typecheckt:public c_typecheck_baset
   };
 
   typedef std::list<method_bodyt> method_bodiest;
+  std::set<irep_idt> methods_seen;
   method_bodiest method_bodies;
 
-  void add_method_body(symbolt *_method_symbol)
-  {
-    method_bodies.push_back(method_bodyt(
-      _method_symbol, template_map, instantiation_stack));
-  }
+  void add_method_body(symbolt *_method_symbol);
 
   // types
 
@@ -382,7 +379,7 @@ class cpp_typecheckt:public c_typecheck_baset
   void typecheck_compound_body(symbolt &symbol);
   void typecheck_compound_body(struct_union_typet &type) { UNREACHABLE; }
   void typecheck_enum_body(symbolt &symbol);
-  void typecheck_method_bodies(method_bodiest &);
+  void typecheck_method_bodies();
   void typecheck_compound_bases(struct_typet &type);
   void add_anonymous_members_to_scope(const symbolt &struct_union_symbol);
 

src/cpp/cpp_typecheck_compound_type.cpp

@@ -11,6 +11,10 @@ Author: Daniel Kroening, kroening@cs.cmu.edu
 
 #include "cpp_typecheck.h"
 
+#ifdef DEBUG
+#include <iostream>
+#endif
+
 #include <algorithm>
 
 #include <util/arith_tools.h>
@@ -378,7 +382,7 @@ void cpp_typecheckt::typecheck_compound_declarator(
   irep_idt identifier;
 
   // the below is a temporary hack
-  // if(is_method || is_static)d
+  // if(is_method || is_static)
   if(id2string(cpp_scopes.current_scope().prefix).find("#anon")==
      std::string::npos ||
      is_method || is_static)
@@ -882,12 +886,25 @@ void cpp_typecheckt::typecheck_friend_declaration(
   // It should be a friend function.
   // Do the declarators.
 
+#ifdef DEBUG
+  std::cout << "friend declaration: " << declaration.pretty() << std::endl;
+#endif
+
   for(auto &sub_it : declaration.declarators())
   {
-    bool has_value=sub_it.value().is_not_nil();
-
+#ifdef DEBUG
+    std::cout << "decl: " << sub_it->pretty() << "\n with value "
+	      << sub_it->value().pretty() << std::endl;
+    std::cout << "  scope: " << cpp_scopes.current_scope().prefix << std::endl;
+#endif
+    // In which scope are we going to typecheck this?
+#if 0
+    // TODO: not sure what the value is?!
+    bool has_value = sub_it.value().is_not_nil();
     if(!has_value)
     {
+      // TODO: This doesn't work if we are inside a template class declaration.
+
       // If no value is found, then we jump to the
       // global scope, and we convert the declarator
       // as if it were declared there
@@ -901,6 +918,7 @@ void cpp_typecheckt::typecheck_friend_declaration(
       symbol.type.add("#friends").move_to_sub(symb_expr);
     }
     else
+#endif
     {
       cpp_declarator_convertert cpp_declarator_converter(*this);
       cpp_declarator_converter.is_friend=true;

src/cpp/cpp_typecheck_declaration.cpp

@@ -6,6 +6,7 @@ Author: Daniel Kroening, kroening@cs.cmu.edu
 
 \********************************************************************/
 
+
 /// \file
 /// C++ Language Type Checking
 
@@ -19,21 +20,15 @@ void cpp_typecheckt::convert(cpp_declarationt &declaration)
   if(declaration.is_empty())
     return;
 
-  // Record the function bodies so we can check them later.
-  // This function is used recursively, so we save them.
-  method_bodiest old_method_bodies;
-  old_method_bodies.swap(method_bodies);
+  // The function bodies must not be checked here,
+  // but only at the very end when all declarations have been
+  // processed (or considering forward declarations at least)
 
   // templates are done in a dedicated function
   if(declaration.is_template())
     convert_template_declaration(declaration);
   else
     convert_non_template_declaration(declaration);
-
-  method_bodiest b;
-  b.swap(method_bodies);
-  typecheck_method_bodies(b);
-  method_bodies.swap(old_method_bodies);
 }
 
 void cpp_typecheckt::convert_anonymous_union(

src/cpp/cpp_typecheck_expr.cpp

@@ -433,6 +433,8 @@ bool cpp_typecheckt::overloadable(const exprt &expr)
       t=t.subtype();
 
     if(t.id()==ID_struct ||
+       //this might be an incomplete struct (template) here
+       t.id()==ID_incomplete_struct ||
        t.id()==ID_union ||
        t.id()==ID_c_enum)
       return true;
@@ -603,6 +605,7 @@ bool cpp_typecheckt::operator_is_overloaded(exprt &expr)
       // We try and fail silently, maybe conversions will work
       // instead.
 
+      //TODO: need to resolve an incomplete struct (template) here
       // go into scope of first operand
       if(expr.op0().type().id()==ID_symbol &&
          follow(expr.op0().type()).id()==ID_struct)
@@ -2362,7 +2365,26 @@ void cpp_typecheckt::typecheck_method_application(
   member_expr.swap(expr.function());
 
   const symbolt &symbol=lookup(member_expr.get(ID_component_name));
-  add_method_body(&symbol_table.get_writeable_ref(symbol.name));
+  symbolt &method_symbol=symbol_table.get_writeable_ref(symbol.name);
+  const symbolt &tag_symbol=lookup(symbol.type.get("#member_name"));
+
+  // build the right template map
+  // if this is an instantiated template class method
+  if(tag_symbol.type.find(ID_C_template)!=irept())
+  {
+    cpp_saved_template_mapt saved_map(template_map);
+    const irept &template_type=tag_symbol.type.find(ID_C_template);
+    const irept &template_args=tag_symbol.type.find(ID_C_template_arguments);
+    template_map.build(static_cast<const template_typet &>(template_type),
+		       static_cast<const cpp_template_args_tct &>(template_args));
+    add_method_body(&method_symbol);
+#ifdef DEBUG
+    std::cout << "MAP for " << symbol << ":" << std::endl;
+    template_map.print(std::cout);
+#endif
+  }
+  else
+    add_method_body(&method_symbol);
 
   // build new function expression
   exprt new_function(cpp_symbol_expr(symbol));

src/cpp/cpp_typecheck_method_bodies.cpp

@@ -9,19 +9,28 @@ Author: Daniel Kroening, kroening@cs.cmu.edu
 /// \file
 /// C++ Language Type Checking
 
+#ifdef DEBUG
+#include <iostream>
+#endif
+
 #include "cpp_typecheck.h"
 
-void cpp_typecheckt::typecheck_method_bodies(
-  method_bodiest &bodies)
+void cpp_typecheckt::typecheck_method_bodies()
 {
   instantiation_stackt old_instantiation_stack;
   old_instantiation_stack.swap(instantiation_stack);
 
-  for(auto &b : bodies)
+  while(!method_bodies.empty())
   {
-    symbolt &method_symbol=*b.method_symbol;
-    template_map.swap(b.template_map);
-    instantiation_stack.swap(b.instantiation_stack);
+    // Dangerous not to take a copy here. We'll have to make sure that
+    // convert is never called with the same symbol twice.
+    method_bodyt &method_body = *method_bodies.begin();
+    symbolt &method_symbol = *method_body.method_symbol;
+
+    template_map.swap(method_body.template_map);
+    instantiation_stack.swap(method_body.instantiation_stack);
+
+    method_bodies.erase(method_bodies.begin());
 
     if(method_symbol.name==ID_main)
       add_argc_argv(method_symbol);
@@ -30,6 +39,11 @@ void cpp_typecheckt::typecheck_method_bodies(
     if(body.id()=="cpp_not_typechecked")
       continue;
 
+#ifdef DEBUG
+  std::cout << "convert_method_body: " << method_symbol.name << std::endl;
+  std::cout << "  is_not_nil: " << body.is_not_nil() << std::endl;
+  std::cout << "  !is_zero: " << (!body.is_zero()) << std::endl;
+#endif
     if(body.is_not_nil() &&
        !body.is_zero())
     {
@@ -39,3 +53,26 @@ void cpp_typecheckt::typecheck_method_bodies(
 
   old_instantiation_stack.swap(instantiation_stack);
 }
+
+void cpp_typecheckt::add_method_body(symbolt *_method_symbol)
+{
+#ifdef DEBUG
+  std::cout << "add_method_body: " << _method_symbol->name << std::endl;
+#endif
+
+  // We have to prevent the same method to be added multiple times
+  //   otherwise we get duplicated symbol prefixes
+  if(methods_seen.find(_method_symbol->name) != methods_seen.end())
+  {
+#ifdef DEBUG
+    std::cout << "  already exists" << std::endl;
+#endif
+    return;
+  }
+  method_bodies.push_back(method_bodyt(
+			      _method_symbol, template_map, instantiation_stack));
+
+  // Converting a method body might add method bodies for methods
+  // that we have already analyzed. Hence, we have to keep track.
+  methods_seen.insert(_method_symbol->name);
+}