Merge pull request #5785 from tautschnig/forall-irep

tautschnig · web-flow · commit 2c115019efc4 · 2021-01-29T18:12:28.000+01:00
Remove {f,F}orall_irep
diff --git a/.clang-format b/.clang-format
@@ -38,8 +38,6 @@ ForEachMacros: [
   'Forall_operands',
   'forall_expr',
   'Forall_expr',
-  'forall_irep',
-  'Forall_irep',
   'forall_symbol_base_map',
   'forall_subtypes',
   'Forall_subtypes']
diff --git a/src/ansi-c/c_typecheck_expr.cpp b/src/ansi-c/c_typecheck_expr.cpp
@@ -433,26 +433,30 @@ void c_typecheck_baset::typecheck_expr_main(exprt &expr)
       expr.add(ID_generic_associations).get_sub();
 
     // first typecheck all types
-    Forall_irep(it, generic_associations)
-      if(it->get(ID_type_arg)!=ID_default)
+    for(auto &irep : generic_associations)
+    {
+      if(irep.get(ID_type_arg) != ID_default)
       {
-        typet &type=static_cast<typet &>(it->add(ID_type_arg));
+        typet &type = static_cast<typet &>(irep.add(ID_type_arg));
         typecheck_type(type);
       }
+    }
 
     // first try non-default match
     exprt default_match=nil_exprt();
     exprt assoc_match=nil_exprt();
 
     const typet &op_type = follow(op.type());
 
-    forall_irep(it, generic_associations)
+    for(const auto &irep : generic_associations)
     {
-      if(it->get(ID_type_arg)==ID_default)
-        default_match=static_cast<const exprt &>(it->find(ID_value));
-      else if(op_type==
-              follow(static_cast<const typet &>(it->find(ID_type_arg))))
-        assoc_match=static_cast<const exprt &>(it->find(ID_value));
+      if(irep.get(ID_type_arg) == ID_default)
+        default_match = static_cast<const exprt &>(irep.find(ID_value));
+      else if(
+        op_type == follow(static_cast<const typet &>(irep.find(ID_type_arg))))
+      {
+        assoc_match = static_cast<const exprt &>(irep.find(ID_value));
+      }
     }
 
     if(assoc_match.is_nil())
