Use member operators instead of global-scope friends

Author: tautschnig

src/analyses/local_bitvector_analysis.h

@@ -167,20 +167,14 @@ class local_bitvector_analysist
     }
 
     void print(std::ostream &) const;
-  };
-
-  friend std::ostream & operator << (std::ostream &out, const flagst f)
-  {
-    f.print(out);
-    return out;
-  }
 
-  inline friend flagst operator|(const flagst f1, const flagst f2)
-  {
-    flagst result=f1;
-    result.bits|=f2.bits;
-    return result;
-  }
+    inline flagst operator|(const flagst other) const
+    {
+      flagst result(*this);
+      result.bits|=other.bits;
+      return result;
+    }
+  };
 
   flagst get(
     const goto_programt::const_targett t,
@@ -222,4 +216,12 @@ class local_bitvector_analysist
   bool is_tracked(const irep_idt &identifier);
 };
 
+inline std::ostream &operator<<(
+  std::ostream &out,
+  const local_bitvector_analysist::flagst &flags)
+{
+  flags.print(out);
+  return out;
+}
+
 #endif // CPROVER_ANALYSES_LOCAL_BITVECTOR_ANALYSIS_H

src/ansi-c/c_qualifiers.h

@@ -68,25 +68,21 @@ class c_qualifierst
     // is_transparent_union isn't checked
   }
 
-  friend bool operator == (
-    const c_qualifierst &a,
-    const c_qualifierst &b)
+  bool operator==(const c_qualifierst &other) const
   {
-    return a.is_constant==b.is_constant &&
-           a.is_volatile==b.is_volatile &&
-           a.is_restricted==b.is_restricted &&
-           a.is_atomic==b.is_atomic &&
-           a.is_ptr32==b.is_ptr32 &&
-           a.is_ptr64==b.is_ptr64 &&
-           a.is_transparent_union==b.is_transparent_union &&
-           a.is_noreturn==b.is_noreturn;
+    return is_constant==other.is_constant &&
+           is_volatile==other.is_volatile &&
+           is_restricted==other.is_restricted &&
+           is_atomic==other.is_atomic &&
+           is_ptr32==other.is_ptr32 &&
+           is_ptr64==other.is_ptr64 &&
+           is_transparent_union==other.is_transparent_union &&
+           is_noreturn==other.is_noreturn;
   }
 
-  friend bool operator != (
-    const c_qualifierst &a,
-    const c_qualifierst &b)
+  bool operator!=(const c_qualifierst &other) const
   {
-    return !(a==b);
+    return !(*this==other);
   }
 
   c_qualifierst &operator += (
@@ -103,10 +99,10 @@ class c_qualifierst
     return *this;
   }
 
-  friend unsigned count(const c_qualifierst &q)
+  unsigned count() const
   {
-    return q.is_constant+q.is_volatile+q.is_restricted+q.is_atomic+
-           q.is_ptr32+q.is_ptr64+q.is_noreturn;
+    return is_constant+is_volatile+is_restricted+is_atomic+
+           is_ptr32+is_ptr64+is_noreturn;
   }
 };
 

src/ansi-c/c_storage_spec.h

@@ -49,42 +49,36 @@ class c_storage_spect
   irep_idt asm_label;
   irep_idt section;
 
-  friend bool operator == (
-    const c_storage_spect &a,
-    const c_storage_spect &b)
+  bool operator==(const c_storage_spect &other) const
   {
-    return a.is_typedef==b.is_typedef &&
-           a.is_extern==b.is_extern &&
-           a.is_static==b.is_static &&
-           a.is_register==b.is_register &&
-           a.is_thread_local==b.is_thread_local &&
-           a.is_inline==b.is_inline &&
-           a.is_weak==b.is_weak &&
-           a.alias==b.alias &&
-           a.asm_label==b.asm_label &&
-           a.section==b.section;
+    return is_typedef==other.is_typedef &&
+           is_extern==other.is_extern &&
+           is_static==other.is_static &&
+           is_register==other.is_register &&
+           is_thread_local==other.is_thread_local &&
+           is_inline==other.is_inline &&
+           is_weak==other.is_weak &&
+           alias==other.alias &&
+           asm_label==other.asm_label &&
+           section==other.section;
   }
 
-  friend bool operator != (
-    const c_storage_spect &a,
-    const c_storage_spect &b)
+  bool operator!=(const c_storage_spect &other) const
   {
-    return !(a==b);
+    return !(*this==other);
   }
 
