Settings

Syside configuration using TOML 1.0. See TOML page for more details.

Example:

std = "path/to/sysml.library"
include = []
exclude = ["lib", "out", "dist"]

[lsp]
completion-limit = 256
edit = "all"

[telemetry]
crash-reports = "ignore"

[format]
line-width = 100
tab-width = 4
tabs = false

[format.keywords.null]
fallback = "null"
preserve = false

Glob Patterns

Some configuration options support the following glob patterns.

* - Matches zero or more characters in a path segment. E.g. *.sysml matches all files that end with .sysml.
? - Matches one character in a path segment. E.g. ?at will match cat and bat, but not chat.
** - Matches any number of path segments, including none. E.g. /x/**/y could match /x/y, /x/a/y, /x/a/b/y.
{...} - Groups conditions. E.g. *.{ker,sys}ml to match both KerML and SysML files (the default behaviour).
[...] - Declares a set or range of characters to match in a path segment. E.g. example[0-9] matches files example0, example1.
[!...] - Declares a negation set or range of characters. E.g. example[!0-9] will not match example1, but will match exampleA.
[^...] - Same as [!...] to match Unix bash behaviour.

Attention

Glob patterns use \ to escape characters thus it cannot be used as a directory separator on Windows. Please use / to separate directories which works on all platforms. Additionally, patterns starting with / are treated as absolute on all platforms.

exclude

Files and/or directories to be omitted from automatic discovery, parsing, and analysis.

This can be used to exclude folders containing automatically generated files, e.g. build folder, from the current workspace. It can also be used in large workspaces to improve startup times by disabling large directories. Note that exclusions are applied before deciding whether a file should be parsed or a directory recursed into but after resolving the root directories from include items, so directory in both include and exclude will be searched non-recursively. This setting supports glob patterns. Relative paths and patterns are resolved relative to the directory that is being searched, matching .gitignore behaviour.

Type: string[] | null

include

Additional files and/or directories to include in the workspace.

This is useful for including external libraries in a project. Note that validation is not performed for files included this way, and that by default Syside ignores hidden files and directories (denoted by the leading . character), and thus this setting would need to be used to include them. This setting supports glob patterns. Relative paths and patterns are resolved relative to the directory where they were declared:

Current working directory when provided as a CLI argument;
Directory of the configuration file if declared in one.

Type: string[] | null

std

Path to the standard SysML library, e.g. sysml.library.

If this is not set, Syside uses a bundled compatible standard library. This setting can be used to experiment with different SysML specification versions or to use a customised SysML library. Keep in mind that using standard libraries other than the bundled one can result in spurious and false-positive diagnostics.

Type: string | null

format

Formatter configuration.

empty-brackets

Choose between {} and ; when formatting empty children blocks:

always: empty blocks are always formatted as {}
never: empty blocks are always formatted as a trailing ;

Type: { fallback: "always" | "never", preserve: boolean }

Default: { fallback = "never", preserve = true }

line-width

Formatter visual line-width limit.

Formatter will attempt to fit formatted lines into this number of visual columns.

Type: integer

Default: 100

markdown

Whether to treat Comment and Documentation bodies as Markdown.

Markdown will preserve whitespace at the end of the lines since it is significant, otherwise it will be trimmed. This does not reformat paragraphs.

Type: boolean

Default: true

strip-unnecessary-quotes

Whether to strip quotes from quoted identifiers where possible.

If true, quotes will be stripped from identifiers that have no restricted characters and do not clash with language keywords.

Type: boolean

Default: true

tab-width

Number of spaces for tabs if using space indentation.

Takes priority over editor settings if set. Defaults to 4 otherwise.

Type: integer | null

tabs

Indent using tabs instead of spaces.

Takes priority over editor settings if set. Defaults to false otherwise.

Type: boolean | null

format.binary

Options for binary ends formatting:

always: binary ends are printed as binary declaration
never: binary ends are printed as nary declaration

allocation

How binary allocation usage ends are formatted.

Type: { fallback: "always" | "never", preserve: boolean }

Default: { fallback = "always", preserve = true }

connection

How binary connection usage ends are formatted.

Type: { fallback: "always" | "never", preserve: boolean }

Default: { fallback = "always", preserve = true }

connector

How binary connector ends are formatted.

Type: { fallback: "always" | "never", preserve: boolean }

Default: { fallback = "always", preserve = true }

interface

How binary interface usage ends are formatted.

Type: { fallback: "always" | "never", preserve: boolean }

Default: { fallback = "always", preserve = true }

succession

How binary succession ends are formatted.

Type: { fallback: "always" | "never", preserve: boolean }

Default: { fallback = "always", preserve = true }

format.breaks

Options for declarations.

about

When to insert line break preceding about in comments:

always: about list is always printed on a new line
as-needed: printer tries to fit about list on the current line

Type: "always" | "as-needed"

Default: "as-needed"

force-bodies

Whether to print all children on a new line, even if they otherwise fit on the same line.

Type: boolean

Default: false

language

When to insert line break preceding language in textual representations:

always: language is always printed on a new line
as-needed: printer tries to fit language on the current line

Type: "always" | "as-needed"

Default: "as-needed"

operator

Wheher to insert line breaks in binary operators:

after: operators are placed on the same line as the LHS expression
before: operators are placed on the same line as the RHS expression

Type: "before" | "after"

Default: "after"

format.decl

Options for declaration formatting.

multiplicity-placement

Where multiplicity is placed in type declarations:

first: multiplicity is printed before any other specializations
first-specialization: multiplicity is printed after the first specialization
last: multiplicity is printed after all specializations

Type: "first" | "first-specialization" | "last"

Default: "first-specialization"

ordered-nonunique

How ordered and nonunique are ordered:

ordered: ordered is printed first
nonunique: nonunique is printed first

Type: { fallback: "ordered" | "nonunique", preserve: boolean }

Default: { fallback = "ordered", preserve = true }

format.decl.merge

Options for merging consecutive declaration relationships.

differencing

Whether to merge consecutive differencings (KerML).

Type: boolean

Default: false

disjoining

Whether to merge consecutive disjoinings (KerML).

Type: boolean

Default: false

feature-chaining

Whether to merge consecutive feature chainings (KerML).

Type: boolean

Default: false

intersecting

Whether to merge consecutive intersectings (KerML).

Type: boolean

Default: false

type-featuring

Whether to merge consecutive type featurings (KerML).

Type: boolean

Default: false

unioning

Whether to merge consecutive unionings (KerML).

Type: boolean

Default: false

format.keywords

Options for keyword formatting, switching between keywords and tokens, or omitting keywords where possible.

allocation

When allocation keyword is printed in allocation usages:

always: allocation is always printed
as-needed: allocation is only printed when required by the grammar

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

assert

When assert keyword is printed in satisfy requirement usages:

always: assert is always printed
never: assert is never printed

Type: { fallback: "always" | "never", preserve: boolean }

Default: { fallback = "always", preserve = true }

binding

When binding keyword is printed in binding connectors as usages:

always: binding is always printed
as-needed: binding is only printed when required by the grammar

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

comment

When comment keyword is printed:

always: comment will always be printed
as-needed: comment will only be printed as needed

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

concern

When concern keyword is printed in framed concern usages:

always: concern is always printed
as-needed: concern is only printed if required by the grammar

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

conjugates

Choose between conjugates and ~ when formatting conjugations (KerML):

keyword: conjugates is printed
token: ~ is printed

Type: { fallback: "token" | "keyword", preserve: boolean }

Default: { fallback = "token", preserve = true }

conjugation

When conjugation keyword is printed in conjugation members (KerML):

always: conjugation will always be printed.
as-needed: conjugation will be printed only if required by the grammar

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

