path: root/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/GroovyBundle.properties

#
#  Copyright 2000-2007 JetBrains s.r.o.
#  Licensed under the Apache License, Version 2.0 (the "License");
#  you may not use this file except in compliance with the License.
#  You may obtain a copy of the License at
#
#  http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing, software
#  distributed under the License is distributed on an "AS IS" BASIS,
#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#  See the License for the specific language governing permissions and
#  limitations under the License.
#

########################################################################################################################
# Groovy script template
########################################################################################################################
file.template.group.title.groovy=Groovy

newclass.dlg.title=New Groovy Class
newclass.menu.action.text=Groovy Class
newclass.menu.action.description=Creates new Groovy Class
newscript.dlg.prompt=Enter name for new Groovy Script
newscript.menu.action.text=Groovy Script
newscript.menu.action.description=Creates new Groovy Script
##########################################################################################################################
# GDK & compilation
########################################################################################################################

cannot.compile.groovy.files.no.facet=Cannot find Groovy home for module ''{0}''.\nYou should either:\n\
- invoke 'Add Framework support' action for this module,\n\
or:\n\
- add Groovy JARs to module classpath manually.
cannot.compile.groovy.files.no.sdk=Cannot Compile Groovy Files.\nPlease Set up SDK for module ''{0}''.
cannot.compile.groovy.files.no.sdk.mult=Cannot Compile Groovy Files.\nPlease Set up SDK for modules ''{0}''.
cannot.compile=Cannot Compile
debug.option=Enable &debug stacktrace
groovy.debug.disable.specific.methods=Do not step &into specific Groovy classes
groovy.debug.caption=Groovy

########################################################################################################################
# Parser error messages
########################################################################################################################

separator.expected=';' or new line expected
separator.or.rcurly.expected=';', '}' or new line expected
import.keyword.expected='import' expected
import.identifier.expected=package or class name expected
identifier.expected=Identifier expected
import.not.allowed=Imports are not allowed inside blocks
identifier.or.block.expected=Identifier or code block expected
string.end.expected=String end expected
regex.end.expected=Regex ending expected
lbrack.expected='[' expected
rbrack.expected=']' expected
lparen.expected='(' expected
lcurly.expected='{' expected
comma.expected=',' expected
rcurly.expected='}' expected
rparen.expected=')' expected
comma.or.rparen.expected=',' or ')' expected
semi.expected=';' expected
gt.expected='>' expected
else.without.if='else' without 'if'
catch.without.try='catch' without 'try'
finally.without.try='finally' without 'try'
case.without.switch='case' outside 'switch' block
default.without.switch='default' outside 'switch' block
catch.or.finally.expected='catch' or 'finally' expected
colon.expected=':' expected
wrong.statement=Wrong statement
variable.definitions.expected=Variable definition expected
method.definitions.expected=Method definition expected
type.specification.expected=Type specification expected
type.definition.expected=Type definition expected
expression.expected=Expression expected
annotation.initializer.expected=Annotation initializer expected
annotation.member.value.initializer.expected=Annotation member value initializer expected
case.block.expected=Case block expected
case.expected='case' or 'default' expected
block.expression.expected=Block expression expected
wrong.string=Wrong string literal
path.selector.expected=Property selector expected
duplicate.modifier=Duplicate modifier ''{0}''
param.expected=Parameter expected
for.clause.expected=clause expected
at.expected='@' expected
if.expected='if' expected
compound.statemenet.expected=Initializer block expected
indentifier.or.string.or.left.parenth.literal.expected=Identifier, string literal or '(' expected

empty.parameter.list.expected=empty parameter list expected
string.name.unexpected=string name unexpected
method.definition.without.modifier=Method definition must be precede by modifier, type or 'def' keyword
interface.body.expected=interface body expected
interface.must.has.no.static.compound.statemenet=static compound statement unexpected in interface
interface.must.has.no.compound.statemenet=compound statement unexpected in interface