-  friend c_storage_spect &operator |= (
-    c_storage_spect &a,
-    const c_storage_spect &b)
+  c_storage_spect &operator|=(const c_storage_spect &other)
   {
-    a.is_typedef      |=b.is_typedef;
-    a.is_extern       |=b.is_extern;
-    a.is_static       |=b.is_static;
-    a.is_register     |=b.is_register;
-    a.is_inline       |=b.is_inline;
-    a.is_thread_local |=b.is_thread_local;
+    is_typedef      |=other.is_typedef;
+    is_extern       |=other.is_extern;
+    is_static       |=other.is_static;
+    is_register     |=other.is_register;
+    is_inline       |=other.is_inline;
+    is_thread_local |=other.is_thread_local;
     // attributes belong to the declarator, don't replace them
 
-    return a;
+    return *this;
   }
 
   void read(const typet &type);

src/ansi-c/c_typecast.cpp

@@ -620,7 +620,7 @@ void c_typecastt::implicit_typecast_followed(
         // build union constructor
         exprt union_expr(ID_union, orig_dest_type);
         union_expr.move_to_operands(expr);
-        if(!full_eq(src_type, src_type_no_const))
+        if(!src_type.full_eq(src_type_no_const))
           do_typecast(union_expr.op0(), src_type_no_const);
         union_expr.set(ID_component_name, comp.get_name());
         expr=union_expr;

src/ansi-c/string_constant.h

@@ -18,18 +18,6 @@ class string_constantt:public exprt
   string_constantt();
   explicit string_constantt(const irep_idt &value);
 
-  friend inline const string_constantt &to_string_constant(const exprt &expr)
-  {
-    assert(expr.id()==ID_string_constant);
-    return static_cast<const string_constantt &>(expr);
-  }
-
-  friend inline string_constantt &to_string_constant(exprt &expr)
-  {
-    assert(expr.id()==ID_string_constant);
-    return static_cast<string_constantt &>(expr);
-  }
-
   void set_value(const irep_idt &value);
 
   inline const irep_idt &get_value() const
@@ -41,7 +29,16 @@ class string_constantt:public exprt
   bool from_array_expr(const array_exprt &);
 };
 
-const string_constantt &to_string_constant(const exprt &expr);
-string_constantt &to_string_constant(exprt &expr);
+inline const string_constantt &to_string_constant(const exprt &expr)
+{
+  assert(expr.id()==ID_string_constant);
+  return static_cast<const string_constantt &>(expr);
+}
+
+inline string_constantt &to_string_constant(exprt &expr)
+{
+  assert(expr.id()==ID_string_constant);
+  return static_cast<string_constantt &>(expr);
+}
 
 #endif // CPROVER_ANSI_C_STRING_CONSTANT_H

src/cpp/cpp_typecheck_resolve.h

@@ -146,13 +146,12 @@ class cpp_typecheck_resolvet
            id(_id)
     {
     }
-  };
-
-  inline friend bool operator < (const matcht &m1, const matcht &m2)
-  {
-    return m1.cost<m2.cost;
-  }
 
+    inline bool operator<(const matcht &other) const
+    {
+      return cost<other.cost;
+    }
+  };
 };
 
 #endif // CPROVER_CPP_CPP_TYPECHECK_RESOLVE_H

src/goto-cc/xml_binaries/xml_irep_hashing.h

@@ -42,7 +42,7 @@ class xml_irep_convertt {
     {
       bool operator()(const irept &l, const irept &r) const
       {
-        return full_eq(l,r);
+        return l.full_eq(l,r);
       }
     };
 

src/goto-instrument/call_sequences.cpp

@@ -173,14 +173,14 @@ class check_call_sequencet
   {
     goto_functionst::function_mapt::const_iterator f;
     goto_programt::const_targett return_address;
-  };
 
-  friend bool operator==(const call_stack_entryt &e1,
-                         const call_stack_entryt &e2)
-  {
-    return e1.f->first==e2.f->first &&
-           e1.return_address==e2.return_address;
-  }
+    bool operator==(const call_stack_entryt &other) const
+    {
+      return
+        f->first==other.f->first &&
+        return_address==other.return_address;
+    }
+  };
 
   struct statet
   {
@@ -189,12 +189,13 @@ class check_call_sequencet
     std::vector<call_stack_entryt> call_stack;
     unsigned index;
 
-    friend bool operator==(const statet &s1, const statet &s2)
+    bool operator==(const statet &other) const
     {
-      return s1.f->first==s2.f->first &&
-             s1.pc==s2.pc &&
-             s1.call_stack==s2.call_stack &&
-             s1.index==s2.index;
+      return
+        f->first==other.f->first &&
+        pc==other.pc &&
+        call_stack==other.call_stack &&
+        index==other.index;
     }
   };
 