connect

When connect keyword is printed in interface usages:

always: connect is always printed
as-needed: connect is only printed when required by the grammar

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

connection

When connection keyword is printed in connection usages:

always: connection is always printed
as-needed: connection is only printed when required by the grammar

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

constraint

When constraint keyword is printed in assert constraint usages:

always: constraint is always printed
as-needed: constraint is only printed when required by the grammar

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

crosses

Choose between crosses and => when formatting cross subsettings:

keyword: crosses is printed
token: => is printed

Type: { fallback: "token" | "keyword", preserve: boolean }

Default: { fallback = "token", preserve = true }

defined-by

Choose between defined by and : when formatting feature typings (SysML, use typed-by for KerML):

keyword: defined by is printed
token: : is printed

Type: { fallback: "token" | "keyword", preserve: boolean }

Default: { fallback = "token", preserve = true }

disjoining

When disjoining keyword is printed in disjoining members (KerML):

always: disjoining will always be printed.
as-needed: disjoining will be printed only if required by the grammar

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

enum

When enum keyword is printed inside enum definitions:

always: enum is always printed
never: enum is never printed

Type: { fallback: "always" | "never", preserve: boolean }

Default: { fallback = "always", preserve = true }

equals

When to print = in feature values:

as-needed: = will only be printed if it is required by the grammar
always: = will be always printed when it is acceptable by the grammar

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

inverting

When inverting keyword is printed in inverting members (KerML):

always: inverting will always be printed.
as-needed: inverting will be printed only if required by the grammar

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

metadata

Choose between metadata and @ tokens for metadata features and usages:

keyword: metadata is printed
token: @ is printed

Type: { fallback: "token" | "keyword", preserve: boolean }

Default: { fallback = "token", preserve = true }

null

Option for NullExpression formatting:

null: always formatted as null
brackets: always formatted as ()

Type: { fallback: "null" | "brackets", preserve: boolean }

Default: { fallback = "null", preserve = true }

port

When port keyword is printed of default interface ends:

always: port is always printed
never: port is never printed

Type: { fallback: "always" | "never", preserve: boolean }

Default: { fallback = "always", preserve = true }

public

When public keyword is printed:

always: public will always be printed
never: public will never be printed

Type: { fallback: "always" | "never", preserve: boolean }

Default: { fallback = "never", preserve = true }

references

Choose between references and ::> when formatting reference subsettings:

keyword: references is printed
token: ::> is printed

Type: { fallback: "token" | "keyword", preserve: boolean }

Default: { fallback = "token", preserve = true }

rep

When rep keyword is printed:

always: rep will always be printed
as-needed: rep will only be printed as needed

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

requirement

When requirement keyword is printed in satisfy requirement usages:

always: requirement is always printed
as-needed: requirement is only printed when required by the grammar

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

specializes

Choose between specializes and :> when formatting specializations and subclassifications:

keyword: specializes is printed
token: :> is printed

Type: { fallback: "token" | "keyword", preserve: boolean }

Default: { fallback = "token", preserve = true }

state

When state keyword is printed in exhibit state usages:

always: state is always printed
as-needed: state is only printed when required by the grammar

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

subsets

Choose between subsets and :> when formatting subsettings:

keyword: subsets is printed
token: :> is printed

Type: { fallback: "token" | "keyword", preserve: boolean }

Default: { fallback = "token", preserve = true }

succession

When succession keyword formatting in successions as usages:

always: succession is always printed
as-needed: succession is only printed when required by the grammar

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

transition

When transition keyword is printed in transition usages:

always: transition is always printed if permitted by the grammar
as-needed: transition is only printed if required by the grammar

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

true

When true keyword is printed in invariants:

never: true is never printed
always: true is always printed if invariant is not negated

Type: { fallback: "always" | "never", preserve: boolean }

Default: { fallback = "always", preserve = true }

