Tal Man
405 lines
23 KiB
Properties
405 lines
23 KiB
Properties
#quick fix messages
|
|
add.function.body=Add function body
|
|
change.to.constructor.invocation=Change to constructor invocation
|
|
add.return.type=Add return type declaration
|
|
change.accessor.type=Change accessor type
|
|
change.getter.type=Change getter type to {0}
|
|
change.setter.type=Change setter parameter type to {0}
|
|
make.variable.immutable=Make variable immutable
|
|
make.variable.mutable=Make variable mutable
|
|
change.variable.mutability.family=Change Variable Mutability
|
|
remove.function.body=Remove function body
|
|
make.element.modifier=Make {0} {1}
|
|
add.modifier=Add ''{0}'' modifier
|
|
add.modifier.family=Add Modifier
|
|
make.element.in.classifiers.open=Make ''{0}'' in {1} open
|
|
make.class.annotation.class=Make ''{0}'' an annotation class
|
|
make.class.annotation.class.family=Make Class an Annotation Class
|
|
add.star.projections=Add ''{0}''
|
|
change.to.star.projection=Change type arguments to {0}
|
|
change.to.star.projection.family=Change to Star Projection
|
|
make.element.not.modifier=Make {0} not {1}
|
|
remove.modifier=Remove ''{0}'' modifier
|
|
remove.modifier.family=Remove Modifier
|
|
remove.redundant.modifier=Remove redundant ''{0}'' modifier
|
|
remove.parts.from.property=Remove {0} from property
|
|
remove.parts.from.property.family=Remove Parts from Property
|
|
remove.psi.element.family=Remove Element
|
|
remove.right.part.of.binary.expression=Remove right part of a binary expression
|
|
remove.cast=Remove cast
|
|
remove.elvis.operator=Remove elvis operator
|
|
remove.redundant.nullable=Remove redundant '?'
|
|
remove.supertype=Remove supertype ''{0}''
|
|
remove.supertype.family=Remove supertype
|
|
remove.supertype.nullable=Remove '?'
|
|
remove.type.arguments=Remove type arguments
|
|
remove.useless.nullable=Remove useless '?'
|
|
remove.nullable.family=Remove '?'
|
|
remove.spread.sign=Remove '*'
|
|
remove.useless.import=Remove useless import for ''{0}''
|
|
remove.useless.import.family=Remove Useless Import
|
|
replace.operation.in.binary.expression=Replace operation in a binary expression
|
|
replace.cast.with.static.assert=Replace a cast with a static assert
|
|
replace.with.dot.call=Replace with dot call
|
|
replace.with.safe.call=Replace with safe (?.) call
|
|
introduce.non.null.assertion=Add non-null asserted (!!) call
|
|
remove.unnecessary.non.null.assertion=Remove unnecessary non-null assertion (!!)
|
|
change.to.backing.field=Change reference to backing field
|
|
implement.members=Implement members
|
|
new.kotlin.file.action=Kotlin File
|
|
import.fix=Import
|
|
imports.chooser.title=Imports
|
|
specify.type.explicitly.action.family.name=Specify Type Explicitly
|
|
specify.type.explicitly.add.return.type.action.name=Specify return type explicitly
|
|
specify.type.explicitly.add.action.name=Specify type explicitly
|
|
specify.type.explicitly.remove.action.name=Remove explicitly specified type
|
|
convert.to.expression.body.action.family.name=Convert to Expression Body
|
|
convert.to.expression.body.action.name=Convert to expression body
|
|
convert.to.block.body.action.family.name=Convert to Block Body
|
|
convert.to.block.body.action.name=Convert to block body
|
|
rename.parameter.to.match.overridden.method=Rename parameter to match overridden method
|
|
rename.family=Rename
|
|
rename.kotlin.package.class.error="Can't rename kotlin package class"
|
|
add.semicolon.after.invocation=Add semicolon after invocation of ''{0}''
|
|
add.semicolon.family=Add Semicolon
|
|
change.function.return.type=Change ''{0}'' function return type to ''{1}''
|
|
change.no.name.function.return.type=Change function return type to ''{0}''
|
|
change.function.literal.return.type=Change function literal return type to ''{0}''
|
|
remove.function.return.type=Remove explicitly specified return type in ''{0}'' function
|
|
remove.no.name.function.return.type=Remove explicitly specified function return type
|
|
change.element.type=Change ''{0}'' type to ''{1}''
|
|
change.function.parameter.type=Change parameter ''{0}'' type of function ''{1}'' to ''{2}''
|
|
change.primary.constructor.parameter.type=Change parameter ''{0}'' type of primary constructor of class ''{1}'' to ''{2}''
|
|
change.type=Change type from ''{0}'' to ''{1}''
|
|
change.type.family=Change Type
|
|
add.parameters.to.function=Add parameter{0} to function ''{1}''
|
|
add.parameters.to.constructor=Add parameter{0} to constructor ''{1}''
|
|
change.function.signature=Change the signature of function ''{0}''
|
|
change.constructor.signature=Change the signature of constructor ''{0}''
|
|
change.function.literal.signature=Change the signature of function literal
|
|
remove.parameter=Remove parameter ''{0}''
|
|
change.signature.family=Change signature of function/constructor
|
|
cast.expression.to.type=Cast expression ''{0}'' to ''{1}''
|
|
cast.expression.family=Cast Expression
|
|
simplify.negated.binary.expression=Simplify negated ''{0}'' expression to ''{1}''
|
|
simplify.negated.binary.expression.family=Simplify Negated Binary Expression
|
|
|
|
replace.call.error.skipped.defaults=Cannot skip default arguments.
|
|
replace.call.error.undefined.returntype=Unable to determine the return type.
|
|
replace.call.error.duplicate.or.missing.arguments=Duplicate or missing arguments.
|
|
replace.call.error.invalid.arguments=Invalid arguments included.
|
|
|
|
replace.call.error.vararg.not.last=Cannot handle named arguments after a vararg.
|
|
replace.call.error.contains.returns_boolean=Contains must return a Boolean.
|
|
|
|
replace.get.with.index=Replace 'get' call with index operator
|
|
replace.get.with.index.family=Replace Get
|
|
|
|
replace.contains.with.in=Replace 'contains' call with in operator
|
|
replace.contains.with.in.family=Replace Contains
|
|
|
|
replace.invoke.with.call=Replace 'invoke' with direct call
|
|
replace.invoke.with.call.family=Replace Invoke
|
|
|
|
replace.unary.operator.with.prefix=Replace with ''{0}'' prefix
|
|
replace.unary.operator.with.prefix.family=Replace Unary Operator
|
|
|
|
replace.binary.operator.with.infix=Replace with ''{0}'' operator
|
|
replace.binary.operator.with.infix.family=Replace Binary Operator
|
|
|
|
|
|
add.kotlin.signature.action.family.name=Specify Custom Kotlin Signature
|
|
add.kotlin.signature.action.text=Specify custom Kotlin signature
|
|
edit.kotlin.signature.action.text=Edit custom Kotlin signature
|
|
view.kotlin.signature.action.text=View custom Kotlin signature
|
|
|
|
goto.super.function.chooser.title=Choose super function
|
|
goto.super.property.chooser.title=Choose super property
|
|
goto.super.class.chooser.title=Choose super class or interface
|
|
|
|
livetemplate.description.main=main() function
|
|
livetemplate.description.soutp=Prints function parameter names and values to System.out
|
|
livetemplate.description.iter=Iterate over elements of iterable
|
|
livetemplate.description.ifn=Inserts ''if null'' expression
|
|
livetemplate.description.inn=Inserts ''if not null'' expression
|
|
livetemplate.description.void=Function returning nothing
|
|
livetemplate.description.fun0=Function with no parameters
|
|
livetemplate.description.fun1=Function with one parameter
|
|
livetemplate.description.fun2=Function with two parameters
|
|
livetemplate.description.interface=Trait
|
|
livetemplate.description.singleton=Singleton
|
|
livetemplate.description.closure=Closure (function without name)
|
|
livetemplate.description.anonymous=Anonymous class
|
|
livetemplate.description.exfun=Extension function
|
|
livetemplate.description.exval=Extension read-only property
|
|
livetemplate.description.exvar=Extension read-write property
|
|
macro.variable.of.type=kotlinVariable()
|
|
macro.iterable.variable=kotlinIterableVariable()
|
|
macro.suggest.variable.name=kotlinSuggestVariableName()
|
|
macro.fun.parameters=functionParameters()
|
|
macro.fun.anonymousSuper=anonymousSuper()
|
|
change.visibility.modifier=Change visibility modifier
|
|
|
|
options.jet.attribute.descriptor.builtin.annotation=Built-in annotation
|
|
options.jet.attribute.descriptor.string.escape=Escape in string and template braces
|
|
options.jet.attribute.descriptor.closure.braces=Function literal braces and arrow
|
|
options.jet.attribute.descriptor.safe.access=Safe access dot
|
|
options.jet.attribute.descriptor.arrow=Arrow
|
|
options.jet.attribute.descriptor.kdoc.comment=KDoc comment
|
|
options.jet.attribute.descriptor.kdoc.tag=KDoc tag
|
|
options.jet.attribute.descriptor.kdoc.value=KDoc tag value
|
|
options.jet.attribute.descriptor.trait=Trait
|
|
options.jet.attribute.descriptor.annotation=Annotation
|
|
options.jet.attribute.descriptor.var=Var (mutable variable, parameter or property)
|
|
options.jet.attribute.descriptor.local.variable=Local variable or value
|
|
options.jet.attribute.descriptor.captured.variable=Variables and values captured in a closure
|
|
options.jet.attribute.descriptor.instance.property=Instance property
|
|
options.jet.attribute.descriptor.package.property=Package-level property
|
|
options.jet.attribute.descriptor.property.with.backing=Property with backing field
|
|
options.jet.attribute.descriptor.backing.field.access=Backing field access
|
|
options.jet.attribute.descriptor.extension.property=Extension property
|
|
options.jet.attribute.descriptor.it=Function literal default parameter
|
|
options.jet.attribute.descriptor.fun=Function declaration
|
|
options.jet.attribute.descriptor.fun.call=Function call
|
|
options.jet.attribute.descriptor.package.fun.call=Package-level function call
|
|
options.jet.attribute.descriptor.extension.fun.call=Extension function call
|
|
options.jet.attribute.descriptor.constructor.call=Constructor call
|
|
options.jet.attribute.descriptor.variable.as.function.call=Variable as function call
|
|
options.jet.attribute.descriptor.variable.as.function.like.call=Variable as function-like call
|
|
options.jet.attribute.descriptor.auto.casted=Smart-cast value
|
|
options.jet.attribute.descriptor.label=Label
|
|
change.to.function.invocation=Change to function invocation
|
|
migrate.sure=Replace sure() calls by !! in project
|
|
remove.val.var.from.parameter=Remove val/var from function, loop and catch parameters in project
|
|
add.override.to.equals.hashCode.toString=Add 'override' to equals, hashCode, toString in project
|
|
add.when.else.branch.action.family.name=Add Else Branch
|
|
add.when.else.branch.action=Add else branch
|
|
move.when.else.branch.to.the.end.action=Move else branch to the end
|
|
move.when.else.branch.to.the.end.family.name=Move Else Branch to the End
|
|
change.to.property.name.family.name=Change to property name
|
|
change.to.property.name.action=Change ''{0}'' to ''{1}''
|
|
map.platform.class.to.kotlin=Change all usages of ''{0}'' in this file to ''{1}''
|
|
map.platform.class.to.kotlin.multiple=Change all usages of ''{0}'' in this file to a Kotlin class
|
|
map.platform.class.to.kotlin.advertisement=Choose an appropriate Kotlin class
|
|
map.platform.class.to.kotlin.family=Change to Kotlin class
|
|
create.from.usage.family=Create from usage
|
|
create.function.from.usage=Create function ''{0}'' from usage
|
|
choose.target.class.or.trait.title=Choose target class or trait
|
|
surround.with=Surround with
|
|
surround.with.string.template="${expr}"
|
|
surround.with.when.template=when (expr) {}
|
|
surround.with.function.template={ }
|
|
surround.with.cannot.perform.action=Cannot perform Surround With action to the current contextsurround.with.function.template={ }
|
|
remove.variable.family.name=Remove variable
|
|
remove.variable.action=Remove variable ''{0}''
|
|
kotlin.code.transformations=Kotlin Code Transformations
|
|
fold.if.to.assignment=Replace 'if' expression with assignment
|
|
fold.if.to.assignment.family=Replace 'if' Expression with Assignment
|
|
fold.if.to.return=Replace 'if' expression with return
|
|
fold.if.to.return.family=Replace 'if' Expression with Return
|
|
fold.if.to.call=Replace 'if' expression with method call
|
|
fold.if.to.call.family=Replace 'if' Expression with Method Call
|
|
fold.when.to.assignment=Replace 'when' expression with assignment
|
|
fold.when.to.assignment.family=Replace 'when' Expression with Assignment
|
|
fold.when.to.return=Replace 'when' expression with return
|
|
fold.when.to.return.family=Replace 'when' Expression with Return
|
|
fold.when.to.call=Replace 'when' expression with method call
|
|
fold.when.to.call.family=Replace 'when' Expression with Method Call
|
|
unfold.assignment.to.if=Replace assignment with 'if' expression
|
|
unfold.assignment.to.if.family=Replace Assignment with 'if' Expression
|
|
unfold.property.to.if=Replace property initializer with 'if' expression
|
|
unfold.property.to.if.family=Replace Property Initializer with 'if' Expression
|
|
unfold.return.to.if=Replace return with 'if' expression
|
|
unfold.return.to.if.family=Replace Return with 'if' Expression
|
|
unfold.call.to.if=Replace method call with 'if' expression
|
|
unfold.call.to.if.family=Replace Method Call with 'if' Expression
|
|
unfold.assignment.to.when=Replace assignment with 'when' expression
|
|
unfold.assignment.to.when.family=Replace Assignment with 'when' Expression
|
|
unfold.property.to.when=Replace property initializer with 'when' expression
|
|
unfold.property.to.when.family=Replace Property Initializer with 'when' Expression
|
|
unfold.return.to.when=Replace return with 'when' expression
|
|
unfold.return.to.when.family=Replace Return with 'when' Expression
|
|
unfold.call.to.when=Replace method call with 'when' expression
|
|
unfold.call.to.when.family=Replace Method Call with 'when' Expression
|
|
double.bang.to.if.then.exception.text=Expression ''{0}'' must not be null
|
|
double.bang.to.if.then.choose.exception=Choose Exception Class
|
|
double.bang.to.if.then=Replace '!!' expression with 'if' expression
|
|
double.bang.to.if.then.family=Replace '!!' Expression With 'if' Expression
|
|
if.then.to.double.bang=Replace 'if' expression with '!!' expression
|
|
if.then.to.double.bang.replace.exception=Replace 'if' expression with '!!' expression (will remove Exception)
|
|
if.then.to.double.bang.family=Replace 'if' expression With '!!' Expression
|
|
elvis.to.if.then=Replace elvis expression with 'if' expression
|
|
elvis.to.if.then.family=Replace Elvis Expression With 'if' Expression
|
|
if.then.to.elvis=Replace 'if' expression with elvis expression
|
|
if.then.to.elvis.family=Replace 'if' expression With Elvis Expression
|
|
safe.access.to.if.then=Replace safe access expression with 'if' expression
|
|
safe.access.to.if.then.family=Replace Safe Access Expression With 'if' Expression
|
|
if.then.to.safe.access=Replace 'if' expression with safe access expression
|
|
if.then.to.safe.access.family=Replace 'if' Expression with Safe Access Expression
|
|
if.to.when=Replace 'if' with 'when'
|
|
if.to.when.family=Replace 'if' with 'when'
|
|
when.to.if=Replace 'when' with 'if'
|
|
when.to.if.family=Replace 'when' with 'if'
|
|
flatten.when=Flatten 'when' expression
|
|
flatten.when.family=Flatten 'when' Expression
|
|
merge.when=Merge 'when' expressions
|
|
merge.when.family=Merge 'when' Expression
|
|
introduce.when.subject=Introduce argument to 'when'
|
|
introduce.when.subject.family=Introduce Argument to 'when'
|
|
eliminate.when.subject=Eliminate argument of 'when'
|
|
eliminate.when.subject.family=Eliminate Argument of 'when'
|
|
transform.if.statement.with.assignments.to.expression=Transform 'if' statement with assignments to expression
|
|
transform.assignment.with.if.expression.to.statement=Transform assignment with 'if' expression to statement
|
|
transform.if.statement.with.assignments.to.expression.family=Transform 'if' Statement with Assignments to Expression
|
|
transform.assignment.with.if.expression.to.statement.family=Transform Assignment with 'if' Expression to Statement
|
|
split.property.declaration=Split property declaration
|
|
split.property.declaration.family=Split Property Declaration
|
|
change.function.signature.action.single=Change function signature to ''{0}''
|
|
change.function.signature.action.multiple=Change function signature...
|
|
change.function.signature.family=Change function signature
|
|
change.function.signature.chooser.title=Choose signature
|
|
change.function.signature.action=Change function signature
|
|
remove.unnecessary.parentheses=Remove unnecessary parentheses
|
|
remove.unnecessary.parentheses.family=Remove Unnecessary Parentheses
|
|
remove.unnecessary.curly.brackets.from.string.template=Remove curly braces from variable
|
|
remove.unnecessary.curly.brackets.from.string.template.family=Remove curly braces from variable
|
|
insert.curly.brackets.to.string.template=Insert curly braces around variable
|
|
insert.curly.brackets.to.string.template.family=Insert curly braces around variable
|
|
swap.binary.expression=Flip Binary Expression
|
|
swap.binary.expression.family=Flip Binary Expression
|
|
add.name.to.argument.family=Add Name to Argument
|
|
add.name.to.argument.single=Add name to argument\: ''{0}''
|
|
add.name.to.argument.multiple=Add name to argument...
|
|
add.name.to.argument.action=Add name to argument...
|
|
add.name.to.parameter.name.chooser.title=Choose parameter name
|
|
replace.with.dot.qualified.method.call.intention=Replace with simple method call
|
|
replace.with.dot.qualified.method.call.intention.family=Replace with simple method call
|
|
replace.with.infix.function.call.intention=Replace with infix function call
|
|
replace.with.infix.function.call.intention.family=Replace with infix function call
|
|
replace.explicit.function.literal.param.with.it=Replace explicit parameter ''{0}'' with ''it''
|
|
replace.explicit.function.literal.param.with.it.family=Replace Explicit Parameter With 'it'
|
|
move.lambda.inside.parentheses=Move lambda function into parentheses
|
|
move.lambda.inside.parentheses.family=Move lambda function into parentheses
|
|
move.lambda.outside.parentheses=Move lambda expression out of parentheses
|
|
move.lambda.outside.parentheses.family=Move lambda expression out of parentheses
|
|
replace.it.with.explicit.function.literal.param=Replace 'it' with explicit parameter
|
|
replace.it.with.explicit.function.literal.param.family=Replace 'it' With Explicit Parameter
|
|
remove.braces=Remove braces
|
|
remove.braces.family=Remove Braces
|
|
add.braces=Add braces
|
|
add.braces.family=Add Braces
|
|
convert.negated.boolean.sequence=Replace negated sequence with DeMorgan equivalent
|
|
convert.negated.boolean.sequence.family=Replace negated sequence with DeMorgan equivalent
|
|
convert.negated.expression.with.demorgans.law=Convert negated expression to DeMorgan's equivalent
|
|
convert.negated.expression.with.demorgans.law.family=Convert negated expression to DeMorgan's equivalent
|
|
split.if=Split into 2 if's
|
|
split.if.family=Split If
|
|
replace.with.operator.assign.intention=Replace with an Operator-Assign Expression
|
|
replace.with.operator.assign.intention.family=Replace with an Operator-Assign Expression
|
|
replace.with.traditional.assignment.intention=Replace with Traditional Assignment
|
|
replace.with.traditional.assignment.intention.family=Replace with Traditional Assignment
|
|
simplify.boolean.with.constants=Simplify boolean expression
|
|
simplify.boolean.with.constants.family=Simplify boolean expression
|
|
insert.explicit.type.arguments=Add explicit type arguments
|
|
insert.explicit.type.arguments.family=Add explicit type arguments
|
|
remove.explicit.type.arguments=Remove explicit type arguments
|
|
remove.explicit.type.arguments.family=Remove explicit type arguments
|
|
convert.assert.to.if.with.throw=Replace 'assert' with 'if' statement
|
|
convert.assert.to.if.with.throw.family=Replace 'assert' with 'if' statement
|
|
convert.if.with.throw.to.assert=Replace 'if' with 'assert' statement
|
|
convert.if.with.throw.to.assert.family=Replace 'if' with 'assert' statement
|
|
|
|
property.is.implemented.too.many=Has implementations
|
|
property.is.overridden.too.many=Is overridden in subclasses
|
|
property.is.implemented.header=Is implemented in <br/>
|
|
property.is.overridden.header=Is overridden in <br/>
|
|
|
|
navigation.title.overriding.property=Choose Implementation of {0}
|
|
navigation.findUsages.title.overriding.property=Overriding properties of {0}
|
|
add.function.to.supertype.family=Add Function to Supertype
|
|
add.function.to.supertype.action.multiple=Add function to supertype...
|
|
add.function.to.type.action.single=Add ''{0}'' to ''{1}''
|
|
add.function.to.type.action=Add function to type
|
|
add.function.to.type.action.type.chooser=Choose type...
|
|
|
|
remove.expression = Remove ''{0}''
|
|
unwrap.expression = Unwrap ''{0}''
|
|
remove.else = Remove else in ''{0}''
|
|
unwrap.else = Unwrap else in ''{0}''
|
|
|
|
usageType.annotation.type = Annotation
|
|
usageType.import = Import directive
|
|
usageType.callable.reference = Callable reference
|
|
usageType.type.constraint = Type constraint
|
|
usageType.type.argument = Type argument
|
|
usageType.value.parameter.type = Parameter type
|
|
usageType.nonLocal.property.type = Class/object property type
|
|
usageType.local.variable.type = Local variable type
|
|
usageType.function.return.type = Function return types
|
|
usageType.superType = Supertype
|
|
usageType.type.definition = Type definition
|
|
usageType.is = Target type of 'is' operation
|
|
usageType.as = Target type of 'as' operation
|
|
usageType.class.object = Nested class/object
|
|
usageType.instantiation = Instantiation
|
|
usageType.function.call = Function call
|
|
usageType.extension.receiver.type = Extension receiver type
|
|
usageType.super.type.qualifier = Super type qualifier
|
|
usageType.receiver = Receiver
|
|
usageType.selector = Selector
|
|
usageType.delegate = Delegate
|
|
|
|
x.in.y={0} in {1}
|
|
x.implements.y={0} in {1} implements {2} in {3}.
|
|
x.overrides.y.in.class.list={0} in {1} overrides functions in the following classes/traits: {2} Do you want to {3} the base functions?
|
|
|
|
unused.overriding.methods.title=Unused Overriding Members
|
|
there.are.unused.methods.that.override.methods.you.delete=There are unused members that override methods you delete.
|
|
choose.the.ones.you.want.to.be.deleted=Choose the ones you want to be deleted.
|
|
method.column=Member
|
|
delete.param.in.method.hierarchy={0} is a part of method hierarchy. Do you want to delete multiple parameters?
|
|
super.methods.delete.with.usage.search=delete (with usage search)
|
|
super.methods.action.key.find.usages=find usages of
|
|
|
|
find.what.implementing.methods.checkbox=&Implementing functions
|
|
find.what.overriding.methods.checkbox=Over&riding functions
|
|
find.what.implementing.properties.checkbox=&Implementing properties
|
|
find.what.overriding.properties.checkbox=Over&riding properties
|
|
find.what.property.readers.checkbox=Readers
|
|
find.what.property.writers.checkbox=Writers
|
|
find.options.include.overloaded.methods.checkbox=Include o&verloaded functions and extensions
|
|
find.what.functions.usages.checkbox=Usages of &functions
|
|
find.what.properties.usages.checkbox=Usages of &properties
|
|
find.what.constructor.usages.checkbox=Usages of &constructor
|
|
find.what.derived.traits.checkbox=&Derived traits
|
|
find.what.derived.classes.checkbox=&Derived classes
|
|
|
|
hierarchy.legend.member.is.defined.in.class=Member is defined in the class
|
|
hierarchy.legend.member.defined.in.superclass=Member is not defined in the class but defined in superclass
|
|
hierarchy.legend.member.should.be.defined=Member should be defined since the class is not abstract
|
|
|
|
convert.to.extension=Convert to extension
|
|
replace.by.reconstructed.type.family.name=Replace by Reconstructed Type
|
|
replace.by.reconstructed.type=Replace by ''{0}''
|
|
|
|
suppress.warnings.family=Suppress Warnings
|
|
suppress.warning.for=Suppress ''{0}'' for {1} {2}
|
|
|
|
# Kotlin Compiler Settings Tab
|
|
|
|
#Common
|
|
kotlin.compiler.option.generate.no.warnings=Generate no &warnings
|
|
kotlin.compiler.option.additional.command.line.parameters=&Additional command line parameters:
|
|
kotlin.compiler.option.additional.command.line.parameters.dialog.title=Additional command line parameters
|
|
|
|
# Kotlin to JVM
|
|
kotlin.compiler.jvm.option.panel.title=Kotlin to JVM
|
|
|
|
# Kotlin to JavaScript
|
|
kotlin.compiler.js.option.panel.title=Kotlin to JavaScript
|
|
kotlin.compiler.js.option.generate.sourcemaps=Generate &source maps
|
|
kotlin.compiler.js.option.output.prefix=Output file &prefix:
|
|
kotlin.compiler.js.option.output.postfix=Output file p&ostfix:
|
|
kotlin.compiler.js.option.output.prefix.browse.title=Choose output file prefix
|
|
kotlin.compiler.js.option.output.postfix.browse.title=Choose output file postfix
|