src/jdk.compiler/share/classes/com/sun/tools/javac/code/Flags.java

@@ -158,6 +158,10 @@ public static EnumSet<Flag> asFlagSet(long flags) {
     /** Marks a type as a value class */
     public static final int VALUE_CLASS  = 1<<21;
 
+    /** Flag bit 21 is available. (used earlier to tag compiler-generated abstract methods that implement
+     *  an interface method (Miranda methods)).
+     */
+
     /** Flag is set for nested classes that do not access instance members
      *  or `this' of an outer class and therefore don't need to be passed
      *  a this$n reference.  This value is currently set only for anonymous
@@ -417,6 +421,16 @@ public static EnumSet<Flag> asFlagSet(long flags) {
      */
     public static final long NON_SEALED = 1L<<63; // ClassSymbols
 
+    /**
+     * Flag to indicate that the type variables is universal
+     */
+    public static final long UNIVERSAL = 1L<<61; // TypeVariableSymbols
+
+    // Encodings for extended flags stored using attributes
+    /**
+     * Flag to indicate that the primitive class is reference default.
+     */
+    public static final int ACC_REF_DEFAULT = 1;
 
     /** Modifier masks.
      */

src/jdk.compiler/share/classes/com/sun/tools/javac/code/Lint.java

@@ -324,7 +324,12 @@ public enum LintCategory {
         /**
          * Warn about use of preview features.
          */
-        PREVIEW("preview");
+        PREVIEW("preview"),
+
+        /**
+         * Warn about use of universal type variables.
+         */
+        UNIVERSAL("universal");
 
         LintCategory(String option) {
             this(option, false);

src/jdk.compiler/share/classes/com/sun/tools/javac/code/Source.java

@@ -241,6 +241,7 @@ public enum Feature {
         REDUNDANT_STRICTFP(JDK17),
         PRIMITIVE_CLASSES(JDK18, Fragments.FeaturePrimitiveClasses, DiagKind.PLURAL),
         VALUE_CLASSES(JDK18, Fragments.FeatureValueClasses, DiagKind.PLURAL),
+        UNIVERSAL_TVARS(JDK18, Fragments.FeatureUniversalTvars, DiagKind.PLURAL),
         ;
 
         enum DiagKind {

src/jdk.compiler/share/classes/com/sun/tools/javac/code/Type.java

@@ -1897,12 +1897,32 @@ public static class TypeVar extends Type implements TypeVariable {
          */
         public Type lower;
 
+        /** if this type variable is universal then it could also have a link to a pure reference
+         *  type variable, it is important to know that a universal type variable and its
+         *  corresponding referenceTypeVar share the same tsym. So if it is needed to double check if
+         *  a type variable is universal or not, we need to check its type not the type of its tsym
+         */
+        public TypeVar projection = null;
+
+        protected boolean isReferenceProjection = false;
+
+        // redundant for now but helpful for debug reasons
+        private boolean isUniversal;
+
         public TypeVar(Name name, Symbol owner, Type lower) {
+            this(name, owner, lower, false);
+        }
+
+        public TypeVar(Name name, Symbol owner, Type lower, boolean isUniversal) {
             super(null, TypeMetadata.EMPTY);
             Assert.checkNonNull(lower);
-            tsym = new TypeVariableSymbol(0, name, this, owner);
+            tsym = new TypeVariableSymbol(isUniversal ? UNIVERSAL : 0, name, this, owner);
             this.setUpperBound(null);
             this.lower = lower;
+            this.isUniversal = isUniversal;
+            if (isUniversal && !isReferenceProjection) {
+                referenceProjection();
+            }
         }
 
         public TypeVar(TypeSymbol tsym, Type bound, Type lower) {
@@ -1911,15 +1931,25 @@ public TypeVar(TypeSymbol tsym, Type bound, Type lower) {
 
         public TypeVar(TypeSymbol tsym, Type bound, Type lower,
                        TypeMetadata metadata) {
+            this(tsym, bound, lower, metadata, false);
+        }
+
+        public TypeVar(TypeSymbol tsym, Type bound, Type lower,
+                       TypeMetadata metadata, boolean isReferenceProjection) {
             super(tsym, metadata);
             Assert.checkNonNull(lower);
             this.setUpperBound(bound);
             this.lower = lower;
+            this.isReferenceProjection = isReferenceProjection;
+            this.isUniversal = (tsym.flags_field & UNIVERSAL) != 0;
+            if (isUniversal && !isReferenceProjection) {
+                referenceProjection();
+            }
         }
 
         @Override
         public TypeVar cloneWithMetadata(TypeMetadata md) {
-            return new TypeVar(tsym, getUpperBound(), lower, md) {
+            return new TypeVar(tsym, getUpperBound(), lower, md, isReferenceProjection) {
                 @Override
                 public Type baseType() { return TypeVar.this.baseType(); }
 
@@ -1943,7 +1973,11 @@ public <R,S> R accept(Type.Visitor<R,S> v, S s) {
         @Override @DefinedBy(Api.LANGUAGE_MODEL)
         public Type getUpperBound() { return _bound; }
 
-        public void setUpperBound(Type bound) { this._bound = bound; }
+        public void setUpperBound(Type bound) {
+            this._bound = bound;
+            if (projection != null)
+                projection.setUpperBound(bound);
+        }
 
         int rank_field = -1;
 
@@ -1975,6 +2009,26 @@ public boolean isNullOrReference() {
         public <R, P> R accept(TypeVisitor<R, P> v, P p) {
             return v.visitTypeVariable(this, p);
         }
+
+        @Override
+        public TypeVar referenceProjection() {
+            if (projection == null) {
+                projection = new TypeVar(tsym, _bound, lower, metadata, true);
+            }
+            return projection;
+        }
+
+        public boolean isUniversal() {
+            return ((tsym.flags_field & UNIVERSAL) != 0);
+        }
+
+        public boolean isReferenceProjection() {
+            return isReferenceProjection;
+        }
+
+        public boolean isValueProjection() {
+            return isUniversal() && !isReferenceProjection();
+        }
     }
 
     /** A captured type variable comes from wildcards which can have
@@ -1994,6 +2048,7 @@ public CapturedType(Name name,
             this.lower = Assert.checkNonNull(lower);
             this.setUpperBound(upper);
             this.wildcard = wildcard;
+            this.isReferenceProjection = wildcard.bound != null ? wildcard.bound.isReferenceProjection : false;
         }
 
         public CapturedType(TypeSymbol tsym,
@@ -2004,6 +2059,7 @@ public CapturedType(TypeSymbol tsym,
                             TypeMetadata metadata) {
             super(tsym, bound, lower, metadata);
             this.wildcard = wildcard;
+            this.isReferenceProjection = wildcard.bound != null ? wildcard.bound.isReferenceProjection : false;
         }
 
         @Override

src/jdk.compiler/share/classes/com/sun/tools/javac/code/Types.java

@@ -50,6 +50,7 @@
 import com.sun.tools.javac.comp.Enter;
 import com.sun.tools.javac.comp.Env;
 import com.sun.tools.javac.jvm.ClassFile;
+import com.sun.tools.javac.resources.CompilerProperties.Warnings;
 import com.sun.tools.javac.util.*;
 
 import static com.sun.tools.javac.code.BoundKind.*;
@@ -94,6 +95,7 @@ public class Types {
     final boolean allowDefaultMethods;
     final boolean mapCapturesToBounds;
     final boolean allowValueBasedClasses;
+    final boolean allowUniversalTVars;
     final Check chk;
     final Enter enter;
     JCDiagnostic.Factory diags;
@@ -124,7 +126,9 @@ protected Types(Context context) {
         diags = JCDiagnostic.Factory.instance(context);
         noWarnings = new Warner(null);
         Options options = Options.instance(context);
+        Preview preview = Preview.instance(context);
         allowValueBasedClasses = options.isSet("allowValueBasedClasses");
+        allowUniversalTVars = Feature.UNIVERSAL_TVARS.allowedInSource(source);
     }
     // </editor-fold>
 
@@ -607,19 +611,32 @@ public boolean isConvertible(Type t, Type s, Warner warn) {
 
         boolean tValue = t.isPrimitiveClass();
         boolean sValue = s.isPrimitiveClass();
+        if (allowUniversalTVars && ((s.hasTag(TYPEVAR)) && ((TypeVar)s).isValueProjection() &&
+                (t.hasTag(BOT) || t.hasTag(TYPEVAR) && !((TypeVar)t).isValueProjection()))) {
+            warn.warn(LintCategory.UNIVERSAL);
+            return true;
+        }
+
+        boolean tUndet = t.hasTag(UNDETVAR);
+        boolean sUndet = s.hasTag(UNDETVAR);
+
         if (tValue != sValue) {
-            return tValue ?
-                    isSubtype(t.referenceProjection(), s) :
-                    !t.hasTag(BOT) && isSubtype(t, s.referenceProjection());
+            boolean result = tValue ?
+                    isSubtype(allowUniversalTVars && (tUndet || sUndet) ? t : t.referenceProjection(), s) :
+                    !t.hasTag(BOT) && isSubtype(t, allowUniversalTVars && (tUndet || sUndet) ? s : s.referenceProjection());
+            if (result && (allowUniversalTVars && !t.hasTag(BOT) &&
+                    s.isPrimitiveClass() && !t.isPrimitiveClass() &&
+                    s.referenceProjectionOrSelf().tsym == t.tsym)) {
+                chk.warnValueConversion(warn.pos(), Warnings.PrimitiveValueConversion);
+            }
+            return result;
         }
 
         boolean tPrimitive = t.isPrimitive();
         boolean sPrimitive = s.isPrimitive();
         if (tPrimitive == sPrimitive) {
             return isSubtypeUnchecked(t, s, warn);
         }
-        boolean tUndet = t.hasTag(UNDETVAR);
-        boolean sUndet = s.hasTag(UNDETVAR);
 
         if (tUndet || sUndet) {
             return tUndet ?
@@ -1017,6 +1034,41 @@ public boolean test(Symbol sym) {
        }
     }
 
+    public boolean isPrimitiveClass(Type t) {
+        return t != null && t.isPrimitiveClass();
+    }
+
+    @FunctionalInterface
+    public interface SubtypeTestFlavor {
+        boolean subtypeTest(Type t, Type s, Warner warn);
+    }
+
+    // this relation is now named `extends` in the latest Valhalla docs
+    public boolean isBoundedBy(Type t, Type s) {
+        return isBoundedBy(t, s, noWarnings, (t1, s1, w1) -> isSubtype(t1, s1));
+    }
+
+    public boolean isBoundedBy(Type t, Type s, SubtypeTestFlavor subtypeTestFlavor) {
+        return isBoundedBy(t, s, noWarnings, subtypeTestFlavor);
+    }
+
+    /**
+     * Is type t bounded by s?
+     */
+    public boolean isBoundedBy(Type t, Type s, Warner warn, SubtypeTestFlavor subtypeTestFlavor) {
+        boolean result = subtypeTestFlavor.subtypeTest(t, s, warn);
+        if (allowUniversalTVars && !result) {
+            if (isPrimitiveClass(t)) {
+                return isBoundedBy(t.referenceProjection(), s, warn, subtypeTestFlavor);
+            } else if (t.hasTag(TYPEVAR) && ((TypeVar)t).isUniversal()) {
+                return isBoundedBy(t.getUpperBound(), s, warn, subtypeTestFlavor);
+            } else if (s.hasTag(TYPEVAR) && ((TypeVar)s).isUniversal()) {
+                return isBoundedBy(t, s.getLowerBound(), warn, subtypeTestFlavor);
+            }
+        }
+        return result;
+    }
+
     // <editor-fold defaultstate="collapsed" desc="isSubtype">
     /**
      * Is t an unchecked subtype of s?
@@ -1054,6 +1106,9 @@ private boolean isSubtypeUncheckedInternal(Type t, Type s, boolean capture, Warn
                 }
             } else if (isSubtype(t, s, capture)) {
                 return true;
+            } else if (allowUniversalTVars && t.hasTag(TYPEVAR) && s.hasTag(TYPEVAR) && t.tsym == s.tsym) {
+                warn.warn(LintCategory.UNIVERSAL);
+                return true;
             } else if (t.hasTag(TYPEVAR)) {
                 return isSubtypeUncheckedInternal(t.getUpperBound(), s, false, warn);
             } else if (!s.isRaw()) {
@@ -1105,6 +1160,9 @@ public final boolean isSubtypeNoCapture(Type t, Type s) {
     public boolean isSubtype(Type t, Type s, boolean capture) {
         if (t.equalsIgnoreMetadata(s))
             return true;
+        if (t.hasTag(TYPEVAR) && s.hasTag(TYPEVAR) && t.tsym == s.tsym) {
+            return true;
+        }
         if (s.isPartial())
             return isSuperType(s, t);
 
@@ -1146,6 +1204,9 @@ public Boolean visitType(Type t, Type s) {
                  case TYPEVAR:
                      return isSubtypeNoCapture(t.getUpperBound(), s);
                  case BOT:
+                     if (allowUniversalTVars && s.hasTag(TYPEVAR) && ((TypeVar)s).isValueProjection()) {
+                         warnStack.head.warn(LintCategory.UNIVERSAL);
+                     }
                      return
                          s.hasTag(BOT) || (s.hasTag(CLASS) && !s.isPrimitiveClass()) ||
                          s.hasTag(ARRAY) || s.hasTag(TYPEVAR);
@@ -1642,8 +1703,10 @@ public Boolean visitWildcardType(WildcardType t, Type s) {
                     // ---------------------------------------------------------------------------
                     return isSameWildcard(t, s)
                         || isCaptureOf(s, t)
-                        || ((t.isExtendsBound() || isSubtypeNoCapture(wildLowerBound(t), wildLowerBound(s))) &&
-                            (t.isSuperBound() || isSubtypeNoCapture(wildUpperBound(s), wildUpperBound(t))));
+                        || ((t.isExtendsBound() || isBoundedBy(wildLowerBound(t), wildLowerBound(s),
+                                (t1, s1, w) -> isSubtypeNoCapture(t1, s1))) &&
+                            (t.isSuperBound() || isBoundedBy(wildUpperBound(s), wildUpperBound(t),
+                                (t1, s1, w) -> isSubtypeNoCapture(t1, s1))));
                 }
             }
 
@@ -1656,6 +1719,16 @@ public Boolean visitUndetVar(UndetVar t, Type s) {
                 }
             }
 
+            @Override
+            public Boolean visitTypeVar(TypeVar t, Type s) {
+                if (s.hasTag(TYPEVAR)) {
+                    TypeVar other = (TypeVar)s;
+                    if (allowUniversalTVars && t.isValueProjection() != other.isValueProjection() && t.tsym == other.tsym)
+                        return true;
+                }
+                return isSameType(t, s);
+            }
+
             @Override
             public Boolean visitErrorType(ErrorType t, Type s) {
                 return true;
@@ -2076,7 +2149,7 @@ public boolean notSoftSubtype(Type t, Type s) {
         if (!s.hasTag(WILDCARD))
             s = cvarUpperBound(s);
 
-        return !isSubtype(t, relaxBound(s));
+        return !isBoundedBy(t, relaxBound(s), (t1, s1, w) -> isSubtype(t1, s1));
     }
 
     private Type relaxBound(Type t) {
@@ -3545,7 +3618,11 @@ public Type visitTypeVar(TypeVar t, Void ignored) {
             for (List<Type> from = this.from, to = this.to;
                  from.nonEmpty();
                  from = from.tail, to = to.tail) {
-                if (t.equalsIgnoreMetadata(from.head)) {
+                if (t.equalsIgnoreMetadata(from.head) ||
+                    allowUniversalTVars &&
+                    !t.isValueProjection() &&
+                    from.head.hasTag(TYPEVAR) &&
+                    t.equalsIgnoreMetadata(((TypeVar)from.head).referenceProjection())) {
                     return to.head.withTypeVar(t);
                 }
             }
@@ -3697,7 +3774,11 @@ public List<Type> newInstances(List<Type> tvars) {
         private static final TypeMapping<Void> newInstanceFun = new TypeMapping<Void>() {
             @Override
             public TypeVar visitTypeVar(TypeVar t, Void _unused) {
-                return new TypeVar(t.tsym, t.getUpperBound(), t.getLowerBound(), t.getMetadata());
+                TypeVar newTV = new TypeVar(t.tsym, t.getUpperBound(), t.getLowerBound(), t.getMetadata(), t.isReferenceProjection);
+                if (t.projection != null) {
+                    newTV.referenceProjection();
+                }
+                return newTV;
             }
         };
     // </editor-fold>
@@ -4162,6 +4243,10 @@ public Type lub(Type... ts) {
         final int UNKNOWN_BOUND = 0;
         final int ARRAY_BOUND = 1;
         final int CLASS_BOUND = 2;
+        // lub is critical code better to go this way rather than using streams
+        for (int i = 0; i < ts.length; i++) {
+            ts[i] = ts[i].referenceProjectionOrSelf();
+        }
 
         int[] kinds = new int[ts.length];
         int boundkind = UNKNOWN_BOUND;