Simplify generic Class<> usage (#179)

Co-authored-by: Gene Gleyzer <gene@xqiz.it>
xtclang · Mar 11, 2024 · 732aeb2 · 732aeb2
1 parent 0478a4d
commit 732aeb2
Show file tree

Hide file tree

Showing 7 changed files with 35 additions and 11 deletions.
diff --git a/javatools/src/main/java/org/xvm/asm/ClassStructure.java b/javatools/src/main/java/org/xvm/asm/ClassStructure.java
@@ -4255,6 +4255,28 @@ else if (cFormal > cActual)
                     m_listActual = listActual = new ArrayList<>(listActual); // clone
                     List<Map.Entry<StringConstant, TypeConstant>> entries = getTypeParamsAsList();
 
+                    if (id.equals(pool.clzClass()) && cActual > 0)
+                        {
+                        TypeConstant typePublic = listActual.get(0);
+                        if (typePublic.isSingleUnderlyingClass(false) && !typePublic.isFormalType())
+                            {
+                            // we know a bit more about the relationship between Class formal types;
+                            // prime them accordingly
+                            for (int i = cActual; i < cFormal; i++)
+                                {
+                                listActual.add(pool.ensureAccessTypeConstant(typePublic,
+                                    switch (i)
+                                        {
+                                        case 1  -> Access.PROTECTED;
+                                        case 2  -> Access.PRIVATE;
+                                        case 3  -> Access.STRUCT;
+                                        default -> throw new IllegalStateException();
+                                        }));
+                                }
+                            return;
+                            }
+                        }
+
                     // fill the missing actual parameters with the canonical constraint types
                     // Note: since there is a possibility of Tuple self-reference
                     // (e.g. Tuple<ElementTypes extends Tuple<ElementTypes...>>)

diff --git a/javatools/src/main/java/org/xvm/asm/Component.java b/javatools/src/main/java/org/xvm/asm/Component.java
@@ -3417,7 +3417,7 @@ protected void registerConstants(ConstantPool pool)
                     TypeConstant   type      = entry.getValue();
 
                     mapNew.put((StringConstant) pool.register(constName),
-                               (TypeConstant)   (type == null ? null : pool.register(type)));
+                               (TypeConstant) (type == null ? null : pool.register(type)));
                     }
                 m_mapParams = mapNew;
                 }

diff --git a/javatools/src/main/java/org/xvm/asm/ConstantPool.java b/javatools/src/main/java/org/xvm/asm/ConstantPool.java
@@ -2310,6 +2310,7 @@ public ByteConstant ensureNibbleConstant(int n)
     public ClassConstant     clzOuter()          {ClassConstant     c = m_clzOuter;          if (c == null) {m_clzOuter          = c = (ClassConstant) getImplicitlyImportedIdentity("Outer"           );} return c;}
     public ClassConstant     clzRef()            {ClassConstant     c = m_clzRef;            if (c == null) {m_clzRef            = c = (ClassConstant) getImplicitlyImportedIdentity("Ref"             );} return c;}
     public ClassConstant     clzVar()            {ClassConstant     c = m_clzVar;            if (c == null) {m_clzVar            = c = (ClassConstant) getImplicitlyImportedIdentity("Var"             );} return c;}
+    public ClassConstant     clzClass()          {ClassConstant     c = m_clzClass;          if (c == null) {m_clzClass          = c = (ClassConstant) getImplicitlyImportedIdentity("Class"           );} return c;}
     public ClassConstant     clzStruct()         {ClassConstant     c = m_clzStruct;         if (c == null) {m_clzStruct         = c = (ClassConstant) getImplicitlyImportedIdentity("Struct"          );} return c;}
     public ClassConstant     clzType()           {ClassConstant     c = m_clzType;           if (c == null) {m_clzType           = c = (ClassConstant) getImplicitlyImportedIdentity("Type"            );} return c;}
     public ClassConstant     clzConst()          {ClassConstant     c = m_clzConst;          if (c == null) {m_clzConst          = c = (ClassConstant) getImplicitlyImportedIdentity("Const"           );} return c;}
@@ -2463,7 +2464,6 @@ public ByteConstant ensureNibbleConstant(int n)
 
     // ---- internal class helpers -----------------------------------------------------------------
 
