Programmatically running an analyzer

Using the SDK, it is possible to invoke analyzers programmatically.
This can be done via the Client type.
The Client needs to know what type of analyzer you intend to load: console or editor.

open FSharp.Analyzers.SDK

let client = Client<CliAnalyzerAttribute, CliContext>()
let countLoaded = client.LoadAnalyzers @"C:\MyAnalyzers"
let ctx = Unchecked.defaultof<CliContext> // Construct your context...

RunAnalyzers does not throw. It returns a result per analyzer, with either the messages of that analyzer or the exception it threw. An analyzer that throws does not affect the messages of the other analyzers.

async {
    let! results = client.RunAnalyzers(ctx)

    for result in results do
        match result.Output with
        | Ok messages ->
            for message in messages do
                printfn "%s: %s" message.Message.Code message.Message.Message
        | Error error -> printfn "Analyzer %s failed: %s" result.AnalyzerName error.Message
}

Previous Next

Multiple items
namespace FSharp

--------------------
namespace Microsoft.FSharp

namespace FSharp.Analyzers

namespace FSharp.Analyzers.SDK

val client: Client<CliAnalyzerAttribute,CliContext>

Multiple items
module Client
from FSharp.Analyzers.SDK

--------------------
type Client<'TAttribute,'TContext (requires 'TAttribute :> AnalyzerAttribute and 'TContext :> Context)> =
  new: logger: ILogger -> Client<'TAttribute,'TContext> + 1 overload
  member LoadAnalyzers:
      dir: string *
      ?excludeInclude: ExcludeInclude ->
          AssemblyLoadStats
  member RunAnalyzers: ctx: 'TContext -> Async<AnalysisResult list> + 1 overload

--------------------
new: unit -> Client<'TAttribute,'TContext>
new: logger: Extensions.Logging.ILogger -> Client<'TAttribute,'TContext>

Multiple items
Marks an analyzer for scanning during the console application run.
type CliAnalyzerAttribute =
  inherit AnalyzerAttribute
  new:
      [<Optional; DefaultParameterValue (("Analyzer" :> obj))>] name: string *
      [<Optional; DefaultParameterValue (("" :> obj))>] shortDescription: string *
      [<Optional; DefaultParameterValue (("" :> obj))>] helpUri: string ->
          CliAnalyzerAttribute
  member Name: string

--------------------
new:
    [<System.Runtime.InteropServices.Optional; System.Runtime.InteropServices.DefaultParameterValue (("Analyzer" :> obj))>] name: string *
    [<System.Runtime.InteropServices.Optional; System.Runtime.InteropServices.DefaultParameterValue (("" :> obj))>] shortDescription: string *
    [<System.Runtime.InteropServices.Optional; System.Runtime.InteropServices.DefaultParameterValue (("" :> obj))>] helpUri: string ->
        CliAnalyzerAttribute

All the relevant compiler information for a given file.
Contains the source text, untyped and typed tree information.
type CliContext =
  {
    FileName: string
    SourceText: ISourceText
    ParseFileResults: FSharpParseFileResults
    CheckFileResults: FSharpCheckFileResults
    TypedTree: FSharpImplementationFileContents option
    CheckProjectResults: FSharpCheckProjectResults
    ProjectOptions: AnalyzerProjectOptions
    AnalyzerIgnoreRanges: Map<string,AnalyzerIgnoreRange list>
  }
  interface Context
  member GetAllEntities: publicOnly: bool -> AssemblySymbol list
  member GetAllSymbolUsesOfFile: unit -> FSharpSymbolUse seq
  member GetAllSymbolUsesOfProject: unit -> FSharpSymbolUse array

val countLoaded: AssemblyLoadStats

member Client.LoadAnalyzers:
    dir: string *
    ?excludeInclude: ExcludeInclude ->
        AssemblyLoadStats

val ctx: CliContext

module Unchecked
from Microsoft.FSharp.Core.Operators

val defaultof<'T> : 'T

val async: AsyncBuilder

val results: AnalysisResult list

member Client.RunAnalyzers: ctx: 'TContext -> Async<AnalysisResult list>
member Client.RunAnalyzers:
    ctx: 'TContext *
    analyzerPredicate: (Client.RegisteredAnalyzer<'TContext> -> bool) ->
        Async<AnalysisResult list>

val result: AnalysisResult

The messages of the analyzer, or the exception it threw.
AnalysisResult.Output: Result<AnalyzerMessage list,exn>

union case Result.Ok: ResultValue: 'T -> Result<'T,'TError>

val messages: AnalyzerMessage list

val message: AnalyzerMessage

val printfn: format: Printf.TextWriterFormat<'T> -> 'T

A message produced by the analyzer.
AnalyzerMessage.Message: Message

Message.Code: string

Message.Message: string

union case Result.Error: ErrorValue: 'TError -> Result<'T,'TError>

val error: exn

AnalysisResult.AnalyzerName: string

property System.Exception.Message: string with get