########################################################################################################################
# Intentions & error messages
########################################################################################################################
cannot.resolve=Cannot resolve symbol ''{0}''
ambiguous.constructor.call=Ambiguous constructor call
cannot.access=Access to ''{0}'' exceeds its access rights
cannot.reference.static=Cannot reference static symbol ''{0}'', class qualifier needed
cannot.reference.non.static=Cannot reference non-static symbol ''{0}'' from static context
cannot.return.from.constructor=Cannot return an object from constructor
cannot.return.from.void.method=Cannot return an object from a method that returns 'void'
cannot.apply.method.or.closure=''{0}'' cannot be applied to ''{1}''
cannot.apply.method1=''{0}'' in ''{1}'' cannot be applied to ''{2}''
cannot.apply.constructor=Constructor ''{0}'' in ''{1}'' cannot be applied to ''{2}''
cannot.apply.default.constructor=Cannot apply default constructor for class ''{0}''
cannot.instantiate.abstract.class=Cannot instantiate abstract class ''{0}''
cannot.instantiate.interface=Cannot instantiate interface ''{0}''
cannot.assign=Cannot assign ''{0}'' to ''{1}''
invalid.lvalue=Invalid value to assign to
duplicate.class=Class ''{0}'' already exists in ''{1}''
duplicate.inner.class=Duplicate class: ''{0}''
script.generated.with.same.name=There is a synthetic class ''{0}'' generated for script code
variable.already.defined=Variable ''{0}'' already defined
field.already.defined=Field ''{0}'' already defined
import.what=Import ''{0}''
import.class=Import Class
create.class.family.name=Create Class
create.class.text=Create Class {0}
create.interface.text=Create Interface {0}
create.annotation.text=Create Annotation {0}
static.declaration.in.inner.class=Inner classes cannot have static declarations
constructors.are.not.allowed.in.anonymous.class=Constructors are not allowed in anonymous class
no.such.property=Property ''{0}'' does not exist
change.modifier=Make ''{0}'' {1}
change.modifier.not=Make ''{0}'' not {1}
change.modifier.family.name=Change modifiers
# suppress inspection "UnusedProperty"
packageLocal.visibility.presentation=default visible
# suppress inspection "UnusedProperty"
protected.visibility.presentation=protected
# suppress inspection "UnusedProperty"
private.visibility.presentation=private
# suppress inspection "UnusedProperty"
public.visibility.presentation=public
# suppress inspection "UnusedProperty"
abstract.visibility.presentation=abstract
# suppress inspection "UnusedProperty"
static.visibility.presentation=static
# suppress inspection "UnusedProperty"
final.visibility.presentation=final
# suppress inspection "UnusedProperty"
native.visibility.presentation=native
# suppress inspection "UnusedProperty"
synchronized.visibility.presentation=synchronized
# suppress inspection "UnusedProperty"
strictfp.visibility.presentation=strictfp
# suppress inspection "UnusedProperty"
transient.visibility.presentation=transient
# suppress inspection "UnusedProperty"
volatile.visibility.presentation=volatile
# suppress inspection "UnusedProperty"
def.visibility.presentation=def



# {0} - colspan, {1} - method name, {2} - class name, {3} - formal myParameters row, {4} - arguments row
########################################################################################################################
# Compiler
########################################################################################################################
class.already.exists=Class ''{0}'' already exists

annotation.definition.qualified.name.expected=Annotation definition qualified name expected
type.expected=Type expected
type.parameter.expected=Type parameter expected
type.argument.expected=Type argument expected

illegal.combination.of.modifiers=Illegal combination of modifiers
illegal.combination.of.modifiers.abstract.and.final=Illegal combination of modifiers 'abstract' and 'final'
modifier.volatile.not.allowed.here=Modifier 'volatile' not allowed here
modifier.transient.not.allowed.here=Modifier 'transient' not allowed here
intarface.cannot.have.modifier.final=Interface cannot have modifier 'final'
script.method.cannot.have.modifier.abstract=Script method cannot have modifier 'abstract'
script.cannot.have.modifier.native=Script cannot have modifier 'native'
interface.must.have.no.static.method=Interface must have no static method
only.abstract.class.can.have.abstract.method=Only abstract class can have abstract method
anonymous.class.cannot.have.abstract.method=Anonymous class cannot have abstract method
illegal.combination.of.modifiers.volatile.and.final=Illegal combination of modifiers 'volatile' and 'final'
variable.cannot.be.native=Variable cannot have modifier 'native'
variable.cannot.be.abstract=Variable cannot have modifier 'abstract'
not.abstract.method.should.have.body=Not abstract method should have body
cannot.create.class.error.text=Cannot Create Class ''{0}'': {1}
cannot.create.class.error.title=Cannot Create Class
no.class.in.file.template=No Class Found in File Template
error.external=External error
Inner.methods.are.not.supported=Inner methods are not supported
final.class.cannot.be.extended=Final class cannot be extended

