Make Java.import import a Java class in the enclosing module instead of always as a top-level constant

Author: eregon

CHANGELOG.md

@@ -45,6 +45,7 @@ Performance:
 Changes:
 
 * `foreign_object.class` on foreign objects is no longer special and uses `Kernel#class` (it used to return the `java.lang.Class` object for a Java type or `getMetaObject()`, but that is too incompatible with Ruby code).
+* `Java.import name` imports a Java class in the enclosing module instead of always as a top-level constant.
 
 # 21.2.0
 

doc/user/jruby-migration.md

@@ -354,7 +354,7 @@ frame.setVisible(true)
 ```
 
 Instead of using Ruby metaprogramming to simulate a Java package name, we explicitly import classes.
-`Java.import` is similar to JRuby's `java_import`, and does `::ClassName = Java.type('package.ClassName')`.
+`Java.import` is similar to JRuby's `java_import`, and does `ClassName = Java.type('package.ClassName')`.
 
 Constants are read by reading properties of the class rather than using Ruby notation.
 
@@ -367,7 +367,7 @@ This is only available in GraalVM - not in the standalone distribution installed
 
 In JRuby, Java classes can either be referenced in the `Java` module, such as `Java::ComFoo::Bar`, or if they have a common TLD they can be referenced as `com.foo.Bar`. `java_import com.foo.Bar` will define `Bar` as a top-level constant.
 
-In TruffleRuby, Java classes are referred to using either `Java.type('com.foo.Bar')`, which you would then normally assign to a constant, or you can use `Java.import 'com.foo.Bar'` to have `Bar` defined as a top-level constant.
+In TruffleRuby, Java classes are referred to using either `Java.type('com.foo.Bar')`, which you would then normally assign to a constant, or you can use `Java.import 'com.foo.Bar'` to have `Bar` defined in the enclosing module.
 
 ### Wildcard Package Imports
 

doc/user/polyglot.md

@@ -132,7 +132,7 @@ With the type object, `.new` will create an instance, `.foo` will call the stati
 To access methods of the `java.lang.Class` instance, use `[:class]`, such as `MyClass[:class].getName`.
 You can also go from the `java.lang.Class` instance to the Java type by using `[:static]`.
 
-To import a Java class as a top-level constant, use `Java.import 'name'`.
+To import a Java class in the enclosing module, use `MyClass = Java.type 'java.lang.MyClass'` or `Java.import 'java.lang.MyClass'`.
 
 ## Embedding in Java
 

spec/tags/truffle/interop/java_import_tags.txt

@@ -10,38 +10,37 @@
 
 guard -> { !TruffleRuby.native? } do
   describe "Java.import" do
-
-    it "imports a class to the top-level" do
-      ruby_exe(%{
+    it "imports a class under the enclosing module" do
+      module TruffleJavaImportSpecs1
         Java.import 'java.math.BigInteger'
-        puts BigInteger.new('1234').toString
-      }).should == "1234\n"
+        BigInteger.new('1234').toString.should == "1234"
+      end
+
+      TruffleJavaImportSpecs1.should.const_defined?('BigInteger', false)
+      Object.should_not.const_defined?('BigInteger')
     end
 
     it "returns the imported class" do
-      ruby_exe(%{
-        puts Java.import('java.math.BigInteger').class.getName
-      }).should == "java.math.BigInteger\n"
+      module TruffleJavaImportSpecs2
+        Java.import('java.math.BigInteger')[:class].getName.should == "java.math.BigInteger"
+      end
     end
 
     it "can import classes twice" do
-      ruby_exe(%{
+      module TruffleJavaImportSpecs3
         Java.import 'java.math.BigInteger'
         Java.import 'java.math.BigInteger'
-        puts BigInteger.new('1234').toString
-      }).should == "1234\n"
+        BigInteger.new('1234').toString.should == "1234"
+      end
     end
 
     it "raises an error if the constant is already defined" do
-      ruby_exe(%{
+      module TruffleJavaImportSpecs4
         BigInteger = '14'
-        begin
+        -> {
           Java.import 'java.math.BigInteger'
-        rescue NameError => e
-          puts e
-        end
-      }).should == "constant BigInteger already set\n"
+        }.should raise_error(NameError, "constant BigInteger already set")
+      end
     end
-
   end
 end

spec/truffle/interop/java_import_spec.rb

@@ -414,18 +414,21 @@ def self.type(name)
   end
 
   def self.import(name)
+    nesting = Primitive.caller_nesting
+    mod = nesting.first || Object
+
     name = name.to_s
     simple_name = name.split('.').last
     type = Java.type(name)
-    if Object.const_defined?(simple_name)
-      current = Object.const_get(simple_name)
+    if mod.const_defined?(simple_name)
+      current = mod.const_get(simple_name)
       if current.equal?(type)
         # Ignore - it's already set
       else
         raise NameError, "constant #{simple_name} already set"
       end
     else
-      Object.const_set simple_name, type
+      mod.const_set simple_name, type
     end
     type
   end