src/jdk.compiler/share/classes/com/sun/tools/javac/resources/compiler.properties

@@ -266,10 +266,16 @@
  
  # 0: kind name, 1: symbol
  compiler.misc.incompatible.abstracts=\
      multiple non-overriding abstract methods found in {0} {1}
  
+ compiler.misc.value.interface.nonfunctional=\
+     since it is a value interface
+ 
+ compiler.misc.identity.interface.nonfunctional=\
+     since it is an identity interface
+ 
  compiler.err.bad.functional.intf.anno=\
      Unexpected @FunctionalInterface annotation
  
  # 0: message segment
  compiler.err.bad.functional.intf.anno.1=\

@@ -712,11 +718,11 @@
  # 0: symbol
  compiler.err.import.requires.canonical=\
      import requires canonical name for {0}
  
  compiler.err.improperly.formed.type.param.missing=\
-     improperly formed type, some parameters are missing
+     improperly formed type, some parameters are missing or misplaced
  
  compiler.err.improperly.formed.type.inner.raw.param=\
      improperly formed type, type arguments given on a raw type
  
  # 0: type, 1: type

@@ -2599,10 +2605,13 @@
      reference
  
  compiler.misc.type.req.exact=\
      class or interface without bounds
  
+ compiler.misc.type.req.identity=\
+     a type with identity
+ 
  # 0: type
  compiler.misc.type.parameter=\
      type parameter {0}
  
  #####

@@ -3591,10 +3600,13 @@
      cannot resolve modules
  
  compiler.misc.bad.requires.flag=\
      bad requires flag: {0}
  
+ compiler.misc.bad.access.flags=\
+     bad access flags combination: {0}
+ 
  # 0: string
  compiler.err.invalid.module.specifier=\
      module specifier not allowed: {0}
  
  # 0: symbol

@@ -3919,10 +3931,98 @@
      (preview language features are only supported for release {1})
  
  compiler.err.preview.without.source.or.release=\
      --enable-preview must be used with either -source or --release
  
+ compiler.misc.feature.primitive.classes=\
+     primitive classes
+ 
+ compiler.misc.feature.value.classes=\
+     value classes
+ 
+ # 0: symbol
+ compiler.err.cyclic.primitive.class.membership=\
+     cyclic primitive class membership involving {0}
+ 
+ # 0: string (expected version)
+ compiler.err.primitive.classes.not.supported=\
+     primitive classes are not supported\n\
+      (use -source {0} or higher to enable primitive classes and pass compiler option: -XDenablePrimitiveClasses)
+ 
+ compiler.err.this.exposed.prematurely=\
+     value class instance should not be passed around before being fully initialized
+ 
+ # 0: type
+ compiler.err.generic.parameterization.with.primitive.class=\
+     Inferred type {0} involves generic parameterization by a primitive class
+ 
+ # 0: type, 1: type
+ compiler.err.value.type.has.identity.super.type=\
+     The identity type {1} cannot be a supertype of the value type {0}
+ 
+ # 0: type, 1: type
+ compiler.err.identity.type.has.value.super.type=\
+     The value type {1} cannot be a supertype of the identity type {0}
+ 
+ # 0: type, 1: type, 2: type
+ compiler.err.mutually.incompatible.supers=\
+     The type {0} has mutually incompatible supertypes: the identity type {1} and the value type {2}
+ 
+ # 0: symbol, 1: type
+ compiler.err.concrete.supertype.for.value.class=\
+     The concrete class {1} is not allowed to be a super class of the value class {0} either directly or indirectly
+ 
+ # 0: symbol, 1: symbol, 2: type
+ compiler.err.super.class.method.cannot.be.synchronized=\
+     The method {0} in the super class {2} of the value class {1} is synchronized. This is disallowed
+ 
+ # 0: symbol, 1: message segment
+ compiler.err.abstract.value.class.constructor.cannot.take.arguments=\
+     {1} defines a constructor {0} that takes arguments. This is disallowed
+ 
+ # 0: symbol, 1: message segment
+ compiler.err.abstract.value.class.constructor.cannot.be.generic=\
+     {1} defines a generic constructor {0}. This is disallowed
+ 
+ # 0: symbol, 1: message segment
+ compiler.err.abstract.value.class.constructor.cannot.throw=\
+     {1} defines a constructor {0} that throws an exception. This is disallowed
+ 
+ # 0: symbol, 1: message segment
+ compiler.err.abstract.value.class.constructor.has.weaker.access=\
+     {1} defines a constructor {0} with a weaker access privilege than the declaring class. This is disallowed
+ 
+ # 0: symbol, 1: message segment
+ compiler.err.instance.field.not.allowed=\
+     {1} defines an instance field {0}. This is disallowed
+ 
+ # 0: symbol, 1: message segment
+ compiler.err.abstract.value.class.no.arg.constructor.must.be.empty=\
+     {1} defines a nonempty no-arg constructor {0}. This is disallowed
+ 
+ # 0: message segment
+ compiler.err.abstract.value.class.declares.init.block=\
+     {0} declares one or more non-empty instance initializer blocks. This is disallowed.
+ 
+ # 0: message segment
+ compiler.err.abstract.value.class.cannot.be.inner=\
+     {0} is an inner class. This is disallowed.
+ 
+ # 0: symbol, 1: type
+ compiler.misc.superclass.of.value.class=\
+     The super class {1} of the value class {0}
+ 
+ # 0: symbol
+ compiler.misc.abstract.value.class=\
+     The abstract value class {0}
+ 
+ compiler.err.projection.cant.be.instantiated=\
+     Illegal attempt to instantiate a projection type
+ 
+ compiler.err.call.to.super.not.allowed.in.value.ctor=\
+     call to super not allowed in value class constructor
+ 
  # 0: symbol
  compiler.err.deconstruction.pattern.only.records=\
      deconstruction patterns can only be applied to records, {0} is not a record
  
  # 0: list of type, 1: list of type