typed-by

Choose between typed by and : when formatting feature typings (KerML):

keyword: typed by is printed
token: : is printed

Type: { fallback: "token" | "keyword", preserve: boolean }

Default: { fallback = "token", preserve = true }

use-case

When use case keyword is printed in include use case usages:

always: use case is always printed
as-needed: use case is only printed when required by the grammar

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

format.keywords.action

When action keyword is printed:

always: action is always printed
as-needed: action is only printed when required by the grammar

action-node

When action keyword is printed in action nodes.

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

perform-action

When action keyword is printed in perform action usages.

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

format.keywords.feature

Options for feature keyword formatting (KerML).

feature

When feature keyword is printed in features:

always: feature is always printed
as-needed: feature is printed only when required by the grammar

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

metadata

When feature keyword is printed in metadata features:

always: feature keyword is always printed
never: feature keyword is never printed

Type: { fallback: "always" | "never", preserve: boolean }

Default: { fallback = "always", preserve = true }

format.keywords.first

When first keyword is printed:

always: first is always printed if permitted by the grammar
as-needed: first is only printed if required by the grammar

succession

When first keyword is printed in binary successions.

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

transition

When first keyword is printed in transition usages.

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

format.keywords.from

When from keyword is printed:

always: from is always printed
as-needed: from is only printed when required by the grammar

connector

When from keyword is printed in binary connectors (KerML).

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

dependency

When from keyword is printed in dependencies.

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "always", preserve = true }

flow

When from keyword is printed in flows (KerML).

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

flow-usage

When from keyword is printed in flow usages.

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

succession-flow

When from keyword is printed in succession flows (KerML).

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

succession-flow-usage

When from keyword is printed in succession flow usages.

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

format.keywords.occurrence

When occurrence keyword is printed:

always: occurrence is always printed
as-needed: occurrence is only printed when required by the grammar

event-occurrence

When occurrence keyword is printed in event occurrence usages.

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

occurrence

When occurrence keyword is printed in occurrence usages and definitions.

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

format.keywords.of

When of keyword is printed:

always: of is always printed
as-needed: of is only printed when required by the grammar

binding-connector

When of keyword is printed in binary binding connectors.

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

type-featuring

When of keyword is printed in type featuring members.

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

format.keywords.redefines

Options for redefines keyword formatting.

feature

Choose between redefines and :>> in feature declarations:

keyword: redefines is printed
token: :>> is printed

Type: { fallback: "token" | "keyword", preserve: boolean }

Default: { fallback = "token", preserve = true }

metadata-body

Choose between redefines, :>>, or no token inside metadata feature bodies:

keyword: redefines is printed
token: :>> is printed
none: nothing is printed

Type: { fallback: "token" | "keyword" | "none", preserve: boolean }

Default: { fallback = "none", preserve = true }

format.keywords.ref

When ref keyword is printed

attribute

When ref keyword is printed in attribute usages.

Type: { fallback: "always" | "never", preserve: boolean }

Default: { fallback = "always", preserve = true }

connection

When ref keyword is printed in connection usages.

Type: { fallback: "always" | "never", preserve: boolean }

Default: { fallback = "always", preserve = true }

connector

When ref keyword is printed in connector as usages.

Type: { fallback: "always" | "never", preserve: boolean }

Default: { fallback = "always", preserve = true }

event-occurrence

When ref keyword is printed in event occurrence usages.

Type: { fallback: "always" | "never", preserve: boolean }

Default: { fallback = "always", preserve = true }

exhibit-state

When ref keyword is printed in exhibit state usages.

Type: { fallback: "always" | "never", preserve: boolean }

Default: { fallback = "always", preserve = true }

include-use-case

When ref keyword is printed in include use case usages.

Type: { fallback: "always" | "never", preserve: boolean }

Default: { fallback = "always", preserve = true }

metadata

When ref keyword is printed in metadata usages.