-    protected ClassConstant  clzClass()         {return (ClassConstant) getImplicitlyImportedIdentity("Class"                    );}
     protected ClassConstant  clzParameter()     {return (ClassConstant) getImplicitlyImportedIdentity("Parameter"                );}
     protected ClassConstant  clzBoolean()       {return (ClassConstant) getImplicitlyImportedIdentity("Boolean"                  );}
     protected ClassConstant  clzFalse()         {return (ClassConstant) getImplicitlyImportedIdentity("False"                    );}
@@ -3905,8 +3905,9 @@ public static Auto withPool(ConstantPool pool) {
     private transient ClassConstant     m_clzOuter;
     private transient ClassConstant     m_clzRef;
     private transient ClassConstant     m_clzVar;
-    private transient ClassConstant     m_clzType;
+    private transient ClassConstant     m_clzClass;
     private transient ClassConstant     m_clzStruct;
+    private transient ClassConstant     m_clzType;
     private transient ClassConstant     m_clzConst;
     private transient ClassConstant     m_clzService;
     private transient ClassConstant     m_clzModule;
@@ -4051,6 +4052,7 @@ private void optimize()
         m_clzOuter          = null;
         m_clzRef            = null;
         m_clzVar            = null;
+        m_clzClass          = null;
         m_clzStruct         = null;
         m_clzType           = null;
         m_clzCloseable      = null;

diff --git a/javatools/src/main/java/org/xvm/asm/constants/ParameterizedTypeConstant.java b/javatools/src/main/java/org/xvm/asm/constants/ParameterizedTypeConstant.java
@@ -533,7 +533,8 @@ public TypeConstant adoptParameters(ConstantPool pool, TypeConstant[] atypeParam
                     }
                 }
             }
-        return m_constType.adoptParameters(pool, atypeParams);        }
+        return m_constType.adoptParameters(pool, atypeParams);
+        }
 
     @Override
     public TypeConstant[] collectGenericParameters()

diff --git a/javatools/src/main/java/org/xvm/compiler/ast/AstNode.java b/javatools/src/main/java/org/xvm/compiler/ast/AstNode.java
@@ -1067,7 +1067,8 @@ protected MethodConstant findMethod(Context ctx, TypeConstant typeTarget, TypeIn
 
         if (setMethods.isEmpty())
             {
-            if (typeTarget.isSingleDefiningConstant() && typeTarget.getAccess() != Access.PRIVATE)
+            if (!typeTarget.isFormalType() && typeTarget.isSingleDefiningConstant() &&
+                    typeTarget.getAccess() != Access.PRIVATE)
                 {
                 // check if there are any potentially matching private methods
                 TypeConstant typePrivate = typeTarget.ensureAccess(Access.PRIVATE);

diff --git a/manualTests/src/main/x/reflect.x b/manualTests/src/main/x/reflect.x
@@ -257,7 +257,7 @@ module TestReflection {
         for (val constructor : t.constructors) {
             switch (constructor.params.size) {
             case 1:
-                Class<public Point, protected Point, private Point, struct Point> clz = Point;
+                Class<Point> clz = Point;
                 assert (struct Point) structure := clz.allocate();
                 structure.x = Int:1;
                 structure.y = Int:2;

diff --git a/tck/src/main/x/tck/constructors/Reflect.x b/tck/src/main/x/tck/constructors/Reflect.x
@@ -11,7 +11,7 @@ class Reflect {
         static class Test(Int a1, String a2);
 
         try {
-            Class<public Test, protected Test, private Test, struct Test> clz = Test;
+            Class<Test> clz = Test;
             assert (struct Test) structure := clz.allocate();
             structure.a1 = 4;
             // structure.a2  assignment is missing
@@ -35,8 +35,7 @@ class Reflect {
 
         try {
             Class<Test> clz = Test;
-            assert Struct structure := clz.allocate();
-            assert structure.is(struct Test);
+            assert (struct Test) structure := clz.allocate();
             structure.a1 = 4;
             structure.a2 = "hello";
             Test t = clz.instantiate(structure);
@@ -64,8 +63,7 @@ class Reflect {
         }
 
         Class<Derived> clz = Derived;
-        assert Struct structure := clz.allocate();
-        assert structure.is(struct Derived);
+        assert (struct Derived) structure := clz.allocate();
         structure.s = "Test";
         Derived d = clz.instantiate(structure);
         assert d.s == "Test-DA-BA";