src/goto-instrument/object_id.h

@@ -30,22 +30,26 @@ class object_idt
     id=identifier;
   }
 
-  friend std::ostream &operator << (std::ostream &out, const object_idt &x)
+  inline bool operator<(const object_idt &other) const
   {
-    return out << x.id;
+    return id < other.id;
   }
 
-  friend inline bool operator < (const object_idt &a, const object_idt &b)
+  const irep_idt &get_id() const
   {
-    return a.id < b.id;
+    return id;
   }
 
 protected:
   irep_idt id;
 };
 
-inline std::ostream &operator << (std::ostream &, const object_idt &);
-inline bool operator < (const object_idt &a, const object_idt &b);
+inline std::ostream &operator<<(
+  std::ostream &out,
+  const object_idt &object_id)
+{
+  return out << object_id.get_id();
+}
 
 typedef std::set<object_idt> object_id_sett;
 

src/goto-instrument/points_to.h

@@ -49,13 +49,6 @@ class points_tot
 
   void output(std::ostream &out) const;
 
-  inline friend std::ostream &operator << (
-    std::ostream &out, const points_tot &points_to)
-  {
-    points_to.output(out);
-    return out;
-  }
-
 protected:
   typedef cfg_baset<empty_cfg_nodet> cfgt;
   cfgt cfg;
@@ -69,6 +62,12 @@ class points_tot
   const object_id_sett empty_set;
 };
 
-std::ostream &operator << (std::ostream &, const points_tot &);
+inline std::ostream &operator<<(
+  std::ostream &out,
+  const points_tot &points_to)
+{
+  points_to.output(out);
+  return out;
+}
 
 #endif // CPROVER_GOTO_INSTRUMENT_POINTS_TO_H

src/goto-instrument/wmm/abstract_event.h

@@ -91,11 +91,6 @@ class abstract_eventt:public graph_nodet<empty_edget>
   inline bool is_fence() const {
     return operation==Fence || operation==Lwfence || operation==ASMfence;}
 
-  friend std::ostream& operator<<(std::ostream& s, const abstract_eventt& e)
-  {
-    return s << e.get_operation() << e.variable;
-  }
-
   /* checks the safety of the pair locally (i.e., w/o taking fences
      or dependencies into account -- use is_unsafe on the whole
      critical cycle for this) */
@@ -152,4 +147,12 @@ class abstract_eventt:public graph_nodet<empty_edget>
     return value;
   }
 };
+
+inline std::ostream& operator<<(
+  std::ostream& s,
+  const abstract_eventt &e)
+{
+  return s << e.get_operation() << e.variable;
+}
+
 #endif // CPROVER_GOTO_INSTRUMENT_WMM_ABSTRACT_EVENT_H

src/java_bytecode/java_bytecode_convert_method.cpp

@@ -41,21 +41,26 @@ class patternt
   }
 
   // match with '?'
-  friend bool operator==(const irep_idt &what, const patternt &pattern)
+  bool operator==(const irep_idt &what) const
   {
     for(std::size_t i=0; i<what.size(); i++)
-      if(pattern.p[i]==0)
+      if(p[i]==0)
         return false;
-      else if(pattern.p[i]!='?' && pattern.p[i]!=what[i])
+      else if(p[i]!='?' && p[i]!=what[i])
         return false;
 
-    return pattern.p[what.size()]==0;
+    return p[what.size()]==0;
   }
 
 protected:
   const char *p;
 };
 
+static bool operator==(const irep_idt &what, const patternt &pattern)
+{
+  return pattern==what;
+}
+
 const size_t SLOTS_PER_INTEGER(1u);
 const size_t INTEGER_WIDTH(64u);
 static size_t count_slots(

src/java_bytecode/java_entry_point.cpp

@@ -220,7 +220,7 @@ exprt::operandst java_build_arguments(
         to_code_type(function.type).return_type().id()==ID_empty &&
         (!to_code_type(function.type).has_this()) &&
         parameters.size()==1 &&
-        full_eq(parameters[0].type(), string_array_type);
+        parameters[0].type().full_eq(string_array_type);
       is_main=(named_main && has_correct_type);
     }