Odin Code Formatter

[gingerBill]

Automatic code formatter for the Odin programming language.

Requirements:

• Written in Odin
• Using package core:odin/parser
• Purely syntactic (no semantic checking required)

Default style overview:

• tabs for indentation, spaces for alignment
• 1tbs for brace indentation style

Usage:

• odinfmt [path ...] [flags]
• flags

  -errors
      Print all errors, including all spurious errors.
  -rule
      Apply the rewrite rule given to the source before formatting
  -simplify
      Try to simplify code (after apply the rewrite rule(s), if any)
  -overwrite
      Instead of printing to stdout, the formatter changes the original file itself.
      If any error occurs during overwriting, the original file is to be restored from an automatic backup.
  -destination:<path>
     Instead of printing to stdout, the formatter prints to the specified path
  -space-indentation:<parameter>
      By default, the formatter will use tabs for indentation and spaces for alignment. Alignment assumes that an editor uses a monospaced font.
      This behaviour can be overridden by specifying either a number to use spaces for indentation instead.
  -brace-style:<style>
      By default, the formatter will use the attached (1TBS) brace indentation style. 
      Available formats: default, 1tbs, allman, k&r, stroustrup
  -mandatory-braces
      By default, `do` based control flow bodies are allowed. This flag will convert all uses of `do` to use braces instead

[gingerBill]

Ideas for the -simplify flag:

Compound literals of the form:
        []T{T{}, T{}}
can be simplified to:
        []T{{}, {}}

Ranged for loops for the form:
        for x, _ in v {...}
can be simplified to:
        for x in v {...}

Ranged for loops for the form:
        for _ in v {...}
can be simplified to:
        for in v {...}

Slice expressions of the form:
        s[a:len(s)]
can be simplified to:
        s[a:]

Slice expressions of the form:
        s[0:n]
can be simplified to:
        s[:n]

Slice expressions of the form:
        s[:][:]
can be simplified to:
        s[:]

[gingerBill]

Brace styles:

default and 1tbs
    foo :: proc(x: int) -> int {
        if x > 0 {
            return x * 123;
        } else {
            return -x * 345;
        }
    }

allman
    foo :: proc(x: int) -> int 
    {
        if x > 0 
        {
            return x * 123;
        } 
        else 
        {
            return -x * 345;
        }
    }

k&r
    foo :: proc(x: int) -> int 
    {
        if x > 0 {
            return x * 123;
        } else {
            return -x * 345;
        }
    }

stroustrup
    foo :: proc(x: int) -> int {
        if x > 0 {
            return x * 123;
        } 
        else {
            return -x * 345;
        }
    }

[ThisDevDane]

Not sure what discussion category this should be converted to @gingerBill

[jasonKercher]

I'll take this on as long as you are okay with an Odin rookie doing it.

[ThisDevDane]

Odinfmt is already being worked on but you’re welcome to try anyway :)

[github-actions[bot]]

Hello!

I am marking this issue as stale as it has not received any engagement from the community or maintainers 120 days. That does not imply that the issue has no merit! If you feel strongly about this issue

• open a PR referencing and resolving the issue;
• leave a comment on it and discuss ideas how you could contribute towards resolving it;
• leave a comment and describe in detail why this issue is critical for your use case;
• open a new issue with updated details and a plan on resolving the issue.

The motivation for this automation is to help prioritize issues in the backlog and not ignore, reject, or belittle anyone..