openide/plugins/groovy/groovy-psi/resources/messages/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
########################################################################################################################
action.groovy.scripting.shell.text=Groovy IDE Scripting Shell
action.Mvc.RunTarget.text=Run Command
action.Mvc.RunTarget.description=Run arbitrary Grails/Griffon command
action.Mvc.Upgrade.text=Change SDK Version
action.Mvc.Upgrade.description=Change Grails/Griffon SDK version
group.Mvc.Actions.text=Grails/Griffon
action.Groovy.Shell.text=Groovy Shell...
action.Groovy.Shell.description=Launch Groovy shell
action.Groovy.Doc.Generating.text=Generate GroovyDoc...
action.Groovy.Doc.Generating.description=Generating Groovy documentation
action.org.jetbrains.plugins.groovy.actions.generate.missing.GroovyGeneratePropertyMissingAction.text=propertyMissing()
action.org.jetbrains.plugins.groovy.actions.generate.missing.GroovyGeneratePropertyMissingAction.description=Action generates propertyMissing()
action.org.jetbrains.plugins.groovy.actions.generate.missing.GroovyGenerateMethodMissingAction.text=methodMissing()
action.org.jetbrains.plugins.groovy.actions.generate.missing.GroovyGenerateMethodMissingAction.description=Action generates propertyMissing()
action.org.jetbrains.plugins.groovy.actions.generate.equals.GroovyGenerateEqualsAction.text=equals() and hashCode()
action.org.jetbrains.plugins.groovy.actions.generate.equals.GroovyGenerateEqualsAction.description=Action generates equals and hashCode now
action.org.jetbrains.plugins.groovy.actions.generate.accessors.GroovyGenerateGetterSetterAction.text=Getter and Setter
action.org.jetbrains.plugins.groovy.actions.generate.accessors.GroovyGenerateGetterSetterAction.description=Generates getter
action.org.jetbrains.plugins.groovy.actions.generate.accessors.GroovyGenerateSetterAction.text=Setter
action.org.jetbrains.plugins.groovy.actions.generate.accessors.GroovyGenerateSetterAction.description=Generates setter
action.org.jetbrains.plugins.groovy.actions.generate.accessors.GroovyGenerateGetterAction.text=Getter
action.org.jetbrains.plugins.groovy.actions.generate.accessors.GroovyGenerateGetterAction.description=Generates getter
action.org.jetbrains.plugins.groovy.actions.generate.constructors.GroovyGenerateConstructorAction.text=Constructor
action.org.jetbrains.plugins.groovy.actions.generate.constructors.GroovyGenerateConstructorAction.description=Generates constructor
action.org.jetbrains.plugins.groovy.actions.generate.tostring.GroovyGenerateToStringAction.text=to_String()
action.org.jetbrains.plugins.groovy.actions.generate.tostring.GroovyGenerateToStringAction.description=Generate toString() method
action.ExcludeFromStubGeneration.text=Exclude from Stub Generation
action.ExcludeFromStubGeneration.description=Don't generate Java stubs for this Groovy file on compilation
action.DumpGroovyControlFlowAction.text=Dump Groovy Control Flow
action.ConvertToCompileStatic.text=Convert to @CompileStatic
action.ConvertToCompileStatic.description=Convert Groovy files to @CompileStatic
action.ConvertGroovyToJava.text=Convert to Java
action.ConvertGroovyToJava.description=Convert Groovy files to Java
action.Groovy.NewScript.text=Groovy Script
action.Groovy.NewScript.description=Create new Groovy script
action.Groovy.NewClass.text=Groovy Class
action.Groovy.NewClass.description=Create new Groovy class
action.Groovy.CheckResources.Rebuild.text=_Rebuild Resources
action.Groovy.CheckResources.Rebuild.description=Run the compiler for all Groovy files in resource roots to check for compilation issues
action.Groovy.CheckResources.Make.text=_Build Resources
action.Groovy.CheckResources.Make.description=Run the incremental compiler for Groovy files in resource roots to check for compilation issues
group.Groovy.CheckResources.text=Gr_oovy Resources
group.Groovy.CheckResources.description=Run the compiler for Groovy files in resource roots to check for compilation issues
action.Groovy.Shell.Execute.text=Execute Groovy Code
action.Groovy.Shell.Execute.description=Execute Groovy code in console

