flinter_rc.yml

# Flinter configuration file.

extension: f\d*

# These are all the regexp rules

# Set active to false is you want to skip  rule
# All are regexp rules, meaning you can add new rules simply by editing this file
# test your rule on https://regex101.com/ if needed
regexp-rules:
  # -------------------------------------------------------------------------- #
  # Meta rules

  line-too-long:
    message: Line too long
    regexp: .{{81,}}
    replacement: null
    active: true

  prepend-openmp-with-!$:
    message: Should prepend with "!$"
    regexp: ^\s*use omp_lib
    replacement: '\1!$ use omp_lib'
    active: true

  useless-eol-semicolon:
    message: Useless ";" at end of line
    regexp: ;\s*$
    replacement: \n
    active: true

  recommended-use-mpi_f08:
    message: Should use `use mpi_f08` instead (or `use mpi` if not available)
    regexp: include ["\']mpif.h[\'"]
    replacement: null
    active: true

  not-recommended-use-include:
    message: include is discouraged, prefer use.
    regexp: ^include.*$
    replacement: null
    active: true

  # -------------------------------------------------------------------------- #
  # White space rules

  trailing-white-spaces:
    message: Trailing white-spaces
    regexp: ([ ]+|\t+)\n
    replacement: ""
    active: true
    include-comments: true

  tabulation-instead-of-two-spaces:
    message: Should use 2 spaces instead of tabulation
    regexp: \t
    replacement: "  "
    active: true

  # -------------------------------------------------------------------------- #
  # Types and intrinsic rules

  # Case sensitive rules do not work
  intrinsics-should-be-lowercased:
    message: Intrinsics keywords should be lowercased
    regexp: \b({intrinsics_upper}|end({blocks_upper}|{structs_upper}))\b
    case-sensitive: true
    active: false

  intrinsics-args-should-be-lowercased:
    message: Intrinsics named argument should be lowercased
    regexp: \b({named-args_upper})(?=\s*=)
    case-sensitive: true
    active: false

  types-should-be-lowercased:
    message: Types should be lowercased
    regexp: \b({types_upper})\b
    case-sensitive: true
    active: false

  use-new-syntax-type:
    message: Use new syntax TYPE(kind)
    regexp: ({types})\*(\w+)
    replacement: \1(\2)
    active: true

  recommended-use-of-sp-dp:
    message: You should use "sp" or "dp" instead
    regexp: \(kind\s*=\s*\d\s*\)
    replacement: null
    active: true

  not-recommended-use-double-precision:
    message: double precision is discouraged; use real instead.
    regexp: ^double precision.*$
    replacement: null
    active: true

  # -------------------------------------------------------------------------- #
  # Syntax rules

  recommended-use-of-brackets:
    message: You should use "[]" instead
    regexp: (\(\/)|(\/\))
    replacement: '[\1]'
    active: true

  not-recommended-bare-end:
    message: Bare end statement not recommended
    regexp: \s^end$
    replacement: null
    active: true

  not-recommended-bare-stop:
    message: Bare stop statement not recommended
    regexp: \s^stop$
    replacement: null
    active: true

  not-recommended-use-exit:
    message: exit is an extension and should be avoided
    regexp: ^exit$
    replacement: null
    active: true

  not-recommended-use-goto:
    message: goto is hard to maintain, prone to spaghetti code.
    regexp: ^goto.*$
    replacement: null
    active: true

  not-recommended-use-pause:
    message: pause is discouraged.
    regexp: ^pause.*$
    replacement: null
    active: true

  scope-not-specified:
    message: Module usage should be explicit
    regexp: ((^\s+use +)(?!(\bneko\b)|(\bdevice\b)|(\bcomm\b)|(\bmpi_f08\b)|(\bhdf5\b))\w+\b)(?!, only)
    replacement: null
    active: true

  # -------------------------------------------------------------------------- #
  # Formatting and code style rules

  missing-spaces-around-operator:
    message: Missing spaces around operator
    regexp: (\w|\))({operators})(\w|\()
    replacement: \1 \2 \3
    active: true

  missing-spaces-before-operator:
    message: Missing space before operator
    regexp: (\w|\))({operators})
    replacement: \1 \2
    active: true

  missing-spaces-after-operator:
    message: Missing space after operator
    regexp: ({operators})(\w|\()
    replacement: \1 \2
    active: true

  incorrect-spaces-before-separator:
    message: Incorrect space before separator
    regexp: (allocate\()?(^\s*\w+(?<!allocate)\b)?(?(1).*(?<=\s)::|(?(2).*(?<=\S)::|\0))
    replacement: '\1 ::'
    active: false

  incorrect-spaces-after-separator:
    message: Incorrect space after separator
    regexp: (allocate\()?(^\s*\w+(?<!allocate)\b)?(?(1).*::(?=\s)|(?(2).*::(?=\S)|\0))
    replacement: ':: \1'
    active: false

  # Look through the list of punctuation, but skip if inside format string '()'
  # However, we do allow a single letter variable or 2 digit number to be used
  # without spaces.
  missing-spaces-after-punctuation:
    message: Missing space after punctuation
    regexp: ((,(?!.*\)[\'\"]))|(,(?=.*[\'\"]\()))(?=\d\d\d|[a-zA-Z]\w|[(\'\"])
    replacement: \1 \2
    active: true

  missing-space-before-parenthesis:
    message: Missing space before parenthesis
    regexp: (\b{structs}\b)\(
    replacement: \1 (
    active: true

  nospace-end:
    message: Missing space after `end'
    regexp: (?<!\#)end(if|do|subroutine|function)
    replacement: end \1
    active: true

  missing-spaces-before-=:
    message: Missing spaces before "="
    regexp: ([^ \=\n]+)(?<!(kind|.len|..\'d|..\'n))((?<![\/=<>])=(?![>=]))
    replacement: ' = \2'
    active: true

  missing-spaces-after-=:
    message: Missing spaces after "="
    regexp: (?<!(kind|.len|..\'d|..\'n))((?<![=<>\/])=(?![>=]))([^ ]\S*)
    replacement: ' = \2'
    active: true

  # -------------------------------------------------------------------------- #
  # Work in progress rules

  # Exception: ´!` is allowed at the end of a string.
  one-space-before-comment:
    message: At least one space before comment
    regexp: (\S+)\!(?!'|")
    replacement: \1 !
    active: false

  one-space-after-comment:
    message: Exactly one space after comment
    regexp: (\!)(?![\!\'])(\S+)
    replacement: '\1 \2'
    active: false

  excessive-use-of-space:
    message: Except for indentation, single spaces are sufficient
    regexp: (?<=\S)  +(?=[^\s!])
    replacement: " "
    active: false

  double-spacing:
    message: Double spacing
    regexp: \S+\s{{2,}}\S+
    replacement: \n
    active: false

# ============================================================================ #
# These are rules that span over multiple lines, not accessible by regexp
# If you want to edit these rules or add your own, two options:
# - ask us.
# - fork the code.
structure-rules:
  max-statements-in-context: 2000
  max-declared-locals: 35
  min-varlen: 1
  max-varlen: 30
  max-arguments: 20
  min-arglen: 1
  max-arglen: 70
  max-nesting-levels: 8
  var-declaration: '(?:{types})\s*(?:\(.*\))?\s*(?:::| )\s*([A-Za-z_]\w*(?:\s*,\s*[A-Za-z_]\w*)*)'

# ============================================================================ #
# These are the fortran syntax we use to parse the source
# A priori there is no need to edit, but Fortran is so vast in time...
# ============================================================================ #

fortran-syntax:
  types:
    - real
    - character
    - logical
    - integer
    - complex
    - double precision

  types_upper:
    - REAL
    - CHARACTER
    - LOGICAL
    - INTEGER
    - COMPLEX
    - DOUBLE PRECISION

  operators:
    - '\.eq\.'
    - "=="
    - '\.neq\.'
    - "/="
    - '\.gt\.'
    - ">"
    - '\.lt\.'
    - "<"
    - '\.geq\.'
    - ">="
    - '\.leq\.'
    - "<="
    - '\.le\.'
    - '\.ge\.'
    - '\.and\.'
    - '\.or\.'

  structs:
    - "if"
    - "select"
    - "case"
    - "while"
    - "is"
    - "select type"

  structs_upper:
    - "IF"
    - "SELECT"
    - "CASE"
    - "WHILE"
    - "IS"
    - "SELECT TYPE"

  punctuations:
    - ","
    - '\)'
    - ";"

  namespace_blocks:
    - "program"
    - "module"

  context_blocks:
    - function
    - subroutine

  blocks:
    - "program"
    - "subroutine"
    - "module"
    - "function"
    - "blockdata"

  blocks_upper:
    - PROGRAM
    - MODULE
    - FUNCTION
    - SUBROUTINE

  intrinsics_upper:
    - ALLOCATABLE
    - ALLOCATE
    - ASSIGN
    - ASSIGNMENT
    - BACKSPACE
    - BLOCK
    - CALL
    - CASE
    - CLOSE
    - COMMON
    - CONTAINS
    - CONTINUE
    - CYCLE
    - DATA
    - DEALLOCATE
    - DEFAULT
    - DIMENSION
    - DO
    - ELSE
    - ELSEWHERE
    - END
    - ENDFILE
    - ENTRY
    - EQUIVALENCE
    - EXIT
    - EXTERNAL
    - FUNCTION
    - GO
    - GOTO
    - IF
    - IMPLICIT
    - IN
    - INOUT
    - INQUIRE
    - INTENT
    - INTERFACE
    - INTRINSIC
    - MODULE
    - NAMELIST
    - NONE
    - NULLIFY
    - ONLY
    - OPEN
    - OPERATOR
    - OPTIONAL
    - OUT
    - PARAMETER
    - PAUSE
    - POINTER
    - PRINT
    - PRIVATE
    - PROCEDURE
    - PROGRAM
    - PUBLIC
    - READ
    - RECURSIVE
    - RESULT
    - RETURN
    - REWIND
    - SAVE
    - SELECT
    - SEQUENCE
    - STOP
    - SUBROUTINE
    - TARGET
    - THEN
    - TO
    - TYPE
    - USE
    - WHERE
    - WHILE
    - WRITE

  named-args_upper:
    - ACCESS
    - ACTION
    - ADVANCE
    - BLANK
    - DELIM
    - DIRECT
    - EOR
    - ERR
    - EXIST
    - FILE
    - FMT
    - FORM
    - FORMAT
    - FORMATTED
    - IOLENGTH
    - IOSTAT
    - KIND
    - LEN
    - NAME
    - NAMED
    - NEXTREC
    - NML
    - NUMBER
    - OPENED
    - PAD
    - POSITION
    - READWRITE
    - REC
    - RECL
    - SEQUENTIAL
    - SIZE
    - STAT
    - STATUS
    - UNFORMATTED
    - UNIT