mirror of
https://gitflic.ru/project/openide/openide.git
synced 2025-12-16 14:23:28 +07:00
223 lines
11 KiB
Properties
223 lines
11 KiB
Properties
0.is.not.an.identifier=''{0}'' is not an identifier.
|
|
annotation.name.is.missing=Annotation attribute must be of the form 'name=value'
|
|
anonymous.class.context.display=Anonymous in {0}
|
|
anonymous.class.derived.display=Anonymous class derived from {0}
|
|
aux.context.display=(in {0})
|
|
bound.not.expected=Unexpected bound
|
|
catch.without.try='catch' without 'try'
|
|
class.context.display={0} in {1}
|
|
class.literal.expected=.class expected
|
|
context.type.java.comment=Comment
|
|
context.type.string=string
|
|
|
|
default.language.level.description=SDK default
|
|
|
|
# These constants are used from JavaElementKind
|
|
# When localizing you may use the parameter #0 which signals the desired grammatical case:
|
|
# 0 = nominative case (subject)
|
|
# 1 = accusative case (object)
|
|
element.abstract_method=abstract method
|
|
element.annotation=annotation
|
|
element.class=class
|
|
element.constant=constant field
|
|
element.constructor=constructor
|
|
element.enum=enum
|
|
element.enum_constant=enum constant
|
|
element.expression=expression
|
|
element.field=field
|
|
element.initializer=initializer
|
|
element.interface=interface
|
|
element.local_variable=local variable
|
|
element.method=method
|
|
element.module=module
|
|
element.package=package
|
|
element.parameter=parameter
|
|
element.pattern_variable=pattern variable
|
|
element.record=record
|
|
element.record_component=record component
|
|
element.statement=statement
|
|
element.unknown=element
|
|
element.variable=variable
|
|
|
|
else.without.if='else' without 'if'
|
|
enum.constant.context=Enum constant ''{0}'' in ''{1}''
|
|
expected.array.initializer=Array initializer expected
|
|
expected.boolean.expression=Boolean expression expected
|
|
expected.catch.or.finally='catch' or 'finally' expected
|
|
expected.class.or.interface='class' or 'interface' expected
|
|
expected.class.reference=Class reference expected
|
|
expected.colon=':' expected
|
|
expected.comma=',' expected
|
|
expected.comma.or.rparen=',' or ')' expected
|
|
expected.comma.or.semicolon=',' or ';' expected
|
|
expected.dot='.' expected
|
|
expected.eq='=' expected
|
|
expected.expression=Expression expected
|
|
expected.gt='>' expected.
|
|
expected.gt.or.comma='>' or ',' expected
|
|
expected.identifier=Identifier expected
|
|
expected.identifier.or.type=Identifier or type expected
|
|
expected.lbrace='{' expected
|
|
expected.lbrace.or.semicolon='{' or ';' expected
|
|
expected.lbracket='[' expected
|
|
expected.lparen='(' expected
|
|
expected.lparen.or.lbracket='(' or '[' expected
|
|
expected.lt.or.lparen='<' or '(' expected
|
|
expected.module.declaration=Module declaration expected
|
|
expected.module.statement=Module directive expected
|
|
expected.package.reference=Package reference expected
|
|
expected.parameter=Parameter expected
|
|
expected.rbrace='}' expected
|
|
expected.rbracket=']' expected
|
|
expected.resource=Resource definition expected
|
|
expected.rparen=')' expected
|
|
expected.semicolon=';' expected
|
|
expected.statement=Statement expected
|
|
expected.string=String literal expected
|
|
expected.switch.label='case', 'default' or '}' expected
|
|
expected.switch.rule=Expression, block or throw statement expected
|
|
expected.type=Type expected
|
|
expected.type.parameter=Type parameter expected
|
|
expected.value=Value expected
|
|
expected.while='while' expected
|
|
expected.with='with' expected
|
|
filetype.description.class=Java class
|
|
filetype.description.java=Java
|
|
filetype.description.jshell=JShell snippet
|
|
finally.without.try='finally' without 'try'
|
|
import.statement.identifier.or.asterisk.expected.=Identifier or '*' expected
|
|
|
|
java.terms.anonymous.class=anonymous class
|
|
java.terms.anonymous.class.base.ref=anonymous {0}
|
|
java.terms.class=class
|
|
java.terms.field=field
|
|
java.terms.interface=interface
|
|
java.terms.method=method
|
|
java.terms.package=package
|
|
java.terms.parameter=parameter
|
|
java.terms.variable=variable
|
|
javadoc.exception.tag.class.is.not.throwable=Class {0} is not a descendant of Throwable
|
|
javadoc.exception.tag.exception.is.not.thrown={0} is not declared to be thrown by method {1}
|
|
javadoc.exception.tag.wrong.tag.value=Wrong tag value
|
|
javadoc.param.tag.parameter.name.expected=Parameter name expected
|
|
javadoc.param.tag.type.parameter.gt.expected='>' expected
|
|
javadoc.param.tag.type.parameter.name.expected=Type parameter name expected
|
|
javadoc.ref.tag.class.ref.expected=Class reference expected
|
|
javadoc.value.field.required=@value tag must reference a field
|
|
javadoc.value.field.with.initializer.required=@value tag must reference a field with a constant initializer
|
|
javadoc.value.static.field.required=@value tag must reference a static field
|
|
javadoc.value.tag.jdk15.required=@value tag may not have any arguments when JDK 1.4 or earlier is used
|
|
jdk.1.3.language.level.description=1.3 - Plain old Java
|
|
jdk.1.4.language.level.description=1.4 - 'assert' keyword
|
|
jdk.1.5.language.level.description=5 - 'enum' keyword, generics, autoboxing etc.
|
|
jdk.1.6.language.level.description=6 - @Override in interfaces
|
|
jdk.1.7.language.level.description=7 - Diamonds, ARM, multi-catch etc.
|
|
jdk.1.8.language.level.description=8 - Lambdas, type annotations etc.
|
|
jdk.1.9.language.level.description=9 - Modules, private methods in interfaces etc.
|
|
jdk.10.language.level.description=10 - Local variable type inference
|
|
jdk.11.language.level.description=11 - Local variable syntax for lambda parameters
|
|
jdk.12.language.level.description=12 - No new language features
|
|
jdk.13.language.level.description=13 - No new language features
|
|
jdk.14.language.level.description=14 - Switch expressions
|
|
jdk.14.preview.language.level.description=14 (Preview) - Records, patterns, text blocks
|
|
jdk.15.language.level.description=15 - Text blocks
|
|
jdk.15.preview.language.level.description=15 (Preview) - Sealed types, records, patterns, local enums and interfaces
|
|
jdk.X.language.level.description=X - Experimental features
|
|
|
|
local.class.preposition=local
|
|
method.context.display={0}() in {1}
|
|
node.abstract.flag.tooltip=Abstract
|
|
node.annotation.tooltip=Annotation
|
|
node.anonymous.class.tooltip=Anonymous Class
|
|
node.class.tooltip=Class
|
|
node.enum.tooltip=Enum
|
|
node.exception.tooltip=Exception
|
|
node.field.tooltip=Field
|
|
node.final.flag.tooltip=Final
|
|
node.interface.tooltip=Interface
|
|
node.junit.test.tooltip=JUnit Test
|
|
node.method.tooltip=Method
|
|
node.record.tooltip=Record (Preview Feature)
|
|
node.runnable.class.tooltip=Runnable Class
|
|
node.static.flag.tooltip=Static
|
|
psi.error.attempt.to.edit.class.file=Cannot modify compiled element in file ''{0}''
|
|
|
|
task.background.title.maven=Maven
|
|
|
|
unexpected.identifier=Unexpected identifier
|
|
unexpected.token=Unexpected token
|
|
unexpected.tokens=Unexpected tokens
|
|
# suppress inspection "UnusedProperty"
|
|
visibility.presentation.abstract=abstract
|
|
# suppress inspection "UnusedProperty"
|
|
visibility.presentation.default=default
|
|
# suppress inspection "UnusedProperty"
|
|
visibility.presentation.final=final
|
|
# suppress inspection "UnusedProperty"
|
|
visibility.presentation.native=native
|
|
# suppress inspection "UnusedProperty"
|
|
visibility.presentation.open=open
|
|
# suppress inspection "UnusedProperty"
|
|
visibility.presentation.packageLocal=package-private
|
|
# suppress inspection "UnusedProperty"
|
|
visibility.presentation.private=private
|
|
# suppress inspection "UnusedProperty"
|
|
visibility.presentation.protected=protected
|
|
# suppress inspection "UnusedProperty"
|
|
visibility.presentation.public=public
|
|
# suppress inspection "UnusedProperty"
|
|
visibility.presentation.static=static
|
|
# suppress inspection "UnusedProperty"
|
|
visibility.presentation.strictfp=strictfp
|
|
# suppress inspection "UnusedProperty"
|
|
visibility.presentation.synchronized=synchronized
|
|
# suppress inspection "UnusedProperty"
|
|
visibility.presentation.transient=transient
|
|
# suppress inspection "UnusedProperty"
|
|
visibility.presentation.transitive=transitive
|
|
# suppress inspection "UnusedProperty"
|
|
visibility.presentation.volatile=volatile
|
|
# suppress inspection "UnusedProperty"
|
|
visibility.presentation.sealed=sealed
|
|
# suppress inspection "UnusedProperty"
|
|
visibility.presentation.non-sealed=non-sealed
|
|
error.message.wildcard.not.expected=Unexpected wildcard
|
|
|
|
bad.return.type.in.method.reference=Bad return type in method reference: cannot convert {0} to {1}
|
|
bad.return.type.in.lambda.expression=Bad return type in lambda expression: {0} cannot be converted to {1}
|
|
bad.return.type.in.lambda.expression1=Bad return type in lambda expression: {0} cannot be converted to void
|
|
missing.return.value.lambda=Missing return value
|
|
unexpected.return.value=Unexpected return value
|
|
lambda.body.must.be.a.statement.expression=Lambda body must be a statement expression
|
|
default.jre.name=Default
|
|
diamond.error.explicit.type.parameters.for.constructor=Cannot use diamonds with explicit type parameters for constructor
|
|
diamond.error.cannot.infer.arguments=Cannot infer arguments
|
|
diamond.error.cannot.infer.arguments.unable.to.resolve.constructor=Cannot infer arguments (unable to resolve constructor)
|
|
diamond.error.anonymous.inner.classes=Cannot use ''<>'' with anonymous inner classes
|
|
diamond.error.cannot.infer.type.arguments=Cannot infer type arguments for {0}
|
|
error.incompatible.type.no.type.variable=no instance(s) of type variable(s) exist so that {0}
|
|
error.incompatible.type.no.type.variable.0=no instance(s) of type variable(s) {0} exist so that {1}
|
|
type.conforms.to.constraint={0} conforms to {1}
|
|
type.can.be.converted={0} can be converted to {1}
|
|
conflicting.conjuncts={0} and {1}
|
|
error.type.parameter.has.incompatible.upper.bounds=Type parameter {0} has incompatible upper bounds: {1}
|
|
error.incompatible.upper.bounds=Incompatible upper bounds: {0}
|
|
error.inference.variable.has.incompatible.bounds=inference variable {0} has incompatible bounds:\n {1}: {2}\n{3}: {4}
|
|
error.incompatible.type={0} is not compatible with {1}
|
|
error.incompatible.type.not.a.functional.interface={0} is not a functional interface
|
|
error.incompatible.type.no.valid.function.type.found=No valid function type can be found for {0}
|
|
error.incompatible.type.parameter.type.is.not.yet.inferred=Parameter type is not yet inferred: {0}
|
|
error.incompatible.type.return.type.is.not.yet.inferred=Return type is not yet inferred: {0}
|
|
error.incompatible.type.unhandled.exception=Unhandled exception: {0}
|
|
error.incompatible.type.failed.to.resolve.argument=Failed to resolve argument
|
|
error.incompatible.type.incompatible.parameter.types.in.lambda=Incompatible parameter types in lambda expression
|
|
error.incompatible.type.incompatible.types.expected.void.lambda=Incompatible types: expected void but the lambda body is neither a statement expression nor a void-compatible block
|
|
error.incompatible.type.expected.value.lambda=Incompatible types: expected not void but the lambda body is a block that is not value-compatible
|
|
error.incompatible.type.bad.lambda.return.type=Bad return type in lambda expression: {0} cannot be converted to {1}
|
|
error.incompatible.type.incompatible.parameter.types.in.method.reference=Incompatible parameter types in method reference expression
|
|
error.incompatible.type.incompatible.types.expected.not.void.got.void.method.reference=Incompatible types: expected not void but compile-time declaration for the method reference has void return type
|
|
error.incompatible.type.declaration.for.the.method.reference.not.found=No compile-time declaration for the method reference is found
|
|
error.incompatible.type.expected.non.void.got.void.method.reference=Incompatible types: expected not void but compile-time declaration for the method reference has void return type
|
|
error.incompatible.type.not.convertible=Incompatible types: {0} is not convertible to {1}
|
|
error.incompatible.type.incompatible.equality.constraint=Incompatible equality constraint: {0} and {1}
|