#Override and implement
method.is.not.implemented=Method ''{0}'' is not implemented
change.implements.and.extends.classes=Normalize extends and implements lists

class.is.not.expected.here=Class is not expected here
fix.package.name=Fix package name

#dynamic properties
add.dynamic.property=Add Dynamic Property ''{0}''
duplicate.element.in.the.map=Duplicate element in the map
dynamic.toolwindow.search.elements=Search dynamic element
dynamic.toolwindow.property.filter=Property Filter
dynamic.tool.window.id=Dynamic Properties

create.from.usage.family.name=Create From Usage
create.field.from.usage=Create Field ''{0}''
create.method.from.usage=Create Method ''{0}''
create.variable.from.usage=Create Variable ''{0}''
add.dynamic.element=Add dynamic element
add.dynamic.method=Add Dynamic Method
dynamic.type=Type
dynamic.name=Name
dynamic.properties.table.name=Method arguments
dynamic.method.return.type=Return &type:
dynamic.method.property.type=Property &type:
are.you.sure.to.delete.dynamic.property=Are you sure to delete ''{0}''?
dynamic.property.deletion=Deletion Dynamic Property
are.you.sure.to.delete.elements=Are you sure to delete ''{0}'' elements?
dynamic.element.deletion=Dynamic Element Deletion
dynamic.window=Dynamic window
dynamic.properties.table.no.arguments=Arguments list is empty.
assignment.expected='=' expected
tuple.cant.be.placed.in.class=Multiple assignments are not allowed for fields
singleton.class.should.have.private.constructor=Class with '@Singleton' annotation should have private constructor
qualified.new.of.static.class=Qualified new of static class
unknown.class=unknown class ''{0}''
is.not.enclosing.class=''{0}'' is not an enclosing class
package.definition.cannot.have.modifiers=Package definition cannot have modifiers
import.statement.cannot.have.modifiers=Import statement cannot have modifiers
inner.classes.are.not.supported=Inner classes are not supported in Groovy {0}
anonymous.classes.are.not.supported=Anonymous classes are not supported in Groovy {0}
undefined.label=Undefined label ''{0}''
continue.outside.loop=The continue statement is only allowed inside loops
break.outside.loop.or.switch=The break statement is only allowed inside loops or switches
label.already.used=Label ''{0}'' is already in use
break.outside.loop=The break statement with named labels is only allowed inside loops

