Made lookup return optional

This was requested in review and removes a lot of double map lookups (has_symbol followed by lookup)

Author: NathanJPhillips

src/ansi-c/ansi_c_entry_point.cpp

@@ -72,7 +72,7 @@ void record_function_outputs(
     codet output(ID_output);
     output.operands().resize(2);
 
-    const symbolt &return_symbol=symbol_table.lookup("return'");
+    const symbolt &return_symbol=*symbol_table.lookup("return'");
 
     output.op0()=
       address_of_exprt(

src/ansi-c/c_typecheck_base.cpp

@@ -121,7 +121,7 @@ void c_typecheck_baset::typecheck_symbol(symbolt &symbol)
       throw 0;
     }
 
-    symbolt & existing_symbol=symbol_table.get_writeable(symbol.name);
+    symbolt & existing_symbol=*symbol_table.get_writeable(symbol.name);
     if(symbol.is_type)
       typecheck_redefinition_type(existing_symbol, symbol);
     else
@@ -733,7 +733,7 @@ void c_typecheck_baset::typecheck_declaration(
       // add code contract (if any); we typecheck this after the
       // function body done above, so as to have parameter symbols
       // available
-      symbolt &new_symbol=symbol_table.get_writeable(identifier);
+      symbolt &new_symbol=*symbol_table.get_writeable(identifier);
 
       typecheck_spec_expr(contract, ID_C_spec_requires);
 

src/ansi-c/c_typecheck_type.cpp

@@ -208,7 +208,7 @@ void c_typecheck_baset::typecheck_type(typet &type)
       {
         const irep_idt &tag_name=
           to_c_enum_tag_type(type.subtype()).get_identifier();
-        symbol_table.get_writeable(tag_name).type.subtype()=result;
+        symbol_table.get_writeable(tag_name)->get().type.subtype()=result;
       }
 
       type=result;
@@ -782,7 +782,7 @@ void c_typecheck_baset::typecheck_compound_type(struct_union_typet &type)
           type.set(ID_tag, base_name);
 
           typecheck_compound_body(type);
-          symbol_table.get_writeable(s_it->first).type.swap(type);
+          symbol_table.get_writeable(s_it->first)->get().type.swap(type);
         }
       }
       else if(have_body)
