Lint.fsi

namespace FSharpLint.Application

/// Provides an API to manage/load FSharpLint configuration files.
/// <see cref="FSharpLint.Framework.Configuration" /> for more information on
/// the default configuration and overriding configurations.
module ConfigurationManagement =

    open FSharpLint.Framework.Configuration

    /// Load a FSharpLint configuration file from the contents (string) of the file.
    val loadConfigurationFile : configurationFileText:string -> Configuration

/// Provides an API for running FSharpLint from within another application.
[<AutoOpen>]
module Lint =

    open System.Threading
    open System.Threading.Tasks
    open FSharpLint.Framework
    open FSharpLint.Framework.Configuration
    open FSharpLint.Framework.Rules
    open FSharp.Compiler.Text
    open FSharp.Compiler.CodeAnalysis

    /// Provides information on what the linter is currently doing.
    [<NoComparison>]
    type ProjectProgress =
        /// Started parsing a file (file path).
        | Starting of filePath: string

        /// Finished parsing a file (file path).
        | ReachedEnd of filePath: string * violations: Suggestion.LintWarning list

        /// Failed to parse a file (file path, exception that caused failure).
        | Failed of filePath: string * ex: System.Exception

        /// Path of the F# file the progress information is for.
        member FilePath : unit -> string

    type ConfigurationParam =
        | Configuration of config: Configuration
        | FromFile of configPath:string
        /// Tries to load the config from file `fsharplint.json`.
        /// If this file doesn't exist or is invalid, falls back to the default configuration.
        | Default

    /// Optional parameters that can be provided to the linter.
    [<NoEquality; NoComparison>]
    type OptionalLintParameters = {
        /// Cancels a lint in progress.
        CancellationToken: CancellationToken option

        /// Lint configuration to use.
        /// Can either specify a full configuration object, or a path to a file to load the configuration from.
        /// You can also explicitly specify the default configuration.
        Configuration: ConfigurationParam

        /// This function will be called every time the linter finds a broken rule.
        ReceivedWarning: (Suggestion.LintWarning -> unit) option

        ReportLinterProgress: (ProjectProgress -> unit) option
    } with
        static member Default: OptionalLintParameters

    /// If your application has already parsed the F# source files using `FSharp.Compiler.Services`
    /// you want to lint then this can be used to provide the parsed information to prevent the
    /// linter from parsing the file again.
    [<NoEquality; NoComparison>]
    type ParsedFileInformation = {
        /// File represented as an AST.
        Ast: FSharp.Compiler.Syntax.ParsedInput

        /// Contents of the file.
        Source: string

        /// Optional results of inferring the types on the AST (allows for a more accurate lint).
        TypeCheckResults: FSharpCheckFileResults option

        /// Optional results of project-wide type info (allows for a more accurate lint).
        ProjectCheckResults:FSharpCheckProjectResults option
        /// Path to the project file (.fsproj), when known. Lets the library-heuristic
        /// rules work under hosts (e.g. TransparentCompiler analyzer hosts) where the
        /// project options cannot be derived from the check results.
        ProjectFileName:string option
    }

    type BuildFailure = | InvalidProjectFileMessage of string

    /// Reason for the linter failing.
    [<NoComparison>]
    type LintFailure =
        /// Project file path did not exist on the local filesystem.
        | ProjectFileCouldNotBeFound of projectFilePath: string

        /// Received exception when trying to get the list of F# file from the project file.
        | MSBuildFailedToLoadProjectFile of projectFilePath: string * failure: BuildFailure

        /// Failed to load a FSharpLint configuration file.
        | FailedToLoadConfig of errorMessage: string

        /// The specified file for linting could not be found.
        | FailedToLoadFile of filePath: string

        /// Failed to analyse a loaded FSharpLint configuration at runtime e.g. invalid hint.
        | RunTimeConfigError of errorMessage: string

        /// `FSharp.Compiler.Services` failed when trying to parse a file.
        | FailedToParseFile of failure: ParseFile.ParseFileFailure

        /// `FSharp.Compiler.Services` failed when trying to parse one or more files in a project.
        | FailedToParseFilesInProject of failures: ParseFile.ParseFileFailure list

        member Description: string

    type Context =
        { IndentationRuleContext : Map<int,bool*int>
// TODO: investigate incorrect indentation warning
// fsharplint:disable-next-line Indentation
          NoTabCharactersRuleContext : (string * Range) list }

    /// Result of running the linter.
    [<NoEquality; NoComparison; RequireQualifiedAccess>]
    type LintResult =
        | Success of violations: Suggestion.LintWarning list
        | Failure of failure: LintFailure

        member TryGetSuccess : byref<Suggestion.LintWarning list> -> bool
        member TryGetFailure : byref<LintFailure> -> bool

    type RunAstNodeRulesConfig =
        {
            Rules: RuleMetadata<AstNodeRuleConfig>[]
            GlobalConfig: Rules.GlobalRuleConfig
            TypeCheckResults: FSharpCheckFileResults option
            ProjectCheckResults: FSharpCheckProjectResults option
            ProjectFileName: Lazy<string option>
            FilePath: string
            FileContent: string
            Lines: string[]
            SyntaxArray: AbstractSyntaxArray.Node array
        }

    /// Runs all rules which take a node of the AST as input.
    val runAstNodeRules : RunAstNodeRulesConfig -> Suggestion.LintWarning [] * Context

    type RunLineRulesConfig =
        {
            LineRules: Configuration.LineRules
            GlobalConfig: Rules.GlobalRuleConfig
            FilePath: string
            FileContent: string
            Lines: string[]
            Context: Context
        }

    /// Gets a FSharpLint Configuration based on the provided ConfigurationParam.
    val getConfig: ConfigurationParam -> Result<Configuration, string>

    /// Runs all rules which take a line of text as input.
    val runLineRules : RunLineRulesConfig -> Suggestion.LintWarning []

    /// Lints an entire F# solution by linting all projects specified in the `.sln`, `slnx` or `.slnf` file.
    val asyncLintSolution : optionalParams:OptionalLintParameters -> solutionFilePath:string -> toolsPath:Ionide.ProjInfo.Types.ToolsPath -> Async<LintResult>

    /// Lints an entire F# solution by linting all projects specified in the `.sln`, `slnx` or `.slnf` file.
    val lintSolutionAsync : optionalParams:OptionalLintParameters -> solutionFilePath:string -> toolsPath:Ionide.ProjInfo.Types.ToolsPath ->  Task<LintResult>

    /// [Obsolete] Lints an entire F# solution by linting all projects specified in the `.sln`, `slnx` or `.slnf` file.
    val lintSolution : optionalParams:OptionalLintParameters -> solutionFilePath:string -> toolsPath:Ionide.ProjInfo.Types.ToolsPath -> LintResult

    /// Lints an entire F# project by retrieving the files from a given
    /// path to the `.fsproj` file.
    val asyncLintProject : optionalParams:OptionalLintParameters -> projectFilePath:string -> toolsPath:Ionide.ProjInfo.Types.ToolsPath -> Async<LintResult>

    /// Lints an entire F# project by retrieving the files from a given path to the `.fsproj` file.
    val lintProjectAsync : optionalParams:OptionalLintParameters -> projectFilePath:string -> toolsPath:Ionide.ProjInfo.Types.ToolsPath -> Task<LintResult>

    /// [Obsolete] Lints an entire F# project by retrieving the files from a given path to the `.fsproj` file.
    val lintProject : optionalParams:OptionalLintParameters -> projectFilePath:string -> toolsPath:Ionide.ProjInfo.Types.ToolsPath -> LintResult

    /// Lints F# source code async.
    val asyncLintSource : optionalParams:OptionalLintParameters -> source:string -> Async<LintResult>

    /// Lints F# source code async.
    val lintSourceAsync : optionalParams:OptionalLintParameters -> source:string -> Task<LintResult>

    /// [Obsolete] Lints F# source code.
    val lintSource : optionalParams:OptionalLintParameters -> source:string -> LintResult

    /// Lints F# source code that has already been parsed using
    /// `FSharp.Compiler.Services` in the calling application.
    val lintParsedSource : optionalParams:OptionalLintParameters -> parsedFileInfo:ParsedFileInformation -> LintResult

    /// Lints an F# file from a given path to the `.fs` file.
    val asyncLintFile : optionalParams:OptionalLintParameters -> filePath:string -> Async<LintResult>

    /// Lints an F# file from a given path to the `.fs` file.
    val lintFileAsync : optionalParams:OptionalLintParameters -> filePath:string -> Task<LintResult>

    /// [Obsolete] Lints an F# file from a given path to the `.fs` file.
    val lintFile : optionalParams:OptionalLintParameters -> filePath:string -> LintResult

    /// Lints multiple F# files from given file paths.
    val asyncLintFiles : optionalParams:OptionalLintParameters -> filePaths:string seq -> Async<LintResult>

    /// Lints multiple F# files from given file paths.
    val lintFilesAsync : optionalParams:OptionalLintParameters -> filePaths:string seq -> Task<LintResult>

    /// [Obsolete] Lints multiple F# files from given file paths.
    val lintFiles : optionalParams:OptionalLintParameters -> filePaths:string seq -> LintResult

    /// Lints an F# file that has already been parsed using
    /// `FSharp.Compiler.Services` in the calling application.
    val lintParsedFile : optionalParams:OptionalLintParameters -> parsedFileInfo:ParsedFileInformation -> filePath:string -> LintResult