hl_fsharp.js

/**
 * @param {string} value
 * @returns {RegExp}
 * */
function escape(value) {
    return new RegExp(value.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&'), 'm')
}

/**
 * @param {RegExp | string } re
 * @returns {string}
 */
function source(re) {
    if (!re) return null
    if (typeof re === 'string') return re

    return re.source
}

/**
 * @param {RegExp | string } re
 * @returns {string}
 */
function lookahead(re) {
    return concat('(?=', re, ')')
}

/**
 * @param {...(RegExp | string) } args
 * @returns {string}
 */
function concat(...args) {
    const joined = args.map((x) => source(x)).join('')
    return joined
}

/**
 * @param { Array<string | RegExp | Object> } args
 * @returns {object}
 */
function stripOptionsFromArgs(args) {
    const opts = args[args.length - 1]

    if (typeof opts === 'object' && opts.constructor === Object) {
        args.splice(args.length - 1, 1)
        return opts
    } else {
        return {}
    }
}

/** @typedef { {capture?: boolean} } RegexEitherOptions */

/**
 * Any of the passed expresssions may match
 *
 * Creates a huge this | this | that | that match
 * @param {(RegExp | string)[] | [...(RegExp | string)[], RegexEitherOptions]} args
 * @returns {string}
 */
function either(...args) {
    /** @type { object & {capture?: boolean} }  */
    const opts = stripOptionsFromArgs(args)
    const joined =
        '(' +
        (opts.capture ? '' : '?:') +
        args.map((x) => source(x)).join('|') +
        ')'
    return joined
}

/*
Language: F#
Author: Jonas Follesø <jonas@follesoe.no>
Contributors: Troy Kershaw <hello@troykershaw.com>, Henrik Feldt <henrik@haf.se>, Melvyn Laïly <melvyn.laily@gmail.com>
Website: https://docs.microsoft.com/en-us/dotnet/fsharp/
Category: functional
*/

/** @type LanguageFn */
export default function (hljs) {
    const KEYWORDS = []

    const BANG_KEYWORD_MODE = {
        // monad builder keywords (matches before non-bang keywords)
        scope: 'keyword',
        match: /\b(yield|return|let|do|match|use)!/,
    }

    const PREPROCESSOR_KEYWORDS = []

    const LITERALS = ['true', 'false']

    const SPECIAL_IDENTIFIERS = [
        '__LINE__',
        '__SOURCE_DIRECTORY__',
        '__SOURCE_FILE__',
    ]

    // Since it's possible to re-bind/shadow names (e.g. let char = 'c'),
    // these builtin types should only be matched when a type name is expected.
    const KNOWN_TYPES = [
        // basic types
    ]

    const BUILTINS = [
        // Somewhat arbitrary list of builtin functions and values.
        // Most of them are declared in Microsoft.FSharp.Core
        // I tried to stay relevant by adding only the most idiomatic
        // and most used symbols that are not already declared as types.
        'Attr',
        'attr',
        'Html',
        'Elem',
        'prop',
        'text',
        'Text',
        'str',
    ]

    const ALL_KEYWORDS = {
        keyword: KEYWORDS,
        literal: LITERALS,
        built_in: BUILTINS,
        'variable.constant': SPECIAL_IDENTIFIERS,
    }

    // (* potentially multi-line Meta Language style comment *)
    const ML_COMMENT = hljs.COMMENT(/\(\*(?!\))/, /\*\)/, {
        contains: ['self'],
    })
    // Either a multi-line (* Meta Language style comment *) or a single line // C style comment.
    const COMMENT = {
        variants: [ML_COMMENT, hljs.C_LINE_COMMENT_MODE],
    }

    // Most identifiers can contain apostrophes
    const IDENTIFIER_RE = /[a-zA-Z_](\w|')*/

    const QUOTED_IDENTIFIER = {
        scope: 'variable',
        begin: /``/,
        end: /``/,
    }

    // 'a or ^a where a can be a ``quoted identifier``
    const BEGIN_GENERIC_TYPE_SYMBOL_RE = /\B('|\^)/
    const GENERIC_TYPE_SYMBOL = {
        scope: 'symbol',
        variants: [
            // the type name is a quoted identifier:
            { match: concat(BEGIN_GENERIC_TYPE_SYMBOL_RE, /``.*?``/) },
            // the type name is a normal identifier (we don't use IDENTIFIER_RE because there cannot be another apostrophe here):
            {
                match: concat(
                    BEGIN_GENERIC_TYPE_SYMBOL_RE,
                    hljs.UNDERSCORE_IDENT_RE
                ),
            },
        ],
        relevance: 0,
    }

    const makeOperatorMode = function ({ includeEqual }) {
        // List or symbolic operator characters from the FSharp Spec 4.1, minus the dot, and with `?` added, used for nullable operators.
        let allOperatorChars
        if (includeEqual) allOperatorChars = '!%&*+-/<=>@^|~?{}[]'
        else allOperatorChars = '!%&*+-/<>@^|~?{}[]'
        const OPERATOR_CHARS = Array.from(allOperatorChars)
        const OPERATOR_CHAR_RE = concat('[', ...OPERATOR_CHARS.map(escape), ']')
        // The lone dot operator is special. It cannot be redefined, and we don't want to highlight it. It can be used as part of a multi-chars operator though.
        const OPERATOR_CHAR_OR_DOT_RE = either(OPERATOR_CHAR_RE, /\./)
        // When a dot is present, it must be followed by another operator char:
        const OPERATOR_FIRST_CHAR_OF_MULTIPLE_RE = concat(
            OPERATOR_CHAR_OR_DOT_RE,
            lookahead(OPERATOR_CHAR_OR_DOT_RE)
        )
        const SYMBOLIC_OPERATOR_RE = either(
            concat(
                OPERATOR_FIRST_CHAR_OF_MULTIPLE_RE,
                OPERATOR_CHAR_OR_DOT_RE,
                '*'
            ), // Matches at least 2 chars operators
            concat(OPERATOR_CHAR_RE, '+') // Matches at least one char operators
        )
        return {
            scope: 'operator',
            match: either(
                // symbolic operators:
                SYMBOLIC_OPERATOR_RE,
                // other symbolic keywords:
                // Type casting and conversion operators:
                /:\?>/,
                /:\?/,
                /:>/,
                /:=/, // Reference cell assignment
                /::?/, // : or ::
                /\$/
            ), // A single $ can be used as an operator
            relevance: 0,
        }
    }

    const OPERATOR = makeOperatorMode({ includeEqual: true })
    // This variant is used when matching '=' should end a parent mode:
    const OPERATOR_WITHOUT_EQUAL = makeOperatorMode({ includeEqual: false })

    const makeTypeAnnotationMode = function (prefix, prefixScope) {
        return {
            begin: concat(
                // a type annotation is a
                prefix, // should be a colon or the 'of' keyword
                lookahead(
                    // that has to be followed by
                    concat(
                        /\s*/, // optional space
                        either(
                            // then either of:
                            /\w/, // word
                            /'/, // generic type name
                            /\^/, // generic type name
                            /#/, // flexible type name
                            /``/, // quoted type name
                            /\(/, // parens type expression
                            /{\|/ // anonymous type annotation
                        )
                    )
                )
            ),
            beginScope: prefixScope,
            // BUG: because ending with \n is necessary for some cases, multi-line type annotations are not properly supported.
            // Examples where \n is required at the end:
            // - abstract member definitions in classes: abstract Property : int * string
            // - return type annotations: let f f' = f' () : returnTypeAnnotation
            // - record fields definitions: { A : int \n B : string }
            end: lookahead(either(/\n/, /=/)),
            relevance: 0,
            // we need the known types, and we need the type constraint keywords and literals. e.g.: when 'a : null
            keywords: hljs.inherit(ALL_KEYWORDS, { type: KNOWN_TYPES }),
            contains: [
                COMMENT,
                GENERIC_TYPE_SYMBOL,
                hljs.inherit(QUOTED_IDENTIFIER, { scope: null }), // match to avoid strange patterns inside that may break the parsing
                OPERATOR_WITHOUT_EQUAL,
            ],
        }
    }

    const TYPE_ANNOTATION = makeTypeAnnotationMode(/:/, 'operator')
    const DISCRIMINATED_UNION_TYPE_ANNOTATION = makeTypeAnnotationMode(
        /\bof\b/,
        'keyword'
    )

    // type MyType<'a> = ...
    const TYPE_DECLARATION = {
        begin: [
            /(^|\s+)/, // prevents matching the following: `match s.stype with`
            /type/,
            /\s+/,
            IDENTIFIER_RE,
        ],
        beginScope: {
            2: 'keyword',
            4: 'title.class',
        },
        end: lookahead(/\(|=|$/),
        keywords: ALL_KEYWORDS, // match keywords in type constraints. e.g.: when 'a : null
        contains: [
            COMMENT,
            hljs.inherit(QUOTED_IDENTIFIER, { scope: null }), // match to avoid strange patterns inside that may break the parsing
            GENERIC_TYPE_SYMBOL,
            {
                // For visual consistency, highlight type brackets as operators.
                scope: 'operator',
                match: /<|>/,
            },
            TYPE_ANNOTATION, // generic types can have constraints, which are type annotations. e.g. type MyType<'T when 'T : delegate<obj * string>> =
        ],
    }

    const COMPUTATION_EXPRESSION = {
        // computation expressions:
        scope: 'computation-expression',
        // BUG: might conflict with record deconstruction. e.g. let f { Name = name } = name // will highlight f
        match: /\b[_a-z]\w*(?=\s*\{)/,
    }

    const PREPROCESSOR = {
        // preprocessor directives and fsi commands:
        begin: [/^\s*/, concat(/#/, either(...PREPROCESSOR_KEYWORDS)), /\b/],
        beginScope: { 2: 'meta' },
        end: lookahead(/\s|$/),
    }

    // TODO: this definition is missing support for type suffixes and octal notation.
    // BUG: range operator without any space is wrongly interpreted as a single number (e.g. 1..10 )
    const NUMBER = {
        variants: [hljs.BINARY_NUMBER_MODE, hljs.C_NUMBER_MODE],
    }

    // All the following string definitions are potentially multi-line.
    // BUG: these definitions are missing support for byte strings (suffixed with B)

    // "..."
    const QUOTED_STRING = {
        scope: 'string',
        begin: /"/,
        end: /"/,
        contains: [hljs.BACKSLASH_ESCAPE],
    }
    // @"..."
    const VERBATIM_STRING = {
        scope: 'string',
        begin: /@"/,
        end: /"/,
        contains: [
            {
                match: /""/, // escaped "
            },
            hljs.BACKSLASH_ESCAPE,
        ],
    }
    // """..."""
    const TRIPLE_QUOTED_STRING = {
        scope: 'string',
        begin: /"""/,
        end: /"""/,
        relevance: 2,
    }
    const SUBST = {
        scope: 'subst',
        begin: /\{/,
        end: /\}/,
        keywords: ALL_KEYWORDS,
    }
    // $"...{1+1}..."
    const INTERPOLATED_STRING = {
        scope: 'string',
        begin: /\$"/,
        end: /"/,
        contains: [
            {
                match: /\{\{/, // escaped {
            },
            {
                match: /\}\}/, // escaped }
            },
            hljs.BACKSLASH_ESCAPE,
            SUBST,
        ],
    }
    // $@"...{1+1}..."
    const INTERPOLATED_VERBATIM_STRING = {
        scope: 'string',
        begin: /(\$@|@\$)"/,
        end: /"/,
        contains: [
            {
                match: /\{\{/, // escaped {
            },
            {
                match: /\}\}/, // escaped }
            },
            {
                match: /""/,
            },
            hljs.BACKSLASH_ESCAPE,
            SUBST,
        ],
    }
    // $"""...{1+1}..."""
    const INTERPOLATED_TRIPLE_QUOTED_STRING = {
        scope: 'string',
        begin: /\$"""/,
        end: /"""/,
        contains: [
            {
                match: /\{\{/, // escaped {
            },
            {
                match: /\}\}/, // escaped }
            },
            SUBST,
        ],
        relevance: 2,
    }
    // '.'
    const CHAR_LITERAL = {
        scope: 'string',
        match: concat(
            /'/,
            either(
                /[^\\']/, // either a single non escaped char...
                /\\(?:.|\d{3}|x[a-fA-F\d]{2}|u[a-fA-F\d]{4}|U[a-fA-F\d]{8})/ // ...or an escape sequence
            ),
            /'/
        ),
    }
    // F# allows a lot of things inside string placeholders.
    // Things that don't currently seem allowed by the compiler: types definition, attributes usage.
    // (Strictly speaking, some of the followings are only allowed inside triple quoted interpolated strings...)
    SUBST.contains = [
        INTERPOLATED_VERBATIM_STRING,
        INTERPOLATED_STRING,
        VERBATIM_STRING,
        QUOTED_STRING,
        CHAR_LITERAL,
        BANG_KEYWORD_MODE,
        COMMENT,
        QUOTED_IDENTIFIER,
        TYPE_ANNOTATION,
        COMPUTATION_EXPRESSION,
        PREPROCESSOR,
        NUMBER,
        GENERIC_TYPE_SYMBOL,
        OPERATOR,
    ]
    const STRING = {
        variants: [
            INTERPOLATED_TRIPLE_QUOTED_STRING,
            INTERPOLATED_VERBATIM_STRING,
            INTERPOLATED_STRING,
            TRIPLE_QUOTED_STRING,
            VERBATIM_STRING,
            QUOTED_STRING,
            CHAR_LITERAL,
        ],
    }

    return {
        name: 'F#',
        aliases: ['fs', 'f#'],
        keywords: ALL_KEYWORDS,
        illegal: /\/\*/,
        classNameAliases: {
            'computation-expression': 'keyword',
        },
        contains: [
            BANG_KEYWORD_MODE,
            STRING,
            COMMENT,
            QUOTED_IDENTIFIER,
            TYPE_DECLARATION,
            {
                // e.g. [<Attributes("")>] or [<``module``: MyCustomAttributeThatWorksOnModules>]
                // or [<Sealed; NoEquality; NoComparison; CompiledName("FSharpAsync`1")>]
                scope: 'meta',
                begin: /\[</,
                end: />\]/,
                relevance: 2,
                contains: [
                    QUOTED_IDENTIFIER,
                    // can contain any constant value
                    TRIPLE_QUOTED_STRING,
                    VERBATIM_STRING,
                    QUOTED_STRING,
                    CHAR_LITERAL,
                    NUMBER,
                ],
            },
            DISCRIMINATED_UNION_TYPE_ANNOTATION,
            TYPE_ANNOTATION,
            COMPUTATION_EXPRESSION,
            PREPROCESSOR,
            NUMBER,
            GENERIC_TYPE_SYMBOL,
            OPERATOR,
        ],
    }
}