Adding tests for inner classes that capture outer class variables

Author: thk123

unit/java_bytecode/java_bytecode_parser/java_bytecode_parse_lambda_method_table.cpp

@@ -797,3 +797,139 @@ SCENARIO(
     }
   }
 }
+SCENARIO(
+  "lambda_method_handle_map with member lambdas capturing outer class "
+  "variables",
+  "[core][java_bytecode][java_bytecode_parse_lambda_method_handle]")
+{
+  null_message_handlert message_handler;
+  GIVEN(
+    "An inner class with member variables as lambdas that capture outer "
+    "variables")
+  {
+    java_bytecode_parse_treet parse_tree;
+    java_bytecode_parse(
+      "./java_bytecode/java_bytecode_parser/lambda_examples/"
+      "OuterMemberLambdas$Inner.class",
+      parse_tree,
+      message_handler);
+    WHEN("Parsing that class")
+    {
+      REQUIRE(parse_tree.loading_successful);
+      const java_bytecode_parse_treet::classt parsed_class =
+        parse_tree.parsed_class;
+      REQUIRE(parsed_class.attribute_bootstrapmethods_read);
+      REQUIRE(parsed_class.lambda_method_handle_map.size() == 3);
+
+      // Field ref for getting the outer class
+      const reference_typet outer_class_reference_type =
+        java_reference_type(symbol_typet{"java::OuterMemberLambdas"});
+      const fieldref_exprt outer_fieldref{
+        outer_class_reference_type, "this$0", "java::OuterMemberLambdas$Inner"};
+
+      THEN(
+        "There should be an entry for the lambda that returns a primitive "
+        "local variable and the method it references should have an "
+        "appropriate descriptor")
+      {
+        std::string descriptor = "()I";
+        const lambda_method_handlet &lambda_entry =
+          require_parse_tree::require_lambda_entry_for_descriptor(
+            parsed_class, descriptor);
+
+        const irep_idt &lambda_impl_name = lambda_entry.lambda_method_name;
+
+        const auto lambda_method =
+          require_parse_tree::require_method(parsed_class, lambda_impl_name);
+        // Note here the descriptor of the implementation is different - the
+        // implementation requries the input to be passed in
+        REQUIRE(id2string(lambda_method.descriptor) == "()I");
+        REQUIRE_FALSE(lambda_method.is_static);
+
+        const fieldref_exprt primitive_fieldref{
+          java_int_type(), "memberPrimitive", "java::OuterMemberLambdas"};
+
+        std::vector<require_parse_tree::expected_instructiont>
+          expected_instructions{{"aload_0", {}}, // load this of stack
+                                {"getfield", {outer_fieldref}},
+                                {"getfield", {primitive_fieldref}},
+                                {"ireturn", {}}};
+
+        require_parse_tree::require_instructions_match_expectation(
+          expected_instructions, lambda_method.instructions);
+      }
+      THEN(
+        "There should be an entry for the lambda that returns a reference type "
+        "local variable  and the method it references should have an "
+        "appropriate descriptor")
+      {
+        // Since it is a local variable, the corresponding method takes the
+        // captured variable as an input
+        std::string descriptor = "()Ljava/lang/Object;";
+        const lambda_method_handlet &lambda_entry =
+          require_parse_tree::require_lambda_entry_for_descriptor(
+            parsed_class, descriptor);
+
+        const irep_idt &lambda_impl_name = lambda_entry.lambda_method_name;
+
+        const auto lambda_method =
+          require_parse_tree::require_method(parsed_class, lambda_impl_name);
+        REQUIRE(id2string(lambda_method.descriptor) == "()Ljava/lang/Object;");
+        REQUIRE_FALSE(lambda_method.is_static);
+
+        const reference_typet dummy_generic_reference_type =
+          java_reference_type(symbol_typet{"java::java.lang.Object"});
+
+        const fieldref_exprt reference_fieldref{dummy_generic_reference_type,
+                                                "memberReference",
+                                                "java::OuterMemberLambdas"};
+
+        std::vector<require_parse_tree::expected_instructiont>
+          expected_instructions{{"aload_0", {}}, // load this of stack
+                                {"getfield", {outer_fieldref}},
+                                {"getfield", {reference_fieldref}},
+                                {"areturn", {}}};
+
+        require_parse_tree::require_instructions_match_expectation(
+          expected_instructions, lambda_method.instructions);
+      }
+      THEN(
+        "There should be an entry for the lambda that returns a specialised "
+        "generic type local variable  and the method it references should have "
+        "an appropriate descriptor")
+      {
+        // Since it is a local variable, the corresponding method takes the
+        // captured variable as an input
+        std::string descriptor = "()LDummyGeneric;";
+        const lambda_method_handlet &lambda_entry =
+          require_parse_tree::require_lambda_entry_for_descriptor(
+            parsed_class, descriptor);
+
+        const irep_idt &lambda_impl_name = lambda_entry.lambda_method_name;
+
+        const java_bytecode_parse_treet::methodt &lambda_method =
+          require_parse_tree::require_method(parsed_class, lambda_impl_name);
+        REQUIRE(id2string(lambda_method.descriptor) == "()LDummyGeneric;");
+        REQUIRE_FALSE(lambda_method.is_static);
+
+        const reference_typet dummy_generic_reference_type =
+          java_reference_type(symbol_typet{"java::DummyGeneric"});
+
+        const fieldref_exprt generic_reference_fieldref{
+          dummy_generic_reference_type,
+          "memberSpecalisedGeneric",
+          "java::OuterMemberLambdas"};
+
+        // since just returning the parameter, nothing to put on the stack
+        std::vector<require_parse_tree::expected_instructiont>
+          expected_instructions{{"aload_0", {}}, // load this of stack
+                                {"getfield", {outer_fieldref}},
+                                {"getfield", {generic_reference_fieldref}},
+                                {"areturn", {}}};
+
+        require_parse_tree::require_instructions_match_expectation(
+          expected_instructions, lambda_method.instructions);
+      }
+    }
+  }
+}

unit/java_bytecode/java_bytecode_parser/lambda_examples/OuterMemberLambdas$Inner.class

@@ -0,0 +1,22 @@
+public class OuterMemberLambdas {
+
+  int memberPrimitive;
+  Object memberReference;
+  DummyGeneric<Integer> memberSpecalisedGeneric;
+
+  public class Inner {
+
+    ReturningLambdaPrimitive returnPrimitiveLambdaCapture = () -> { return memberPrimitive; };
+    ReturningLambdaReference returnReferenceLambdaCapture = () -> { return memberReference; };
+    ReturningLambdaSpecalisedGeneric returningSpecalisedGenericLambdaCapture = () -> { return memberSpecalisedGeneric; };
+
+
+    public void testMethod() {
+
+      returnPrimitiveLambdaCapture.Execute();
+      returnReferenceLambdaCapture.Execute();
+      returningSpecalisedGenericLambdaCapture.Execute();
+    }
+  }
+}
+