Constructor=Constructor
Getter=Getter
Setter=Setter
groovy.like.library.found=Groovy Library Found
groovy.like.library.found.text=Do you want to set up Groovy for module ''{0}'' \n\
with found library ''{1}'' (Groovy version {2})?
compile.groovy.files=&Compile Groovy files
in.expected='in' expected
not.allowed.modifier.in.forin=Modifier ''{0}'' is not allowed here
property.name.expected=Property name expected
add.method.body=Add method body
wildcards.are.not.allowed.in.extends.list=A super type may not specify a wildcard type
method.doesnot.override.super=Method does not override method from its super class
method.duplicate=Method with signature {0} is already defined in the class ''{1}''
ambiguous.code.block=Ambiguous code block
cyclic.inheritance.involving.0=Cyclic inheritance involving ''{0}''
there.is.no.default.constructor.available.in.class.0=There is no default constructor available in class ''{0}''
groovy.library.is.not.configured.for.module=Groovy SDK is not configured for module ''{0}''
configure.groovy.library=Configure Groovy SDK...
create.instance.of.built-in.type=Instantiation of built-in type
incorrect.variable.name=Incorrect variable name
is.not.supported.in.version=Command Expression syntax is not supported in Groovy {0}
no.interface.expected.here=No interface expected here
no.class.expected.here=No class expected here
move.to.extends.list=Move reference to extends list
move.to.implements.list=Move reference to implements list
script.file.is.not.groovy.file=Script file is not Groovy file
class.does.not.exist=Class does not exist
class.can't\ be\ executed=Class cannot be executed
invoke.completion.second.time.to.show.skipped.methods=Invoke completion second time to show skipped methods
groovy.file.extension.is.not.mapped.to.groovy.file.type=*.groovy files are mapped to ''{0}''.\nYou can map them to Groovy in Settings | File types
class.is.not.annotation=''{0}'' is not an annotation
method.call.is.ambiguous=Method call is ambiguous
duplicated.named.parameter=Duplicated named parameter ''{0}'' found
no.super.classes.found=No super classes found
no.super.method.found=No super methods found
wrong.package.name=Package name ''{0}'' does not corresponding to the file path ''{1}''
cannot.assign.string.to.enum.0=Cannot assign string to enum ''{0}''
cannot.find.enum.constant.0.in.enum.1=Cannot find enum constant ''{0}'' in enum ''{1}''
recursive.constructor.invocation=Recursive constructor invocation
the.usage.of.a.map.entry.expression.to.initialize.an.enum.is.currently.not.supported=The usage of a map entry expression to initialize an Enum is currently not supported
class.definition.is.not.expected.here=Class definition is not expected here
move.class.0.from.method=Move ''{0}'' to correct place
move.class.from.method.family.name=Move to correct place quick fix
diamonds.are.not.allowed.in.groovy.0=Diamonds are not allowed in Groovy {0}
multiline.slashy.strings.are.not.allowed.in.groovy.0=Multi-line slashy strings are not allowed in Groovy {0}
slashy.strings.with.injections.are.not.allowed.in.groovy.0=Slashy strings with injections are not allowed in Groovy {0}
constructor.call.is.ambiguous=Constructor call is ambiguous
cannot.infer.argument.types=Cannot infer argument types
triple.is.not.expected.here='...' is not expected here
Equals=Equals
default.initializers.are.not.allowed.in.abstract.method=Default initializers are not allowed in abstract methods
groovy.does.not.support.constructor.type.arguments=Groovy does not support constructor type arguments
illegal.escape.character.in.string.literal=Illegal escape character in string literal
dollar.slash.end.expected=Dollar slash ending expected
add.parentheses=Add parentheses
add.parentheses.to.command.method.call=Add parentheses to command method call
dollar.slash.strings.are.not.allowed.in.0=Dollar slashy strings are not allowed in Groovy {0}
method.with.type.parameters.should.have.return.type=Method with type parameters should have return type
primitive.type.parameters.are.not.allowed=Primitive type parameters are not allowed in type parameter list
primitive.bound.types.are.not.allowed=Primitive bound types are not allowed
ellipsis.type.is.not.allowed.here=Ellipsis type is not allowed here
method.0.is.too.complex.too.analyze=Method ''{0}'' is too complex to analyze.\nTypes of local variables are not inferred.
closure.is.too.complex.to.analyze=Closure is complex to analyze.\nTypes of local variables are not inferred.
0.is.deprecated=''{0}'' is deprecated
create.parameter.from.usage=Create Parameter ''{0}''
wrong.number.of.type.arguments=Wrong number of type arguments\: {0}; required\: {1}
type.argument.0.is.not.in.its.bound.should.extend.1=Type parameter ''{0}'' is not in its bound; should extend ''{1}''
catch.statement.parameter.type.should.be.a.subclass.of.throwable=Catch statement parameter type should be a subclass of Throwable
exception.0.has.already.been.caught=Exception ''{0}'' has already been caught
unnecessary.type=Unnecessary exception ''{0}''. ''{1}'' is already declared
create.enum=Create Enum {0}
create.trait=Create Trait {0}
create.inner.class=Create Inner Class {0}
annotation.field.can.only.be.used.within.a.script.body=Annotation @Field can only be used within a script body
annotation.field.can.only.be.used.within.a.script=Annotation @Field can only be used within a script
public.modifier.is.not.allowed.in.interfaces='public' modifier is not allowed in interfaces
return.type.is.incompatible=The return type of {0} in {1} is incompatible with {2} in {3}
anonymous.class.derived.from.0=anonymous class derived from {0}
throws.clause.is.not.allowed.in.at.interface='throws' clause is not allowed in @interface members
at.interface.0.does.not.contain.attribute=@interface ''{0}'' does not contain attribute ''{1}''
duplicate.attribute=Duplicate attribute
missed.attributes=Missed attributes\: {0}
unexpected.attribute.type.0=Unexpected attribute type\: ''{0}''
annotation.attribute.should.have.return.type.declaration=Annotation attribute should have return type declaration
interface.members.are.not.allowed.to.be=Interface members are not allowed to be {0}
abstract.method.cannot.be.final=Abstract method cannot be final
abstract.methods.must.not.have.body=Abstract methods must not have body
method.has.incorrect.modifier.volatile=Method has incorrect modifier 'volatile'
native.methods.cannot.have.body=Native methods cannot have body
top.level.class.maynot.have.private.modifier=Top level class may not have 'private' modifier
top.level.class.maynot.have.protected.modifier=Top level class may not have 'protected' modifier
property.missing=propertyMissing
attribute.name.expected=Attribute name expected
java.style.for.each.statement.requires.a.type.declaration=Java-style for-each statement requires a type declaration
super.cannot.be.used.in.static.context='super' cannot be used in static context
qualified.0.is.allowed.only.in.nested.or.inner.classes=Qualified {0} is allowed only in nested/inner classes
groovy.file.0=Groovy file ''{0}''
type.argument.list.is.not.allowed.here=Type argument list is not allowed here
initializers.are.not.allowed.in.interface=Initializers are not allowed in interface
initializer.cannot.have.annotations=Initializers cannot have annotations
initializer.cannot.be.0=Initializer cannot be {0}
constructors.are.not.allowed.in.interface=Constructors are not allowed in interface
type.parameters.are.unexpected=Type parameters are unexpected
constructors.cannot.have.return.type=Return type element is not allowed in constructor
constructor.cannot.have.static.modifier=Constructor may not be static
annotation.types.may.not.have.extends.clause=Annotation types may not have 'extends' clause
annotation.types.may.not.have.implements.clause=Annotation types may not have 'implements' clause
no.implements.clause.allowed.for.interface=Interfaces may not have 'implements' clause
enums.may.not.have.extends.clause=Enums may not have 'extends' clause
method.0.cannot.override.method.1.in.2.overridden.method.is.final=Method ''{0}'' cannot override method ''{1}'' in ''{2}''; overridden method is final
method.0.cannot.have.weaker.access.privileges.1.than.2.in.3.4=Method ''{0}'' cannot have weaker access privileges (''{1}'') than ''{2}'' in ''{3}'' (''{4}'')
tuple.declaration.should.end.with.def.modifier=Tuple declaration should end with 'def' modifier
injection.should.not.contain.line.feeds=GString injection must not contain line feeds
collection.literal.contains.named.argument.and.expression.items=Collection literal contains named and expression arguments at the same time
annotation.collector.cannot.have.attributes=Annotation type annotated with @AnnotationCollector cannot have attributes
annotation.expected=Annotation expected
annotation.type.cannot.be.inner=Annotation type cannot be inner
cannot.find.operator.overload.method=Cannot resolve index access with arguments {0}
named.arguments.are.not.allowed.inside.index.operations=Named arguments are not allowed inside index operations
expected.0.to.be.inline.constant=Expected ''{0}'' to be an inline constant
cannot.assign.a.value.to.final.field.0=Cannot assign a value to final field ''{0}''
cannot.assign.a.value.to.final.parameter.0=Cannot assign a value to final parameter ''{0}''
variable.0.might.not.have.been.initialized=Variable ''{0}'' might not have been initialized
unexpected.symbol=Unexpected symbol
statement.expected=Statement expected
annotation.attribute.expected=Annotation attribute expected
highlight.constructor.calls.of.a.non.static.inner.classes.without.enclosing.instance.passed=Highlight constructor calls of non-static inner classes without enclosing instance passed
doc.end.expected='*/' expected
mixing.private.and.public.protected.methods.of.the.same.name=Mixing private and public/protected methods of the same name
explicit.constructors.are.not.allowed.in.immutable.class=Explicit constructors are not allowed for @Immutable class
repetitive.method.name.0=Repetitive method name ''{0}''
assign.expected='=' expected
declared.type.0.have.to.extend.script=Declared type ''{0}'' does not extend 'groovy.lang.Script' class
base.script.annotation.is.allowed.only.inside.scripts=Annotation @BaseScript can only be used within a script
0.expressions.on.trait.fields.properties.are.not.supported.in.traits={0} expressions on trait fields/properties are not supported in traits
only.traits.expected.here=Only traits are expected here
anonymous.classes.cannot.be.created.from.traits=Anonymous classes cannot be created from traits
trait.method.cannot.be.protected=Trait methods are not allowed to be protected
traits.are.not.supported.in.groovy.0=Traits are not supported in Groovy {0}