diff --git a/src/ansi-c/parser_static.inc b/src/ansi-c/parser_static.inc
@@ -410,10 +410,10 @@ static void adjust_KnR_parameters(
 
       // we just do a linear search over the parameters
       // this could be improved with a hash map
-      Forall_irep(a_it, parameters.get_sub())
+      for(auto &parameter : parameters.get_sub())
       {
         ansi_c_declarationt &p_decl=
-          to_ansi_c_declaration(static_cast<exprt &>(*a_it));
+          to_ansi_c_declaration(static_cast<exprt &>(parameter));
 
         if(p_decl.declarator().get_base_name()==base_name)
         {
diff --git a/src/cpp/cpp_convert_type.cpp b/src/cpp/cpp_convert_type.cpp
@@ -129,9 +129,9 @@ void cpp_convert_typet::read_template(const typet &type)
 
   irept &arguments=t.add(ID_arguments);
 
-  Forall_irep(it, arguments.get_sub())
+  for(auto &argument : arguments.get_sub())
   {
-    exprt &decl=static_cast<exprt &>(*it);
+    exprt &decl = static_cast<exprt &>(argument);
 
     // may be type or expression
     bool is_type=decl.get_bool(ID_is_type);
diff --git a/src/cpp/cpp_declarator_converter.cpp b/src/cpp/cpp_declarator_converter.cpp
@@ -572,9 +572,9 @@ irep_idt cpp_declarator_convertert::get_pretty_name()
 
     std::string result=scope->prefix+id2string(base_name)+"(";
 
-    forall_irep(it, parameters)
+    for(auto it = parameters.begin(); it != parameters.end(); ++it)
     {
-      const typet &parameter_type=((exprt &)*it).type();
+      const typet &parameter_type = ((exprt &)*it).type();
 
       if(it!=parameters.begin())
         result+=", ";
diff --git a/src/cpp/cpp_enum_type.cpp b/src/cpp/cpp_enum_type.cpp
@@ -26,10 +26,10 @@ irep_idt cpp_enum_typet::generate_anon_tag() const
 
   std::string result="#anonE";
 
-  forall_irep(it, b)
+  for(const auto &value : b)
   {
     result+='#';
-    result+=id2string(it->get(ID_name));
+    result += id2string(value.get(ID_name));
   }
 
   return result;
diff --git a/src/cpp/cpp_name.cpp b/src/cpp/cpp_name.cpp
@@ -44,14 +44,14 @@ void cpp_namet::convert(
   std::string &identifier,
   std::string &base_name) const
 {
-  forall_irep(it, get_sub())
+  for(const auto &irep : get_sub())
   {
-    const irep_idt id=it->id();
+    const irep_idt id = irep.id();
 
     std::string name_component;
 
     if(id==ID_name)
-      name_component=it->get_string(ID_identifier);
+      name_component = irep.get_string(ID_identifier);
     else if(id==ID_template_args)
     {
       std::stringstream ss;
@@ -60,7 +60,7 @@ void cpp_namet::convert(
       throw ss.str();
     }
     else
-      name_component=it->id_string();
+      name_component = irep.id_string();
 
     identifier+=name_component;
 
@@ -76,14 +76,14 @@ std::string cpp_namet::to_string() const
 {
   std::string str;
 
-  forall_irep(it, get_sub())
+  for(const auto &irep : get_sub())
   {
-    if(it->id()=="::")
-      str += it->id_string();
-    else if(it->id()==ID_template_args)
+    if(irep.id() == "::")
+      str += irep.id_string();
+    else if(irep.id() == ID_template_args)
       str += "<...>";
     else
-      str+=it->get_string(ID_identifier);
+      str += irep.get_string(ID_identifier);
   }
 
   return str;
diff --git a/src/cpp/cpp_name.h b/src/cpp/cpp_name.h
@@ -108,9 +108,11 @@ class cpp_namet:public irept
 
   bool is_qualified() const
   {
-    forall_irep(it, get_sub())
-      if(it->id()=="::")
+    for(const auto &irep : get_sub())
+    {
+      if(irep.id() == "::")
         return true;
+    }
     return false;
   }
 
@@ -121,9 +123,11 @@ class cpp_namet:public irept
 
   bool has_template_args() const
   {
-    forall_irep(it, get_sub())
-      if(it->id()==ID_template_args)
+    for(const auto &irep : get_sub())
+    {
+      if(irep.id() == ID_template_args)
         return true;
+    }
 
     return false;
   }
diff --git a/src/cpp/cpp_type2name.cpp b/src/cpp/cpp_type2name.cpp
@@ -84,13 +84,13 @@ static std::string irep2name(const irept &irep)
     }
   }
 
-  forall_irep(it, irep.get_sub())
+  for(const auto &sub : irep.get_sub())
   {
     if(first)
       first=false;
     else
       result+=',';
-    result += irep2name(*it);
+    result += irep2name(sub);
   }
 
   result+=')';
diff --git a/src/cpp/cpp_typecheck_bases.cpp b/src/cpp/cpp_typecheck_bases.cpp
@@ -22,10 +22,9 @@ void cpp_typecheckt::typecheck_compound_bases(struct_typet &type)
 
   irept::subt &bases_irep=type.add(ID_bases).get_sub();
 
-  Forall_irep(base_it, bases_irep)
+  for(auto &base : bases_irep)
   {
-    const cpp_namet &name=
-      to_cpp_name(base_it->find(ID_name));
+    const cpp_namet &name = to_cpp_name(base.find(ID_name));
 
     exprt base_symbol_expr=
       resolve(
@@ -68,8 +67,8 @@ void cpp_typecheckt::typecheck_compound_bases(struct_typet &type)
       throw 0;
     }
 
-    bool virtual_base = base_it->get_bool(ID_virtual);
-    irep_idt class_access = base_it->get(ID_protection);
+    bool virtual_base = base.get_bool(ID_virtual);
+    irep_idt class_access = base.get(ID_protection);
 
     if(class_access.empty())
       class_access = default_class_access;
@@ -80,7 +79,7 @@ void cpp_typecheckt::typecheck_compound_bases(struct_typet &type)
     if(virtual_base)
       base_symbol_expr.set(ID_virtual, true);
 
-    base_it->swap(base_symbol_expr);
+    base.swap(base_symbol_expr);
 
     // Add base scopes as parents to the current scope
     cpp_scopes.current_scope().add_secondary_scope(
diff --git a/src/cpp/cpp_typecheck_compound_type.cpp b/src/cpp/cpp_typecheck_compound_type.cpp
@@ -1257,9 +1257,10 @@ void cpp_typecheckt::move_member_initializers(
       value = code_blockt{{to_code(value)}};
 
     exprt::operandst::iterator o_it=value.operands().begin();
-    forall_irep(it, initializers.get_sub())
+    for(const auto &initializer : initializers.get_sub())
     {
-      o_it=value.operands().insert(o_it, static_cast<const exprt &>(*it));
+      o_it =
+        value.operands().insert(o_it, static_cast<const exprt &>(initializer));
       o_it++;
     }
   }
@@ -1620,10 +1621,8 @@ bool cpp_typecheckt::check_component_access(
   // check friendship
   const irept::subt &friends = struct_union_type.find(ID_C_friends).get_sub();
 
-  forall_irep(f_it, friends)
+  for(const auto &friend_symb : friends)
   {
-    const irept &friend_symb=*f_it;
-
     const cpp_scopet &friend_scope =
       cpp_scopes.get_scope(friend_symb.get(ID_identifier));
 
diff --git a/src/cpp/cpp_typecheck_constructor.cpp b/src/cpp/cpp_typecheck_constructor.cpp
@@ -423,9 +423,8 @@ void cpp_typecheckt::check_member_initializers(
 {
   assert(initializers.id()==ID_member_initializers);
 
-  forall_irep(init_it, initializers.get_sub())
+  for(const auto &initializer : initializers.get_sub())
   {
-    const irept &initializer=*init_it;
     assert(initializer.is_not_nil());
 
     const cpp_namet &member_name=
@@ -601,10 +600,8 @@ void cpp_typecheckt::full_member_initialization(
       // explicitly calls the parent constructor.
       bool found=false;
 
-      forall_irep(m_it, initializers.get_sub())
+      for(irept initializer : initializers.get_sub())
       {
-        irept initializer=*m_it;
-
         const cpp_namet &member_name=
           to_cpp_name(initializer.find(ID_member));
 
@@ -715,10 +712,8 @@ void cpp_typecheckt::full_member_initialization(
     // Check if the initialization list of the constructor
     // explicitly initializes the data member
     bool found=false;
-    Forall_irep(m_it, initializers.get_sub())
+    for(auto &initializer : initializers.get_sub())
     {
-      irept &initializer=*m_it;
-
       if(initializer.get(ID_member)!=ID_cpp_name)
         continue;
       cpp_namet &member_name=(cpp_namet&) initializer.add(ID_member);
diff --git a/src/cpp/cpp_typecheck_enum_type.cpp b/src/cpp/cpp_typecheck_enum_type.cpp
@@ -30,13 +30,13 @@ void cpp_typecheckt::typecheck_enum_body(symbolt &enum_symbol)
 
   mp_integer i=0;
 
-  Forall_irep(it, components)
+  for(auto &component : components)
   {
-    const irep_idt &name=it->get(ID_name);
+    const irep_idt &name = component.get(ID_name);
 
-    if(it->find(ID_value).is_not_nil())
+    if(component.find(ID_value).is_not_nil())
     {
-      exprt &value=static_cast<exprt &>(it->add(ID_value));
+      exprt &value = static_cast<exprt &>(component.add(ID_value));
       typecheck_expr(value);
       implicit_typecast(value, c_enum_type.subtype());
       make_constant(value);
@@ -56,8 +56,8 @@ void cpp_typecheckt::typecheck_enum_body(symbolt &enum_symbol)
     symbol.name=id2string(enum_symbol.name)+"::"+id2string(name);
     symbol.base_name=name;
     symbol.value=value_expr;
-    symbol.location=
-      static_cast<const source_locationt &>(it->find(ID_C_source_location));
+    symbol.location = static_cast<const source_locationt &>(
+      component.find(ID_C_source_location));
     symbol.mode = enum_symbol.mode;
     symbol.module=module;
     symbol.type=enum_tag_type;
diff --git a/src/cpp/expr2cpp.cpp b/src/cpp/expr2cpp.cpp
@@ -232,7 +232,7 @@ std::string expr2cppt::convert_rec(
 
     const irept::subt &arguments=src.find(ID_arguments).get_sub();
 
-    forall_irep(it, arguments)
+    for(auto it = arguments.begin(); it != arguments.end(); ++it)
     {
       if(it!=arguments.begin())
         dest+=", ";
diff --git a/src/cpp/parse.cpp b/src/cpp/parse.cpp
@@ -1756,12 +1756,14 @@ bool Parser::rOtherDeclaration(
     assert(!type_name.get_sub().empty());
 
     bool is_destructor=false;
-    forall_irep(it, type_name.get_sub())
-      if(it->id()=="~")
+    for(const auto &irep : type_name.get_sub())
+    {
+      if(irep.id() == "~")
       {
         is_destructor=true;
         break;
       }
+    }
 
     cpp_declaratort constructor_declarator;
     typet trailing_return_type;
diff --git a/src/cpp/template_map.cpp b/src/cpp/template_map.cpp
@@ -54,10 +54,10 @@ void template_mapt::apply(typet &type) const
 
     irept::subt &parameters=type.add(ID_parameters).get_sub();
 
-    Forall_irep(it, parameters)
+    for(auto &parameter : parameters)
     {
-      if(it->id()==ID_parameter)
-        apply(static_cast<typet &>(it->add(ID_type)));
+      if(parameter.id() == ID_parameter)
+        apply(static_cast<typet &>(parameter.add(ID_type)));
     }
   }
   else if(type.id()==ID_merged_type)
diff --git a/src/goto-instrument/dump_c.cpp b/src/goto-instrument/dump_c.cpp
@@ -436,26 +436,27 @@ void dump_ct::convert_compound(
 
   const irept &bases = type.find(ID_bases);
   std::stringstream base_decls;
-  forall_irep(parent_it, bases.get_sub())
+  for(const auto &parent : bases.get_sub())
   {
     UNREACHABLE;
-    /*
-    assert(parent_it->id() == ID_base);
-    assert(parent_it->get(ID_type) == ID_struct_tag);
+    (void)parent;
+#if 0
+    assert(parent.id() == ID_base);
+    assert(parent.get(ID_type) == ID_struct_tag);
 
     const irep_idt &base_id=
-      parent_it->find(ID_type).get(ID_identifier);
+      parent.find(ID_type).get(ID_identifier);
     const irep_idt &renamed_base_id=global_renaming[base_id];
     const symbolt &parsymb=ns.lookup(renamed_base_id);
 
     convert_compound_rec(parsymb.type, os);
 
     base_decls << id2string(renamed_base_id) +
       (parent_it+1==bases.get_sub().end()?"":", ");
-      */
+#endif
   }
 
-  /*
+#if 0
   // for the constructor
   string constructor_args;
   string constructor_body;
@@ -471,7 +472,7 @@ void dump_ct::convert_compound(
   constructor_args += "const " + type_to_string(compo.type()) + "& " + component_name;
 
   constructor_body += indent + indent + "this->"+component_name + " = " + component_name + ";\n";
-  */
+#endif
 
   std::stringstream struct_body;
 
diff --git a/src/util/irep.cpp b/src/util/irep.cpp
diff --git a/src/util/irep.h b/src/util/irep.h
diff --git a/src/util/irep_hash_container.cpp b/src/util/irep_hash_container.cpp
diff --git a/src/util/irep_serialization.cpp b/src/util/irep_serialization.cpp
diff --git a/src/util/lispirep.cpp b/src/util/lispirep.cpp
diff --git a/src/util/merge_irep.cpp b/src/util/merge_irep.cpp
diff --git a/src/util/xml_irep.cpp b/src/util/xml_irep.cpp

Original file line number	Diff line number	Diff line change
`@@ -410,10 +410,10 @@ static void adjust_KnR_parameters(`
`410`	`410`
`411`	`411`	`// we just do a linear search over the parameters`
`412`	`412`	`// this could be improved with a hash map`
`413`		`- Forall_irep(a_it, parameters.get_sub())`
	`413`	`+ for(auto &parameter : parameters.get_sub())`
`414`	`414`	`{`
`415`	`415`	`ansi_c_declarationt &p_decl=`
`416`		`- to_ansi_c_declaration(static_cast<exprt &>(*a_it));`
	`416`	`+ to_ansi_c_declaration(static_cast<exprt &>(parameter));`
`417`	`417`
`418`	`418`	`if(p_decl.declarator().get_base_name()==base_name)`
`419`	`419`	`{`
Original file line number	Diff line number	Diff line change
`@@ -129,9 +129,9 @@ void cpp_convert_typet::read_template(const typet &type)`
`129`	`129`
`130`	`130`	`irept &arguments=t.add(ID_arguments);`
`131`	`131`
`132`		`- Forall_irep(it, arguments.get_sub())`
	`132`	`+ for(auto &argument : arguments.get_sub())`
`133`	`133`	`{`
`134`		`- exprt &decl=static_cast<exprt &>(*it);`
	`134`	`+ exprt &decl = static_cast<exprt &>(argument);`
`135`	`135`
`136`	`136`	`// may be type or expression`
`137`	`137`	`bool is_type=decl.get_bool(ID_is_type);`
Original file line number	Diff line number	Diff line change
`@@ -572,9 +572,9 @@ irep_idt cpp_declarator_convertert::get_pretty_name()`
`572`	`572`
`573`	`573`	`std::string result=scope->prefix+id2string(base_name)+"(";`
`574`	`574`
`575`		`- forall_irep(it, parameters)`
	`575`	`+ for(auto it = parameters.begin(); it != parameters.end(); ++it)`
`576`	`576`	`{`
`577`		`- const typet &parameter_type=((exprt &)*it).type();`
	`577`	`+ const typet &parameter_type = ((exprt &)*it).type();`
`578`	`578`
`579`	`579`	`if(it!=parameters.begin())`
`580`	`580`	`result+=", ";`
Original file line number	Diff line number	Diff line change
`@@ -26,10 +26,10 @@ irep_idt cpp_enum_typet::generate_anon_tag() const`
`26`	`26`
`27`	`27`	`std::string result="#anonE";`
`28`	`28`
`29`		`- forall_irep(it, b)`
	`29`	`+ for(const auto &value : b)`
`30`	`30`	`{`
`31`	`31`	`result+='#';`
`32`		`- result+=id2string(it->get(ID_name));`
	`32`	`+ result += id2string(value.get(ID_name));`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`return result;`
Original file line number	Diff line number	Diff line change
`@@ -44,14 +44,14 @@ void cpp_namet::convert(`
`44`	`44`	`std::string &identifier,`
`45`	`45`	`std::string &base_name) const`
`46`	`46`	`{`
`47`		`- forall_irep(it, get_sub())`
	`47`	`+ for(const auto &irep : get_sub())`
`48`	`48`	`{`
`49`		`- const irep_idt id=it->id();`
	`49`	`+ const irep_idt id = irep.id();`
`50`	`50`
`51`	`51`	`std::string name_component;`
`52`	`52`
`53`	`53`	`if(id==ID_name)`
`54`		`- name_component=it->get_string(ID_identifier);`
	`54`	`+ name_component = irep.get_string(ID_identifier);`
`55`	`55`	`else if(id==ID_template_args)`
`56`	`56`	`{`
`57`	`57`	`std::stringstream ss;`
`@@ -60,7 +60,7 @@ void cpp_namet::convert(`
`60`	`60`	`throw ss.str();`
`61`	`61`	`}`
`62`	`62`	`else`
`63`		`- name_component=it->id_string();`
	`63`	`+ name_component = irep.id_string();`
`64`	`64`
`65`	`65`	`identifier+=name_component;`
`66`	`66`
`@@ -76,14 +76,14 @@ std::string cpp_namet::to_string() const`
`76`	`76`	`{`
`77`	`77`	`std::string str;`
`78`	`78`
`79`		`- forall_irep(it, get_sub())`
	`79`	`+ for(const auto &irep : get_sub())`
`80`	`80`	`{`
`81`		`- if(it->id()=="::")`
`82`		`- str += it->id_string();`
`83`		`- else if(it->id()==ID_template_args)`
	`81`	`+ if(irep.id() == "::")`
	`82`	`+ str += irep.id_string();`
	`83`	`+ else if(irep.id() == ID_template_args)`
`84`	`84`	`str += "<...>";`
`85`	`85`	`else`
`86`		`- str+=it->get_string(ID_identifier);`
	`86`	`+ str += irep.get_string(ID_identifier);`
`87`	`87`	`}`
`88`	`88`
`89`	`89`	`return str;`
Original file line number	Diff line number	Diff line change
`@@ -108,9 +108,11 @@ class cpp_namet:public irept`
`108`	`108`
`109`	`109`	`bool is_qualified() const`
`110`	`110`	`{`
`111`		`- forall_irep(it, get_sub())`
`112`		`- if(it->id()=="::")`
	`111`	`+ for(const auto &irep : get_sub())`
	`112`	`+ {`
	`113`	`+ if(irep.id() == "::")`
`113`	`114`	`return true;`
	`115`	`+ }`
`114`	`116`	`return false;`
`115`	`117`	`}`
`116`	`118`
`@@ -121,9 +123,11 @@ class cpp_namet:public irept`
`121`	`123`
`122`	`124`	`bool has_template_args() const`
`123`	`125`	`{`
`124`		`- forall_irep(it, get_sub())`
`125`		`- if(it->id()==ID_template_args)`
	`126`	`+ for(const auto &irep : get_sub())`
	`127`	`+ {`
	`128`	`+ if(irep.id() == ID_template_args)`
`126`	`129`	`return true;`
	`130`	`+ }`
`127`	`131`
`128`	`132`	`return false;`
`129`	`133`	`}`
Original file line number	Diff line number	Diff line change
`@@ -84,13 +84,13 @@ static std::string irep2name(const irept &irep)`
`84`	`84`	`}`
`85`	`85`	`}`
`86`	`86`
`87`		`- forall_irep(it, irep.get_sub())`
	`87`	`+ for(const auto &sub : irep.get_sub())`
`88`	`88`	`{`
`89`	`89`	`if(first)`
`90`	`90`	`first=false;`
`91`	`91`	`else`
`92`	`92`	`result+=',';`
`93`		`- result += irep2name(*it);`
	`93`	`+ result += irep2name(sub);`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`result+=')';`