Update to Java commit 641933e (2025.06.02): CLJ-2888: Adding support for array symbols to gen-class. Retains existing gen-class constraints around unqualified symbold defaulting to java.lang package qualification"

dmiller · dmiller · commit e5280f60bcb8 · 2025-08-30T10:39:21.000-04:00
diff --git a/Clojure/Clojure.Source/clojure/genclass.clj b/Clojure/Clojure.Source/clojure/genclass.clj
@@ -53,15 +53,26 @@
 	  'chars (Type/GetType "System.Char[]")})
 
  
- (defn- ^Type the-class [x]					;;; ^Class
-  (cond 
-   (class? x) x
-   (contains? prim->class x) (prim->class x)
-   :else (let [strx (str x)]
-           (clojure.lang.RT/classForName 
-            (if (some #{\. \[} strx)           
-              strx
-              (str "System." strx))))))         ;;;(str "java.lang." strx))))))
+(defn- the-array-class [sym]
+  (clojure.lang.RT/classForName
+   (let [cn (namespace sym)]
+     (clojure.lang.CljCompiler.Ast.HostExpr/BuildArrayTypeDescriptor                  ;;; clojure.lang.Compiler$HostExpr/buildArrayClassDescriptor 
+      (if (or (clojure.lang.Compiler/PrimType (symbol cn)) (some #{\.} cn))           ;;; primClass
+        sym
+        (symbol (str "System." cn) (name sym)))))))                                   ;;; "java.lang."
+
+(defn- ^Type the-class [x]                                                            ;;; ^Class
+  (cond
+    (class? x) x
+    (symbol? x) (cond (contains? prim->class x) (prim->class x)
+                      (clojure.lang.CljCompiler.Ast.HostExpr/LooksLikeArrayType x)   ;;; clojure.lang.Compiler$HostExpr/looksLikeArrayClass
+                        (the-array-class x)
+                      :else (let [strx (str x)]
+                              (clojure.lang.RT/classForName
+                               (if (some #{\. \[} strx)
+                                 strx
+                                 (str "System." strx)))))                             ;;; "java.lang."
+    :else (clojure.lang.RT/classForName x)))
  
  (defn- the-class-maybe-by-ref [x]
    (cond
diff --git a/Clojure/Clojure.Tests/clojure/test_clojure/genclass.clj b/Clojure/Clojure.Tests/clojure/test_clojure/genclass.clj
@@ -148,4 +148,14 @@
 ;;;        sourceVisitor (proxy [clojure.asm.ClassVisitor] [clojure.asm.Opcodes/ASM4 nil]
 ;;;                        (visitSource [source debug] (.append sourceFile source)))]
 ;;;    (.accept classReader sourceVisitor 0)
-;;;    (is (= "examples.clj" (str sourceFile)))))
+;;;    (is (= "examples.clj" (str sourceFile)))))
+
+(deftest array-descriptors->class
+  (are [descr c] (= (#'clojure.core/the-class descr) c)
+    "System.Guid[]" System.Guid/1                           ;;; "[Ljava.util.UUID;" java.util.UUID/1
+    'String System.String                                   ;;; java.lang.String
+    'String/1 System.String/1                               ;;; java.lang.String/1
+    `System.Guid System.Guid                                ;;; 'java.util.UUID java.util.UUID
+    'System.Guid/2 System.Guid/2                            ;;; 'java.util.UUID/2 java.util.UUID/2
+    'int/1 int/1
+    'boolean/9 bool/9))
diff --git a/Clojure/Clojure/CljCompiler/Ast/HostExpr.cs b/Clojure/Clojure/CljCompiler/Ast/HostExpr.cs
@@ -70,12 +70,12 @@ public Expr Parse(ParserContext pcon, object form)
                 ISeq args;
                 bool methodRequired = false;
 
-                if ( RT.third(sform) is Symbol s)
+                if (RT.third(sform) is Symbol s)
                 {
                     methodSym = s;
                     args = RT.next(RT.next(RT.next(sform)));
                 }
-                else if (RT.Length(sform) == 3  && RT.third(sform) is ISeq seq)
+                else if (RT.Length(sform) == 3 && RT.third(sform) is ISeq seq)
                 {
                     var seqFirst = RT.first(seq);
                     if (seqFirst is Symbol sym)
@@ -133,7 +133,7 @@ public Expr Parse(ParserContext pcon, object form)
 
                     bool isPropName = false;
                     Symbol memberSym = methodSym;
-                    
+
                     if (memberSym.Name[0] == '-')
                     {
                         isPropName = true;
@@ -148,9 +148,9 @@ public Expr Parse(ParserContext pcon, object form)
                     //   are generated by StaticFieldExpr and InstanceFieldExpr.
                     if (staticType != null)
                     {
-                        if ( ! hasTypeArgs && (finfo = Reflector.GetField(staticType, memberName, true)) != null)
+                        if (!hasTypeArgs && (finfo = Reflector.GetField(staticType, memberName, true)) != null)
                             return new StaticFieldExpr(source, spanMap, tag, staticType, memberName, finfo);
-                        if ( ! hasTypeArgs && (pinfo = Reflector.GetProperty(staticType, memberName, true)) != null)
+                        if (!hasTypeArgs && (pinfo = Reflector.GetProperty(staticType, memberName, true)) != null)
                             return new StaticPropertyExpr(source, spanMap, tag, staticType, memberName, pinfo);
                         if (!isPropName && Reflector.GetArityZeroMethod(staticType, memberName, typeArgs, true) != null)
                             return new StaticMethodExpr(source, spanMap, tag, staticType, memberName, typeArgs, new List<HostArg>(), tailPosition);
@@ -185,7 +185,7 @@ public Expr Parse(ParserContext pcon, object form)
                         if (pcon.IsAssignContext)
                             return new InstanceFieldExpr(source, spanMap, tag, instance, memberName, null); // same as InstancePropertyExpr when last arg is null
                         else
-                            return new InstanceZeroArityCallExpr(source, spanMap, tag, instance, memberName); 
+                            return new InstanceZeroArityCallExpr(source, spanMap, tag, instance, memberName);
 
                     }
                 }
@@ -204,7 +204,7 @@ public Expr Parse(ParserContext pcon, object form)
 
         internal static List<HostArg> ParseArgs(ParserContext pcon, ISeq argSeq)
         {
-            List<HostArg> args = new List<HostArg>();
+            List<HostArg> args = new();
 
             for (ISeq s = argSeq; s != null; s = s.next())
             {
@@ -232,7 +232,7 @@ internal static List<HostArg> ParseArgs(ParserContext pcon, ISeq argSeq)
                     }
                 }
 
-                Expr expr = Compiler.Analyze(pcon.EvalOrExpr(),arg);
+                Expr expr = Compiler.Analyze(pcon.EvalOrExpr(), arg);
 
                 args.Add(new HostArg(paramType, expr, lb));
             }
@@ -290,13 +290,13 @@ internal static List<HostArg> ParseArgs(ParserContext pcon, ISeq argSeq)
 
         internal static readonly MethodInfo Method_RT_booleanCast = typeof(RT).GetMethod("booleanCast", new Type[] { typeof(object) });
 
-        internal static readonly MethodInfo Method_RT_intPtrCast = typeof (RT).GetMethod("intPtrCast", new Type[] { typeof (object) });
-        internal static readonly MethodInfo Method_RT_uintPtrCast = typeof (RT).GetMethod("uintPtrCast", new Type[] { typeof (object) });
+        internal static readonly MethodInfo Method_RT_intPtrCast = typeof(RT).GetMethod("intPtrCast", new Type[] { typeof(object) });
+        internal static readonly MethodInfo Method_RT_uintPtrCast = typeof(RT).GetMethod("uintPtrCast", new Type[] { typeof(object) });
 
         #endregion
 
         #region Tags and types
-        
+
         public static Type MaybeType(object form, bool stringOk)
         {
             if (form is Type type)
@@ -322,7 +322,7 @@ public static Type MaybeType(object form, bool stringOk)
                             var tName = type1.FullName;
                             var compiledType = Compiler.FindDuplicateCompiledType(tName);
                             if (compiledType is not null && Compiler.IsCompiling)
-                                t =  compiledType;
+                                t = compiledType;
                         }
                         else if (Compiler.LocalEnvVar.deref() != null && ((IPersistentMap)Compiler.LocalEnvVar.deref()).containsKey(form))  // JVM casts to java.util.Map
                             return null;
@@ -388,8 +388,8 @@ internal static Type TagToType(object tag)
                     t = HostExpr.MaybeArrayType(sym);
                 }
             }
-           
-            if ( t == null )
+
+            if (t == null)
                 t = MaybeType(tag, true);
 
             if (t != null)
@@ -398,29 +398,42 @@ internal static Type TagToType(object tag)
             throw new ArgumentException("Unable to resolve typename: " + tag);
         }
 
-        public static Type MaybeArrayType(Symbol sym)
+
+        public static bool LooksLikeArrayType(Symbol sym)
         {
-            if (sym.Namespace == null || !Util.IsPosDigit(sym.Name))
-                return null;
+            return sym.Namespace is not null && Util.IsPosDigit(sym.Name);
+        }
 
+        public static string BuildArrayTypeDescriptor(Symbol sym)
+        {
             int dim = sym.Name[0] - '0';
             Symbol componentTypeName = Symbol.intern(null, sym.Namespace);
             Type componentType = Compiler.PrimType(componentTypeName);
-            if (componentType == null)
-                componentType = HostExpr.MaybeType(componentTypeName, false);
 
-            if (componentType == null)
-                throw new TypeNotFoundException("Unable to resolve component typename: " + componentTypeName);
+            if (componentType is null)
+                componentType = MaybeType(componentTypeName, false);
+
+            if (componentType is null)
+                throw new TypeNotFoundException(componentTypeName.ToString());
+
+            StringBuilder arrayDescriptor = new();
+            arrayDescriptor.Append(componentType.FullName);
 
-            // componentType.MakeArrayType(dim) is not what you want.  This creates .IsVariableBound designed for multiple dimensions.
-            // We are matching Java which means we have jagged arrays.
-            // Without an argument, MakeArrayType returns an SZ array -- one-dimensional, zero-based.
-            // we need to nest.
 
             for (int i = 0; i < dim; i++)
-                componentType = componentType.MakeArrayType();
+            {
+                arrayDescriptor.Append("[]");
+            }
+
+            return arrayDescriptor.ToString();
+        }
+
+        public static Type MaybeArrayType(Symbol sym)
+        {
+            if (!LooksLikeArrayType(sym))
+                return null;
 
-            return componentType;
+            return MaybeType(BuildArrayTypeDescriptor(sym), true);
         }
 
         #endregion
@@ -456,11 +469,11 @@ internal static void EmitUnboxArg(CljILGen ilg, Type paramType)
                 {
                     m = HostExpr.Method_RT_charCast;
                 }
-                else if(paramType == typeof(IntPtr))
+                else if (paramType == typeof(IntPtr))
                 {
                     m = HostExpr.Method_RT_intPtrCast;
                 }
-                else if(paramType == typeof(UIntPtr))
+                else if (paramType == typeof(UIntPtr))
                 {
                     m = HostExpr.Method_RT_uintPtrCast;
                 }
@@ -558,7 +571,7 @@ internal static void EmitUnboxArg(CljILGen ilg, Type paramType)
                 }
 
                 ilg.Emit(OpCodes.Castclass, typeof(Object));
-                ilg.Emit(OpCodes.Call,m);
+                ilg.Emit(OpCodes.Call, m);
             }
             else
             {
