Always convert methods in two phases, even in eager mode

Previously in lazy mode we first converted all the method prototypes,
then later populated bodies, while in eager mode bodies were populated
as we went. Now we always use the former method, so eager mode is like
lazy mode except we then populate every method regardless of reachability.

This makes the process more uniform, and as a useful side-effect means
that the symbol table is populated by the time method conversion happens,
so we can check for static initialisers' existence or otherwise.

Author: smowton

src/java_bytecode/java_bytecode_convert_class.cpp

@@ -171,21 +171,7 @@ void java_bytecode_convert_classt::convert(const classt &c)
       method_identifier,
       method,
       symbol_table);
-    if(lazy_methods_mode==LAZY_METHODS_MODE_EAGER)
-    {
-      // Upgrade to a fully-realized symbol now:
-      java_bytecode_convert_method(
-        *class_symbol,
-        method,
-        symbol_table,
-        get_message_handler(),
-        max_array_length);
-    }
-    else
-    {
-      // Wait for our caller to decide what needs elaborating.
-      lazy_methods[method_identifier]=std::make_pair(class_symbol, &method);
-    }
+    lazy_methods[method_identifier]=std::make_pair(class_symbol, &method);
   }
 
   // is this a root class?

src/java_bytecode/java_bytecode_language.cpp

@@ -542,6 +542,20 @@ bool java_bytecode_languaget::typecheck(
     if(do_ci_lazy_method_conversion(symbol_table, lazy_methods))
       return true;
   }
+  else if(lazy_methods_mode==LAZY_METHODS_MODE_EAGER)
+  {
+    // Simply elaborate all methods symbols now.
+    for(const auto &method_sig : lazy_methods)
+    {
+      java_bytecode_convert_method(
+        *method_sig.second.first,
+        *method_sig.second.second,
+        symbol_table,
+        get_message_handler(),
+        max_user_array_length);
+    }
+  }
+  // Otherwise our caller is in charge of elaborating methods on demand.
 
   // now typecheck all
   if(java_bytecode_typecheck(