Use a more descriptive error message when an expression tries to call methods on a class that is not loaded yet.

Before: "The instance method ... is undefined for the type ..."
After:  "Java class ... has not been loaded yet"

-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=156081390

Author: emrekultursay

src/agent/jvm_readers_factory.cc

@@ -330,27 +330,43 @@ JvmReadersFactory::FindLocalInstanceMethods(
       evaluators_->method_locals->GetLocalVariables(method_);
 
   if (method->local_instance == nullptr) {
-    return {};  // This is a static method, no matches.
+    // The current class is expected to be loaded. So, we must be in a
+    // static method with no instance methods.
+    return {};
   }
 
-  return FindInstanceMethods(
+  std::vector<ClassMetadataReader::Method> methods;
+  FormatMessageModel unused_error_message;
+  bool unused_success = FindInstanceMethods(
       method->local_instance->GetStaticType().object_signature,
-      method_name);
+      method_name,
+      &methods,
+      &unused_error_message);
+  DCHECK(unused_success);
+
+  return methods;
 }
 
 
-std::vector<ClassMetadataReader::Method>
-JvmReadersFactory::FindInstanceMethods(
+bool JvmReadersFactory::FindInstanceMethods(
     const string& class_signature,
-    const string& method_name) {
+    const string& method_name,
+    std::vector<ClassMetadataReader::Method>* methods,
+    FormatMessageModel* error_message) {
   JniLocalRef cls =
       evaluators_->class_indexer->FindClassBySignature(class_signature);
   if (cls == nullptr) {
-    LOG(ERROR) << "Local instance class not found: " << class_signature;
-    return {};
+    LOG(ERROR) << "Instance class not found: " << class_signature;
+    *error_message = {
+      ClassNotLoaded,
+      { TypeNameFromJObjectSignature(class_signature) }
+    };
+    return false;
   }
 
-  return FindClassMethods(static_cast<jclass>(cls.get()), false, method_name);
+  *methods =
+      FindClassMethods(static_cast<jclass>(cls.get()), false, method_name);
+  return true;
 }
 
 
@@ -359,24 +375,28 @@ JvmReadersFactory::FindStaticMethods(
     const string& method_name) {
   JniLocalRef cls = GetMethodDeclaringClass(method_);
   if (cls == nullptr) {
+    // This should not happen. The current class should always be loaded.
     return {};
   }
 
   return FindClassMethods(static_cast<jclass>(cls.get()), true, method_name);
 }
 
 
-std::vector<ClassMetadataReader::Method>
-JvmReadersFactory::FindStaticMethods(
+bool JvmReadersFactory::FindStaticMethods(
     const string& class_name,
-    const string& method_name) {
-  FormatMessageModel error_message;  // TODO(vlif): propagate this error.
-  JniLocalRef cls = FindClassByName(class_name, &error_message);
+    const string& method_name,
+    std::vector<ClassMetadataReader::Method>* methods,
+    FormatMessageModel* error_message) {
+  JniLocalRef cls = FindClassByName(class_name, error_message);
   if (cls == nullptr) {
-    return {};
+    *error_message = { ClassNotLoaded, { class_name } };
+    return false;
   }
 
-  return FindClassMethods(static_cast<jclass>(cls.get()), true, method_name);
+  *methods =
+      FindClassMethods(static_cast<jclass>(cls.get()), true, method_name);
+  return true;
 }
 
 

src/agent/jvm_readers_factory.h

@@ -75,16 +75,20 @@ class JvmReadersFactory : public ReadersFactory {
   std::vector<ClassMetadataReader::Method> FindLocalInstanceMethods(
       const string& method_name) override;
 
-  std::vector<ClassMetadataReader::Method> FindInstanceMethods(
+  bool FindInstanceMethods(
       const string& class_signature,
-      const string& method_name) override;
+      const string& method_name,
+      std::vector<ClassMetadataReader::Method>* methods,
+      FormatMessageModel* error_message) override;
 
   std::vector<ClassMetadataReader::Method> FindStaticMethods(
       const string& method_name) override;
 
-  std::vector<ClassMetadataReader::Method> FindStaticMethods(
+  bool FindStaticMethods(
       const string& class_name,
-      const string& method_name) override;
+      const string& method_name,
+      std::vector<ClassMetadataReader::Method>* methods,
+      FormatMessageModel* error_message) override;
 
   std::unique_ptr<ArrayReader> CreateArrayReader(
       const JSignature& array_signature) override;

src/agent/method_call_evaluator.cc

@@ -297,10 +297,15 @@ void MethodCallEvaluator::MatchInstanceSourceMethod(
     return;
   }
 
-  std::vector<ClassMetadataReader::Method> instance_methods =
-      readers_factory->FindInstanceMethods(
+  std::vector<ClassMetadataReader::Method> instance_methods;
+  if (!readers_factory->FindInstanceMethods(
           instance_source_->GetStaticType().object_signature,
-          method_name_);
+          method_name_,
+          &instance_methods,
+          error_message)) {
+    *matched = true;
+    return;
+  }
 
   MatchMethods(
       readers_factory,
@@ -327,8 +332,15 @@ void MethodCallEvaluator::MatchExplicitStaticMethod(
     ReadersFactory* readers_factory,
     bool* matched,
     FormatMessageModel* error_message) {
-  std::vector<ClassMetadataReader::Method> static_methods =
-      readers_factory->FindStaticMethods(possible_class_name_, method_name_);
+  std::vector<ClassMetadataReader::Method> static_methods;
+  if (!readers_factory->FindStaticMethods(
+      possible_class_name_,
+      method_name_,
+      &static_methods,
+      error_message)) {
+    *matched = true;
+    return;
+  }
 
   MatchMethods(
       readers_factory,

src/agent/readers_factory.h

@@ -112,20 +112,27 @@ class ReadersFactory {
 
   // Finds signatures of all instance methods named "method_name" in the
   // specified class.
-  virtual std::vector<ClassMetadataReader::Method> FindInstanceMethods(
+  // Returns false if the class for class_signature is not loaded, true
+  // otherwise.
+  virtual bool FindInstanceMethods(
       const string& class_signature,
-      const string& method_name) = 0;
+      const string& method_name,
+      std::vector<ClassMetadataReader::Method>* methods,
+      FormatMessageModel* error_message) = 0;
 
   // Finds signatures of all static methods named "method_name" in the current
   // class.
   virtual std::vector<ClassMetadataReader::Method> FindStaticMethods(
       const string& method_name) = 0;
 
   // Finds signatures of all static methods named "method_name" in the current
-  // class. Returns "MethodCaller" instances for each such method.
-  virtual std::vector<ClassMetadataReader::Method> FindStaticMethods(
+  // class. Populates "MethodCaller" instances for each such method.
+  // Returns false if the class for class_name is not loaded, true otherwise.
+  virtual bool FindStaticMethods(
       const string& class_name,
-      const string& method_name) = 0;
+      const string& method_name,
+      std::vector<ClassMetadataReader::Method>* methods,
+      FormatMessageModel* error_message) = 0;
 
   // Creates an object to read native array in expression evaluation. Returns
   // nullptr if "array_signature" doesn't correspond to an array.