file.template.group.title.groovy=Groovy

groovy.term.class=class
groovy.term.interface=interface
groovy.term.trait=trait
groovy.term.enum=enum
groovy.term.annotation=annotation
groovy.term.method=method
groovy.term.field=field
groovy.term.property=property
groovy.term.parameter=parameter
groovy.term.variable=local variable
groovy.term.binding=script binding variable
groovy.term.label=label
groovy.term.closure=closure
groovy.term.expression=expression

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=Cannot Compile
debug.option=Enable &debug stack trace
groovy.debug.disable.specific.methods=Do not step &into specific Groovy classes
groovy.debug.caption=Groovy

########################################################################################################################
# Parser error messages
########################################################################################################################
identifier.expected=Identifier expected
identifier.or.block.expected=Identifier or code block expected
string.end.expected=String end expected
try.without.catch.finally='try' without 'catch' or 'finally'
expression.expected=Expression expected
duplicate.modifier=Duplicate modifier ''{0}''

########################################################################################################################
# Intentions & error messages
########################################################################################################################
cannot.resolve=Cannot resolve symbol ''{0}''
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.return.type=Cannot return ''{0}'' from method returning ''{1}''
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}''
missing.required.named.parameter=Missing required named parameter ''{0}''
loss.of.precision=Possible loss of precision from ''{0}'' to ''{1}''
cannot.assign=Cannot assign ''{0}'' to ''{1}''
cannot.cast=Cannot cast ''{0}'' to ''{1}''
multiple.assignments.without.list.expr=Multiple assignments without list expressions on the right hand side are unsupported in static type checking mode
spread.operator.is.not.available=The spread operator cannot be used as argument with static type checking
replace.with.list.literal=Replace with list literal
replace.with.get.at=Replace with index access
incorrect.number.of.values=Incorrect number of values. Expected:{0} Was:{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
parameter.cast.fix=Cast {0,number,ordinal} parameter to {1}
action.convert.lambda.to.closure=Convert lambda to closure
add.parenthesis.to.lambda.parameter.list=Add parenthesis to parameter list
# 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

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
modifier.0.not.allowed=Modifier ''{0}'' not allowed here
interface.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=Variable cannot have modifier ''{0}''
remove.modifier=Remove ''{0}''
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

# Groovy 1.7 checks
unsupported.inner.class.0=Inner classes are not supported in Groovy {0}
unsupported.anonymous.class.0=Anonymous classes are not supported in Groovy {0}

# Groovy 1.8 checks
unsupported.diamonds.0=Diamonds are not supported in Groovy {0}
unsupported.command.syntax.0=Command expression syntax is not supported in Groovy {0}
unsupported.dollar.slashy.string.0=Dollar slashy strings are not supported in Groovy {0}
unsupported.multiline.slashy.string.0=Multi-line slashy strings are not supported in Groovy {0}

#Groovy 2.3 checks
unsupported.traits.0=Traits are not supported in Groovy {0}

#Groovy 2.5 checks
duplicating.named.parameter=Duplicate named parameter ''{0}'' occurs in parameters: {1}
field.should.be.immutable=Field ''{0}'' should have immutable type or be declared so with @ImmutableOptions
immutable.options.property.not.exist=Property ''{0}'' does not exist

#Groovy 3.0 checks
illegal.default.modifier=Modifier 'default' makes sense only in interface's methods
illegal.default.modifier.fix=Remove 'default' modifier
default.modifier.in.old.versions=Modifier 'default' is available with Groovy 3.0 or later
unsupported.do.while.statement='do while' is not supported in current version
unsupported.tuple.declaration.in.for=Tuple declaration in 'for' initialization is not supported in current version
unsupported.multiple.variables.in.for=Multiple variables in 'for' initialization are not supported in current version
unsupported.expression.list.in.for.update=Multiple expressions in 'for' update are not supported in current version
unsupported.resource.list='try' with resources is not supported in current version
unsupported.array.initializers=Array initializers are not supported in current version
operator.is.not.supported.in=Operator ''{0}'' is not supported in current version
unsupported.negated.in=Negated 'in' is not supported in current version
unsupported.negated.instanceof=Negated 'instanceof' is not supported in current version
unsupported.elvis.assignment=Elvis assignment is not supported in current version
unsupported.safe.index.access=Safe index access is not supported in current version
unsupported.lambda=Lambdas are not supported in current version
unsupported.type.annotations=Type annotations are not supported in current version
illegal.single.argument.lambda=Single argument form of lambda is available only as right part of assignment expression or as argument inside method call

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

fix.package.name=Fix package name

#dynamic properties
add.dynamic.property=Add dynamic property ''{0}''
duplicate.element.in.the.map=Duplicate element ''{0}'' in the map
dynamic.tool.window.id=Dynamic Members

create.field.from.usage.family.name=Create field from usage
create.field.from.usage=Create field ''{0}''
create.method.from.usage.family.name=Create method from usage
create.method.from.usage=Create method ''{0}''
create.variable.from.usage.family.name=Create variable from usage
create.variable.from.usage=Create Variable ''{0}''
create.parameter.from.usage.family.name=Create parameter from usage
create.parameter.from.usage=Create parameter ''{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
tuple.cant.be.placed.in.class=Multiple assignments are not allowed for fields
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
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
compile.groovy.files=&Compile Groovy files
not.allowed.modifier.in.for.in=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.does.not.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
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.cannot.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
operator.call.is.ambiguous=Operator 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
constructor.call.is.ambiguous=Constructor call is ambiguous
cannot.infer.argument.types=Cannot infer argument types
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
add.parentheses=Add parentheses
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
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
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
annotation.field.should.have.type.declaration=Field in annotation should have 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.may.not.have.private.modifier=Top level class may not have 'private' modifier
top.level.class.may.not.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.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
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}''
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
delegate.annotation.is.only.for.methods.without.arguments=Annotation @Delegate couldn't be applied to method with arguments
builder.annotation.not.support.super.for.simple.strategy=Annotation attribute 'includeSuperProperties' not supported by groovy.transform.builder.SimpleStrategy
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
non.static.classes.not.allowed=Non-static inner classes are not allowed in traits
selfType.class.does.not.inherit=@SelfType: Class ''{0}'' does not inherit ''{1}''
illegal.type.void=Illegal type: 'void'
illegal.method.name=Method name contains illegal character(s): {0}

select.module.description=Which module to use classpath of?
select.module.title=Select module...
### Inspection groups ###
inspection.annotations=Annotations verifying
inspection.assignments=Assignment issues
inspection.bugs=Probable bugs
inspection.confusing=Potentially confusing code constructs
inspection.control.flow=Control flow issues
inspection.data.flow=Data flow
inspection.error.handling=Error handling
inspection.gpath=GPath
inspection.naming=Naming conventions
inspection.method.metrics=Method metrics
inspection.redundancy=Declaration redundancy
inspection.threading=Threading issues
inspection.validity=Validity issues
inspection.style=Style
inspection.other=Other
### Intention groups ###
intention.category.groovy=Groovy
intention.category.conversions=Groovy/Expression conversions
intention.category.closures=Groovy/Closures
intention.category.comments=Groovy/Comments
intention.category.groovy.style=Groovy/Groovy-style
intention.category.control.flow=Groovy/Control flow
intention.category.groovy.declaration=Groovy/Declaration
intention.category.groovy.other=Groovy/Other
configurable.GroovyCompilerConfigurable.display.name=Groovy Compiler