@@ -1220,7 +1220,7 @@ void c_typecheck_baset::typecheck_c_enum_type(typet &type)
     {
       // Ok, overwrite the type in the symbol table.
       // This gives us the members and the subtype.
-      symbol_table.get_writeable(symbol.name).type=enum_tag_symbol.type;
+      symbol_table.get_writeable(symbol.name)->get().type=enum_tag_symbol.type;
     }
     else if(symbol.type.id()==ID_c_enum)
     {

src/cpp/cpp_declarator_converter.cpp

@@ -98,7 +98,10 @@ symbolt &cpp_declarator_convertert::convert(
     }
 
     // try static first
-    if(!cpp_typecheck.symbol_table.has_symbol(final_identifier))
+    symbol_tablet::opt_symbol_reft 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)
@@ -108,7 +111,8 @@ symbolt &cpp_declarator_convertert::convert(
       get_final_identifier();
 
       // try again
-      if(!cpp_typecheck.symbol_table.has_symbol(final_identifier))
+      maybe_symbol=cpp_typecheck.symbol_table.get_writeable(final_identifier);
+      if(!maybe_symbol)
       {
         cpp_typecheck.error().source_location=
           declarator.name().source_location();
@@ -120,7 +124,7 @@ symbolt &cpp_declarator_convertert::convert(
       }
     }
 
-    symbolt &symbol=cpp_typecheck.symbol_table.get_writeable(final_identifier);
+    symbolt &symbol=*maybe_symbol;
 
     combine_types(declarator.name().source_location(), final_type, symbol);
     enforce_rules(symbol);
@@ -187,10 +191,11 @@ symbolt &cpp_declarator_convertert::convert(
     }
 
     // already there?
-    if(!cpp_typecheck.symbol_table.has_symbol(final_identifier))
+    symbol_tablet::opt_symbol_reft maybe_symbol=
+      cpp_typecheck.symbol_table.get_writeable(final_identifier);
+    if(!maybe_symbol)
       return convert_new_symbol(storage_spec, member_spec, declarator);
-
-    symbolt &symbol=cpp_typecheck.symbol_table.get_writeable(final_identifier);
+    symbolt &symbol=*maybe_symbol;
 
     if(!storage_spec.is_extern())
       symbol.is_extern = false;

src/cpp/cpp_instantiate_template.cpp

@@ -372,7 +372,7 @@ const symbolt &cpp_typecheckt::instantiate_template(
   // been instantiated using these arguments
   {
     // need non-const handle on template symbol
-    symbolt &s=symbol_table.get_writeable(template_symbol.name);
+    symbolt &s=*symbol_table.get_writeable(template_symbol.name);
     irept &instantiated_with=s.value.add("instantiated_with");
     instantiated_with.get_sub().push_back(specialization_template_args);
   }
@@ -451,7 +451,7 @@ const symbolt &cpp_typecheckt::instantiate_template(
 
   if(is_template_method)
   {
-    symbolt &symb=symbol_table.get_writeable(class_name);
+    symbolt &symb=*symbol_table.get_writeable(class_name);
 
     assert(new_decl.declarators().size() == 1);
 

src/cpp/cpp_typecheck.cpp

@@ -153,7 +153,7 @@ void cpp_typecheckt::static_and_dynamic_initialization()
 
   for(const irep_idt &d_it : dynamic_initializations)
   {
-    const symbolt &symbol=symbol_table.lookup(d_it);
+    const symbolt &symbol=*symbol_table.lookup(d_it);
 
     if(symbol.is_extern)
       continue;
@@ -178,7 +178,7 @@ void cpp_typecheckt::static_and_dynamic_initialization()
 
       // Make it nil to get zero initialization by
       // __CPROVER_initialize
-      symbol_table.get_writeable(d_it).value.make_nil();
+      symbol_table.get_writeable(d_it)->get().value.make_nil();
     }
     else
     {
@@ -231,7 +231,7 @@ void cpp_typecheckt::do_not_typechecked()
          symbol.value.get_bool("is_used"))
       {
         assert(symbol.type.id()==ID_code);
-        symbolt &symbol=symbol_table.get_writeable(named_symbol.first);
+        symbolt &symbol=*symbol_table.get_writeable(named_symbol.first);
 
         if(symbol.base_name=="operator=")
         {
@@ -260,7 +260,7 @@ void cpp_typecheckt::do_not_typechecked()
   for(const auto &named_symbol : symbol_table.symbols)
   {
     if(named_symbol.second.value.id()=="cpp_not_typechecked")
-      symbol_table.get_writeable(named_symbol.first).value.make_nil();
+      symbol_table.get_writeable(named_symbol.first)->get().value.make_nil();
   }
 }
 
@@ -285,8 +285,8 @@ void cpp_typecheckt::clean_up()
             symbol.type.id()==ID_union)
     {
       // remove methods from 'components'
-      struct_union_typet &struct_union_type=
-        to_struct_union_type(symbol_table.get_writeable(cur_it->first).type);
+      struct_union_typet &struct_union_type=to_struct_union_type(
+        symbol_table.get_writeable(cur_it->first)->get().type);
 
       const struct_union_typet::componentst &components=
         struct_union_type.components();

src/cpp/cpp_typecheck_compound_type.cpp

@@ -159,17 +159,19 @@ void cpp_typecheckt::typecheck_compound_type(
 
   // check if we have it already
 
-  if(symbol_table.has_symbol(symbol_name))
+  symbol_tablet::opt_const_symbol_reft maybe_symbol=
+    symbol_table.lookup(symbol_name);
+  if(maybe_symbol)
   {
     // we do!
-    const symbolt &symbol=symbol_table.lookup(symbol_name);
+    const symbolt &symbol=*maybe_symbol;
 
     if(has_body)
     {
       if(symbol.type.id()=="incomplete_"+type.id_string())
       {
         // a previously incomplete struct/union becomes complete
-        symbolt &symbol=symbol_table.get_writeable(symbol_name);
+        symbolt &symbol=*symbol_table.get_writeable(symbol_name);
         symbol.type.swap(type);
         typecheck_compound_body(symbol);
       }
@@ -551,7 +553,7 @@ void cpp_typecheckt::typecheck_compound_declarator(
         put_compound_into_scope(compo);
       }
 
-      typet &vt=symbol_table.get_writeable(vt_name).type;
+      typet &vt=symbol_table.get_writeable(vt_name)->get().type;
       INVARIANT(vt.id()==ID_struct, "Virtual tables must be stored as struct");
       struct_typet &virtual_table=to_struct_type(vt);
 
@@ -1408,7 +1410,7 @@ void cpp_typecheckt::convert_anon_struct_union_member(
   struct_typet::componentst &components)
 {
   symbolt &struct_union_symbol=
-    symbol_table.get_writeable(follow(declaration.type()).get(ID_name));
+    *symbol_table.get_writeable(follow(declaration.type()).get(ID_name));
 
   if(declaration.storage_spec().is_static() ||
      declaration.storage_spec().is_mutable())

src/cpp/cpp_typecheck_declaration.cpp

@@ -75,7 +75,7 @@ void cpp_typecheckt::convert_anonymous_union(
 
   // do scoping
   symbolt union_symbol=
-    symbol_table.get_writeable(follow(symbol.type).get(ID_name));
+    *symbol_table.get_writeable(follow(symbol.type).get(ID_name));
   const irept::subt &components=union_symbol.type.add(ID_components).get_sub();
 
   forall_irep(it, components)
@@ -105,7 +105,7 @@ void cpp_typecheckt::convert_anonymous_union(
     id.is_member=true;
   }
 
-  symbol_table.get_writeable(union_symbol.name).type.set(
+  symbol_table.get_writeable(union_symbol.name)->get().type.set(
     "#unnamed_object", symbol.base_name);
 
   code.swap(new_code);

src/cpp/cpp_typecheck_expr.cpp

@@ -1244,7 +1244,8 @@ void cpp_typecheckt::typecheck_expr_member(
     assert(it!=symbol_table.symbols.end());
 
     if(it->second.value.id()=="cpp_not_typechecked")
-      symbol_table.get_writeable(component_name).value.set("is_used", true);
+      symbol_table.get_writeable(component_name)->get()
+        .value.set("is_used", true);
   }
 }
 
@@ -2202,7 +2203,7 @@ void cpp_typecheckt::typecheck_side_effect_function_call(
            type.id()==ID_code &&
            type.find(ID_return_type).id()==ID_destructor)
         {
-          add_method_body(&symbol_table.get_writeable(it->get(ID_name)));
+          add_method_body(&symbol_table.get_writeable(it->get(ID_name))->get());
           break;
         }
       }
@@ -2371,7 +2372,7 @@ 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(symbol.name));
+  add_method_body(&symbol_table.get_writeable(symbol.name)->get());
 
   // build new function expression
   exprt new_function(cpp_symbol_expr(symbol));
@@ -2413,7 +2414,7 @@ void cpp_typecheckt::typecheck_method_application(
   if(symbol.value.id()=="cpp_not_typechecked" &&
      !symbol.value.get_bool("is_used"))
   {
-    symbol_table.get_writeable(symbol.name).value.set("is_used", true);
+    symbol_table.get_writeable(symbol.name)->get().value.set("is_used", true);
   }
 }
 
@@ -2682,7 +2683,7 @@ void cpp_typecheckt::typecheck_expr_function_identifier(exprt &expr)
     assert(it != symbol_table.symbols.end());
 
     if(it->second.value.id()=="cpp_not_typechecked")
-      symbol_table.get_writeable(it->first).value.set("is_used", true);
+      symbol_table.get_writeable(it->first)->get().value.set("is_used", true);
   }
 
   c_typecheck_baset::typecheck_expr_function_identifier(expr);

src/cpp/cpp_typecheck_template.cpp

@@ -107,10 +107,12 @@ void cpp_typecheckt::typecheck_class_template(
 
   // check if we have it already
 
-  if(symbol_table.has_symbol(symbol_name))
+  symbol_tablet::opt_symbol_reft maybe_symbol=
+    symbol_table.get_writeable(symbol_name);
+  if(maybe_symbol)
   {
     // there already
-    auto &previous_symbol=symbol_table.get_writeable(symbol_name);
+    symbolt &previous_symbol=*maybe_symbol;
     cpp_declarationt &previous_declaration=
       to_cpp_declaration(previous_symbol.type);
 
@@ -263,7 +265,7 @@ void cpp_typecheckt::typecheck_function_template(
 
     if(has_value)
     {
-      symbol_table.get_writeable(symbol_name).type.swap(declaration);
+      symbol_table.get_writeable(symbol_name)->get().type.swap(declaration);
       cpp_scopes.id_map[symbol_name]=&template_scope;
     }
 
@@ -382,7 +384,7 @@ void cpp_typecheckt::typecheck_class_template_member(
 
   const cpp_idt &cpp_id=**(id_set.begin());
   symbolt &template_symbol=
-    symbol_table.get_writeable(cpp_id.identifier);
+    *symbol_table.get_writeable(cpp_id.identifier);
 
   exprt &template_methods=static_cast<exprt &>(
     template_symbol.value.add("template_methods"));