Syntax and types introduction

This topic provides an overview of the basic elements of the Simple Issue Language (SIL) scripting syntax.

Simple Issue Language (SIL) is a scripting language specifically designed for Jira. It follows common programming language conventions but is tailored to work with Jira issues and workflows. SIL is the underlying scripting language of Power Scripts, Power Actions, and other apps. It is easy to learn and work with.

Basic syntax rules

Every instruction must end with a semicolon ;
Comments can be written in two ways:
// For single line comments /* For multi-line comments */

Data types

Data types are templates or definitions that tell the system what kind of data can be stored. SIL uses several categories of data types.

Basic data types

Type	Use for

Type	Use for
`string`	text values like `hello`
`boolean`	true/false values
`number`	any numeric value
`integer`	whole numbers without decimals
`byte`	for byte values
`date`	for dates like `2024-10-24`
`interval`	for time periods like `2d 3h` (two days and three hours)

Complex data types

Arrays

Arrays are created by adding [] after any basic type. The following list represents valid arrays:

string[]
boolean[]
number[][]
integer[]
date[][][]
interval[]

You can also create arrays for a user-defined structure:

Person[][]

Key-value arrays

Arrays in SIL where positions in the list act as keys. Key-value arrays (or maps) are declared like regular arrays.

Learn more about using the indexing operator to create key-value maps and retrieve values from them.

Structures

Structures are user-defined data types. A structure in SIL is like a container that can hold different types of data together. The syntax for defining a structure is:

struct StructureName {
    type1 field1;
    type2 field2;
    // ... more fields
}

The type of each field can be a basic data type, a user-defined structure, a self-referential structure, or arrays of these types. The following examples show how to define a structure with each type:

struct Address {
    string street;
    string city;
    string zipCode;         //Basic data types in structure
}

struct Employee {
    string id;
    string name;
    Address workAddress;    // Structure inside structure
    Address homeAddress;    // Can use same type multiple times
}
struct Department {
    string name;
    Department parent;            // A Department can reference itself
    Department[] subDepartments;  // Can have array of same type
}

Best practices when creating structures:

Use meaningful field names.
Group related fields together.
Consider the logical hierarchy of your data.

To access the value of a field from a variable in a structure, use the syntax:

You can initialize structures field-by-field:

Alternatively, you can do a one-line initialization, including nested initialization:

Literals

Literals are fixed values that appear directly in the code. In SIL, literals are used to represent constant values of different data types.

Literals refer to the constant values used in scripts, NOT the use of a constant which is the readonly attribute of variables.

Type

Type
Basic type literals
String, Date, and Interval literals	These types require double quotes (" ").
Array literals	Arrays use curly braces and commas:
Special literals	You can use `null` or `nil` to unset variables.

Variables

Variables are named containers that use the data types. They are like labeled boxes that can hold specific values.

You can create an array from variables as illustrated in the following example:

You can also create array variables:

Variable declaration and initialization

To give value to your variables, you initialize them either when you declare them or later.

Constants

Variables can be made readonly by adding the keyword const before the data type when the variable is first defined.

Explicit type casting

When types are compatible, SIL automatically converts one type to another. Automatic conversion can lead to ambiguous results. If you want to tell SIL how to convert a type, use explicit type casting with the following syntax:

The following example illustrates how explicit type casting returns accurate results:

User-defined functions

SIL comes with many out-of-the-box functions by SIL, but allows you to define local functions, referred to as user-defined routines (UDRs). To define and declare a function, use this general syntax:

For additional details, check the User-defined routines (UDRs) topic.