< prev index next >

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

Print this page
*** 685,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
  
  compiler.err.improperly.formed.type.inner.raw.param=\
      improperly formed type, type arguments given on a raw type
  
  # 0: type, 1: type
--- 685,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 or misplaced
  
  compiler.err.improperly.formed.type.inner.raw.param=\
      improperly formed type, type arguments given on a raw type
  
  # 0: type, 1: type

*** 2475,10 ***
--- 2475,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}
  
  #####

*** 3814,11 ***
--- 3817,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
+ 
+ # 0: symbol
+ compiler.err.cyclic.primitive.class.membership=\
+     cyclic primitive class membership involving {0}
+ 
+ compiler.warn.get.class.compared.with.interface=\
+     return value of getClass() can never equal the class literal of an interface
+ 
+ # 0: name (of method)
+ compiler.err.primitive.class.may.not.override=\
+     primitive classes may not override the method {0} from Object
+ 
+ # 0: name (of method)
+ compiler.err.primitive.class.does.not.support=\
+     primitive classes do not support {0}
+ 
+ compiler.err.primitive.class.may.not.extend=\
+     inappropriate super class declaration for a primitive class
+ 
+ compiler.err.primitive.class.instance.field.expected.here=\
+     withfield operator requires an instance field of a primitive class here
+ 
+ compiler.err.with.field.operator.disallowed=\
+     WithField operator is allowed only with -XDallowWithFieldOperator
+ 
+ compiler.err.this.exposed.prematurely=\
+     primitive 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
+ compiler.err.primitive.class.must.not.implement.identity.object=\
+     The primitive class {0} attempts to implement the incompatible interface IdentityObject
+ 
+ # 0: type
+ compiler.err.primitive.class.must.not.implement.cloneable=\
+     The primitive class {0} attempts to implement the incompatible interface Cloneable
+ 
+ # 0: type
+ compiler.err.identity.class.must.not.implement.primitive.object=\
+     The identity class {0} attempts to implement the incompatible interface PrimitiveObject
+ 
+ # 0: type
+ compiler.err.mutually.incompatible.super.interfaces=\
+     The type {0} attempts to implement the mutually incompatible interfaces PrimitiveObject and IdentityObject
+ 
+ # 0: symbol, 1: type
+ compiler.err.concrete.supertype.for.primitive.class=\
+     The concrete class {1} is not allowed to be a super class of the primitive class {0} either directly or indirectly
+ 
+ # 0: symbol, 1: symbol, 2: type
+ compiler.err.super.method.cannot.be.synchronized=\
+     The method {0} in the super class {2} of the primitive class {1} is synchronized. This is disallowed
+ 
+ # 0: symbol, 1: symbol, 2: type
+ compiler.err.super.constructor.cannot.take.arguments=\
+     The super class {2} of the primitive class {1} defines a constructor {0} that takes arguments. This is disallowed
+ 
+ # 0: symbol, 1: symbol, 2: type
+ compiler.err.super.field.not.allowed=\
+     The super class {2} of the primitive class {1} defines an instance field {0}. This is disallowed
+ 
+ # 0: symbol, 1: symbol, 2: type
+ compiler.err.super.no.arg.constructor.must.be.empty=\
+     The super class {2} of the primitive class {1} defines a nonempty no-arg constructor {0}. This is disallowed
+ 
+ # 0: symbol, 1: type
+ compiler.err.super.class.declares.init.block=\
+     The super class {1} of the primitive class {0} declares one or more non-empty instance initializer blocks. This is disallowed.
+ 
+ # 0: symbol, 1: type
+ compiler.err.super.class.cannot.be.inner=\
+     The super class {1} of the primitive class {0} is an inner class. This is disallowed.
+ 
+ compiler.err.projection.cant.be.instantiated=\
+     Illegal attempt to instantiate a projection type
+ 
+ compiler.err.call.to.super.not.allowed.in.primitive.ctor=\
+     call to super not allowed in primitive class constructor
+ 
  # 0: kind name, 1: symbol
  compiler.warn.declared.using.preview=\
      {0} {1} is declared using a preview feature, which may be removed in a future release.
  
  compiler.warn.attempt.to.synchronize.on.instance.of.value.based.class=\
      attempt to synchronize on an instance of a value-based class
+ 
+ compiler.note.cant.instantiate.object.directly=\
+     Object cannot be instantiated directly; a subclass of Object will be instantiated instead, by invoking java.util.Objects.newIdentity()
< prev index next >