Rename component_name to mangled_method_name

The component to which a `class_method_descriptor_exprt` is referring to
is specifically a particular overload of a method. The particular
overload is distinguished based on a mangling process. Therefore
`mangled_method_name` more accurately describes that this component is
the the mangled name of a method, as opposed to any other kind of class
component such as a field.

Author: thomasspriggs

jbmc/src/java_bytecode/ci_lazy_methods.cpp

@@ -292,13 +292,13 @@ bool ci_lazy_methodst::handle_virtual_methods_with_no_callees(
     }
 
     // Check that `get_virtual_method_target` returns a method now
-    const irep_idt &call_basename = virtual_function.get_component_name();
-    const irep_idt method_name = get_virtual_method_target(
-      instantiated_classes, call_basename, call_class, symbol_table);
-    CHECK_RETURN(!method_name.empty());
+    const irep_idt &method_name = virtual_function.mangled_method_name();
+    const irep_idt method_id = get_virtual_method_target(
+      instantiated_classes, method_name, call_class, symbol_table);
+    CHECK_RETURN(!method_id.empty());
 
     // Add what it returns to methods_to_convert_later
-    methods_to_convert_later.insert(method_name);
+    methods_to_convert_later.insert(method_id);
   }
   return any_new_classes;
 }
@@ -480,9 +480,9 @@ void ci_lazy_methodst::get_virtual_method_targets(
   const auto &call_class = called_function.class_id();
   INVARIANT(
     !call_class.empty(), "All virtual calls should be aimed at a class");
-  const auto &call_basename = called_function.get_component_name();
+  const auto &method_name = called_function.mangled_method_name();
   INVARIANT(
-    !call_basename.empty(),
+    !method_name.empty(),
     "Virtual function must have a reasonable name after removing class");
 
   class_hierarchyt::idst self_and_child_classes =
@@ -491,10 +491,10 @@ void ci_lazy_methodst::get_virtual_method_targets(
 
   for(const irep_idt &class_name : self_and_child_classes)
   {
-    const irep_idt method_name = get_virtual_method_target(
-      instantiated_classes, call_basename, class_name, symbol_table);
-    if(!method_name.empty())
-      callable_methods.insert(method_name);
+    const irep_idt method_id = get_virtual_method_target(
+      instantiated_classes, method_name, class_name, symbol_table);
+    if(!method_id.empty())
+      callable_methods.insert(method_id);
   }
 }
 

jbmc/src/java_bytecode/expr2java.cpp

@@ -423,7 +423,7 @@ std::string expr2javat::convert_with_precedence(
     const class_method_descriptor_exprt &virtual_function =
       to_class_method_descriptor_expr(src);
     return "CLASS_METHOD_DESCRIPTOR(" + id2string(virtual_function.class_id()) +
-           "." + id2string(virtual_function.get_component_name()) + ")";
+           "." + id2string(virtual_function.mangled_method_name()) + ")";
   }
   else if(
     const auto &literal = expr_try_dynamic_cast<java_string_literal_exprt>(src))

jbmc/src/java_bytecode/java_bytecode_convert_method.cpp

@@ -2268,7 +2268,7 @@ void java_bytecode_convert_methodt::convert_invoke(
     method_symbol == symbol_table.symbols.end() &&
     !(is_virtual && is_method_inherited(
                       class_method_descriptor.class_id(),
-                      class_method_descriptor.get_component_name())))
+                      class_method_descriptor.mangled_method_name())))
   {
     create_method_stub_symbol(
       invoked_method_id,
@@ -3222,13 +3222,13 @@ void java_bytecode_convert_method(
 /// a method inherited from a class (and not an interface!) from which
 /// \p classname inherits, either directly or indirectly.
 /// \param classname: class whose method is referenced
-/// \param methodid: method basename
+/// \param mangled_method_name: The particular overload of a given method.
 bool java_bytecode_convert_methodt::is_method_inherited(
   const irep_idt &classname,
-  const irep_idt &methodid) const
+  const irep_idt &mangled_method_name) const
 {
-  const auto inherited_method =
-    get_inherited_component(classname, methodid, symbol_table, false);
+  const auto inherited_method = get_inherited_component(
+    classname, mangled_method_name, symbol_table, false);
   return inherited_method.has_value();
 }
 

jbmc/src/java_bytecode/java_bytecode_convert_method_class.h

@@ -311,7 +311,7 @@ class java_bytecode_convert_methodt:public messaget
 
   bool is_method_inherited(
     const irep_idt &classname,
-    const irep_idt &methodid) const;
+    const irep_idt &mangled_method_name) const;
 
   irep_idt get_static_field(
     const irep_idt &class_identifier, const irep_idt &component_name) const;

jbmc/src/java_bytecode/java_bytecode_parser.cpp

@@ -754,17 +754,17 @@ void java_bytecode_parsert::rconstant_pool()
 
         auto class_tag = java_classname(id2string(class_name_entry.s));
 
-        irep_idt component_name=
-          id2string(name_entry.s)+
-          ":"+id2string(pool_entry(nameandtype_entry.ref2).s);
+        irep_idt mangled_method_name =
+          id2string(name_entry.s) + ":" +
+          id2string(pool_entry(nameandtype_entry.ref2).s);
 
         irep_idt class_id = class_tag.get_identifier();
 
         irep_idt identifier =
-          id2string(class_id) + "." + id2string(component_name);
+          id2string(class_id) + "." + id2string(mangled_method_name);
 
         entry.expr = class_method_descriptor_exprt{
-          type, component_name, class_id, name_entry.s, identifier};
+          type, mangled_method_name, class_id, name_entry.s, identifier};
       }
       break;
 

src/util/std_expr.h

@@ -4598,21 +4598,34 @@ class class_method_descriptor_exprt : public nullary_exprt
   /// \param base_method_name: The name of the method to which this expression
   ///   is applied as would be seen in the source code. For example this could
   ///   be - `toString`.
+  /// \param mangled_method_name: The method name after mangling it by
+  ///   combining it with the descriptor. The mangled name is distinguished from
+  ///   other overloads of the method with different counts of or types of
+  ///   parameters. It is not distinguished between different implementations
+  ///   within a class hierarchy. For example if the overall expression refers
+  ///   to the `java.lang.Object.toString` method, then the mangled_method_name
+  ///   would be `toString:()Ljava/lang/String;`
   explicit class_method_descriptor_exprt(
     typet _type,
-    irep_idt component_name,
+    irep_idt mangled_method_name,
     irep_idt class_id,
     irep_idt base_method_name,
     irep_idt identifier)
     : nullary_exprt(ID_virtual_function, std::move(_type))
   {
-    set(ID_component_name, std::move(component_name));
+    set(ID_component_name, std::move(mangled_method_name));
     set(ID_C_class, std::move(class_id));
     set(ID_C_base_name, std::move(base_method_name));
     set(ID_identifier, std::move(identifier));
   }
 
-  const irep_idt &get_component_name() const
+  /// The method name after mangling it by combining it with the descriptor.
+  /// The mangled name is distinguished from other overloads of the method with
+  /// different counts of or types of parameters. It is not distinguished
+  /// between different implementations within a class hierarchy. For example if
+  /// the overall expression refers to the `java.lang.Object.toString` method,
+  /// then the mangled_method_name would be `toString:()Ljava/lang/String;`
+  const irep_idt &mangled_method_name() const
   {
     return get(ID_component_name);
   }