Type: { fallback: "always" | "never", preserve: boolean }

Default: { fallback = "always", preserve = true }

perform-action

When ref keyword is printed in perform action usages.

Type: { fallback: "always" | "never", preserve: boolean }

Default: { fallback = "always", preserve = true }

port

When ref keyword is printed in port usages.

Type: { fallback: "always" | "never", preserve: boolean }

Default: { fallback = "always", preserve = true }

reference

When ref keyword is printed in reference usages:

always: ref keyword is always printed
as-needed: ref keyword is only printed if required by the grammar

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

format.keywords.specialization

Options for specialization keyword formatting member relationships (KerML).

When specialization keyword is printed:

always: specialization will always be printed.
as-needed: specialization will be printed only if required by the grammar

feature-typing

When specialization keyword is printed in feature typing members.

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

redefinition

When specialization keyword is printed in redefinition members.

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

specialization

When specialization keyword is printed in specialization members.

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

subclassification

When specialization keyword is printed in subclassification members.

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

subsetting

When specialization keyword is printed in subsetting members.

Type: { fallback: "always" | "as-needed", preserve: boolean }

Default: { fallback = "as-needed", preserve = true }

format.parentheses

Options for expression parentheses formatting:

always: expression is printed with parentheses
never: expression is printed without parentheses
on-break: expression is printed with parentheses only if it breaks

filter

When to parenthesize filter expression filter (...):

always: expression is printed with parentheses
never: expression is printed without parentheses
on-break: expression is printed with parentheses only if it breaks

Type: "never" | "always" | "on-break"

Default: "on-break"

if

When to parenthesize condition expression if (...):

always: expression is printed with parentheses
never: expression is printed without parentheses
on-break: expression is printed with parentheses only if it breaks

Type: "never" | "always" | "on-break"

Default: "on-break"

transition-guard

When to parenthesize condition expression if (...) in transition usages:

always: expression is printed with parentheses
never: expression is printed without parentheses
on-break: expression is printed with parentheses only if it breaks

Type: "never" | "always" | "on-break"

Default: "on-break"

format.parentheses.while-loop

Options for parentheses inside while loops.

condition

When to parenthesize condition expression while (...).

Type: "never" | "always" | "on-break"

Default: "on-break"

until

When to parenthesize until expression until (...).

Type: "never" | "always" | "on-break"

Default: "on-break"

format.synth

Options for printing synthetic elements.

literal-real

How to print synthetic LiteralReal values:

none - implementation defined, typically fixed format, e.g. 0.024
exp - printed in exponential notation, e.g. 2.4e-2
prec - general format, switching between fixed and exponential format depending on the magnitude

Type: "none" | "exp" | "prec"

Default: "none"

format.trailing-comma

Options for trailing comma placement.

sequence-expression

When to insert a trailing comma in sequence expressions, e.g. = (a,b,c);:

always: trailing comma is always inserted
never: trailing comma is never inserted
on-break: trailing comma is inserted if the expression breaks

Type: "never" | "always" | "on-break"

Default: "on-break"

lsp

LSP configuration.

completion-limit

The maximum number of completions shown in the autocomplete dropdown.

Setting this to 0 will disable any limits. Lower values reduce completion latency.

Type: integer

Default: 256

edit

Document tiers treated as editable, affecting the renaming feature, and diagnostics:

project - allows editing only project files.
external - allows editing project files and external libraries except the standard library.
all - allows editing all files, including standard library.

Type: "all" | "external" | "project"

Default: "project"

telemetry

Telemetry configuration.

crash-reports

Whether Syside should automatically send crash reports back to Sensmetry or not.

When declared in a configuration file, this only takes effect after the configuration file is parsed. If you want to ensure consistent behaviour, consider passing this through CLI.

Automatic sending can be disabled by setting this to "ignore". For more information refer to Telemetry.

Type: "ignore" | "upload" | null