Currently the result is ignored: FSharpLint.Application.RunLint.parseProject parseInfo |> ignore, this means that when the MSBuild task fails there's no indication that anything has gone wrong, the result needs to be handled and logged as a warning

see: http://mascot.x9c.fr/distrib/mascot.html

Also needs to be tidied up as it's a complete mess

If I create a new console project in VS2013, set the target F# Runtime to 4.3.0.0, and build it, then I can run FSharpLint.exe against it and no warning are produced.
If I then set the runtime to 4.3.1.0 and rebuild, then running FSharpLint produces a crash:
Failed to parse file Program.fs Exception Message: Exception of type 'FSharpLint.Framework.Ast+ParseException' was thrown. Exception Stack Trace: at FSharpLint.Framework.Ast.parse(FSharpFunc2 finishEarly, InteractiveChecke
r checker, ProjectOptions projectOptions, String file, String input, FSharpList 1 visitors) in C:\Git\FSharpLint\src\FSharpLint.Framework\Ast.fs:line 521 at [email protected](Unit unitVar) in C:\Gi t\FSharpLint\src\FSharpLint.Application\RunLint.fs:line 94 at [email protected](AsyncParams1 a
rgs)`

Switching back to 4.3.0.0 and rebuilding makes the error go away again.

There are a few circumstances where we need to lookup more information on an identifier.

Examples:

match 5 with
    | Number -> ()

We need to lookup Number to find out whether it's a discriminated union case or a new identifier.

[<Literal>]
let Cat = 5

We need to lookup the attribute to make sure it's the LiteralAttribute from FSharp.Core (could have been redefined).

Type checking the code makes the linter significantly slower, so the idea here is to let whether the code is type checked be configurable

Currently the SuppressMessageAttribute isn't supported by the FSharpLint.Typography analyser because it doesn't have access to the AST which is what is being used to get the SuppressMessageAttributes. Seems like the AST needs to be analysed initially to get a map of SuppressMessageAttribute to range for the plaintext visitors.

The extension needs to have any fluff taken out of it. Just a single button on the tools menu to run the lint on all open projects, display the errors in the error window, and display the progress in the output window. The extension right now is broken because of a bad dependency on FParsec

Want to have continuous integration set up

Currently the configuration file is more difficult to use than it needs to be as it tried to have a very similar format to StyleCop's configuration. A simpler type safe approach (allowing for an xsd not letting the user enter anything that shouldn't be possible) outweighs imo the benefits of the configuration mimicking StyleCop

we are using FSharpLint like this at the moment

Target "Lint" (fun _ ->
    let printException (e:System.Exception) =
        System.Console.WriteLine("Exception Message:")
        System.Console.WriteLine(e.Message)
        System.Console.WriteLine("Exception Stack Trace:")
        System.Console.WriteLine(e.StackTrace)

    let failedToParseFileError (file:string) parseException =
        printfn "%A" file
        printException parseException

    let parserProgress = function
        | FSharpLint.Application.RunLint.Starting(file)
        | FSharpLint.Application.RunLint.ReachedEnd(file) -> ()
        | FSharpLint.Application.RunLint.Failed(file, parseException) ->
            failedToParseFileError file parseException

    let error = System.Action<ErrorHandling.Error>(fun error ->  
        let output = error.Info + System.Environment.NewLine + ErrorHandling.errorInfoLine error.Range error.Input 
        System.Console.WriteLine(output)) 


    let lintOptions: RunLint.ProjectParseInfo =
        {
            /// Function that when returns true cancels the parsing of the project, useful for cancellation tokens etc.
            FinishEarly = System.Func<_>(fun _ -> false)

            /// Absolute path to the .fsproj file.
            ProjectFile = calculonProjectFile

            /// Callback that's called at the start and end of parsing each file (or when a file fails to be parsed).
            Progress = System.Action<RunLint.ParserProgress>(parserProgress)

            /// Callback that's called when a lint error is detected.
            ErrorReceived = error

            /// Optionally force the lint to lookup FSharp.Core.dll from this directory.
            FSharpCoreDirectory = Some fsharpCore
        }
    RunLint.parseProject lintOptions |> printfn "%A"

)

it would be nice to use it like this:

Target "Lint" (fun _ -> 
    !! projectFile
    |> FSharpLint(fun p -> 
    { p with
        Settings = Some settingsFile
        FSharpCoreDirectory =  Some coreDirectory }) 
)

see: http://mascot.x9c.fr/distrib/mascot.html

Currently the FSharp.Core directory is looked up using the version number inside of the reference in the project file e.g. <Reference Include="FSharp.Core, Version=4.3.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"> will use 4.3.0.0. The version number is not required so this case needs to be handled.

I'm thinking that it should try and find the most recent version of FSharp.Core if no version is specified

Add a section to the configuration file that lets users specify files not to be linted

feature request.

failwith "%s" str // typo of failwith*f*. but this code has no warnings...
failwithf "%s %s" str1 str2 str3 // %s is not enough or str3 is extra.

I want to detect these cases.

see: http://mascot.x9c.fr/distrib/mascot.html

It would be a nice touch if adding this as a nuget package would modify the fsproj file to insert the task and target.

see: http://mascot.x9c.fr/distrib/mascot.html

see: http://mascot.x9c.fr/distrib/mascot.html

Currently there's a config, but right now nothing is using it, could do with a record being passed to all visitors which contains the config

Currently all of the documentation is in markdown, parts of it have become difficult to read and could do with further styling. We need to use the current markdown documentation to generate HTML documentation on the pages branch. It looks like FSharp.Formatting is the tool for this job, looking at other F# projects it tends to be tied up to the build script to push to the pages branch on build.

type Bar() =
    static member SomeMethod(foo: bool) = ()

Bar.SomeMethod(foo = true)

This currently warns with x=true can be refactored into x because it's interpreting the named parameter as checking for equivalence rather than being assigned a value

see: http://mascot.x9c.fr/distrib/mascot.html

Currently there's very few hints (20 in total)

Adding new hints is going to be an ongoing process, a good start will be to see what we can convert from the default HLint rules to F# hints. It would be great to build up a sizable collection of hints for the FSharp.Core library and the .NET framework.

At the moment there's limitations in which rules can be written e.g. we can't currently match against tuples or lists, these limitations are going to be the next priority

A control flow graph will make analysing code in certain ways much simpler than using the visitor approach.

The goals I have in mind with it are so that we can: detect code that will never be hit and write hints in the config file like HLint's

Support needs to be added for SuppressMessageAttribute so that rules can be disabled from within the code

see: http://mascot.x9c.fr/distrib/mascot.html

see: http://mascot.x9c.fr/distrib/mascot.html

Let us know if you'd like to move to http://github.com/fsprojects. It can be useful to

(a) help attract multiple contributors
(b) make it a more canonical component in the F# ecosystem
(c) eventually graduate to "fsharp" once very stable, widely used, well tested, well documented etc.

To request to be moved, add an entry here: https://github.com/fsprojects/FsProjectsAdmin

Adding an XSD will document the structure of a config file and also let users validate their config files

There's now a nuget package: https://www.nuget.org/packages/FSharpLint/

The generation of the .nupkg file should be automatically created after building the project - integrated into the /build.fsx file

I have no idea how logo for lint project should looks like, but I pretty sure that FSharpLint project and twitter account needs logo. And I have some options for you ;)

Option 1 (I like this one):

Option 2:

Option 3:

Option 4:

Option 5:

Option 6:

Any ideas/suggestions about logo?

Right now the directory containing FSharp.Core.dll with .sigdata and .optdata files needs to be found to be able to parse any projects. Currently the tool looks for the directory by searching for the default locations

The directory may not be located in one of the default locations so it should be possible to optionally pass the path of the directory to both the console application and MSBuild task.

Our Settings.FSharpLint is in the same folder as the fsproj file (and we tried putting it one folder up) and the settings aren't applied.

Running on MonoDevelop I get the following error:

/Users/dave/code/monodevelop/main/external/fsharpbinding/monodevelop/MonoDevelop.FSharpBinding/packages/FSharpLint.0.1.11/build/FSharpLint.targets: Warning: Lint failed while analysing /Users/dave/code/monodevelop/main/external/fsharpbinding/FSharp.CompilerBinding/FSharp.CompilerBinding.fsproj.
Failed with: Could not find any resources appropriate for the specified culture or the neutral culture.  Make sure "Text.resources" was correctly embedded or linked into assembly "FSharpLint.Framework" at compile time, or that all the satellite assemblies required are loadable and fully signed.
Stack trace:   at System.Resources.ResourceManager.AssemblyResourceMissing (System.String fileName) [0x00000] in <filename unknown>:0 
  at System.Resources.ResourceManager.InternalGetResourceSet (System.Globalization.CultureInfo culture, Boolean createIfNotExists, Boolean tryParents) [0x00000] in <filename unknown>:0 
  at System.Resources.ResourceManager.InternalGetResourceSet (System.Globalization.CultureInfo culture, Boolean createIfNotExists, Boolean tryParents) [0x00000] in <filename unknown>:0 
  at System.Resources.ResourceManager.InternalGetResourceSet (System.Globalization.CultureInfo culture, Boolean createIfNotExists, Boolean tryParents) [0x00000] in <filename unknown>:0 
  at System.Resources.ResourceManager.GetString (System.String name, System.Globalization.CultureInfo culture) [0x00000] in <filename unknown>:0 
  at System.Resources.ResourceManager.GetString (System.String name) [0x00000] in <filename unknown>:0 
  at FSharpLint.Framework.Resources.GetString (System.String name) [0x00000] in <filename unknown>:0 
  at FSharpLint.MSBuildIntegration.FSharpLintTask.logError (System.String resouce, System.Object[] args) [0x00000] in <filename unknown>:0 
  at FSharpLint.MSBuildIntegration.FSharpLintTask.Execute () [0x00000] in <filename unknown>:0  (FSharp.CompilerBinding)

I created a new F# console application with main file consisting of simply

let x = 23
printfn "%d" x

and added the 0.1.6 package to the project with the NuGet Gui. On building it I get errors every time I try

In VS2010SP1 on both Vista and Win7

This is reproducible on different machines, just so long as I'm using VS2010

D:\temp\ConsoleApplication1\packages\FSharpLint.0.1.6\build\FSharpLint.targets(16,5): warning : Lint failed while analysing D:\temp\ConsoleApplication1\ConsoleApplication1\ConsoleApplication1.fsproj.
Failed with: Method not found: 'ParserResult`2<!!0,Microsoft.FSharp.Core.Unit> FParsec.CharParsers.run(Microsoft.FSharp.Core.FSharpFunc`2<FParsec.CharStream`1<Microsoft.FSharp.Core.Unit>,FParsec.Reply`1<!!0>>, System.String)'.
Stack trace:    at [email protected](String hint)
   at Microsoft.FSharp.Primitives.Basics.List.map[T,TResult](FSharpFunc`2 mapping, FSharpList`1 x)
   at Microsoft.FSharp.Collections.ListModule.Map[T,TResult](FSharpFunc`2 mapping, FSharpList`1 list)
   at [email protected](FSharpMap`2 config)
   at FSharpLint.Framework.HintMatcher.RegisterHintVisitor.FSharpLint-Framework-LoadVisitors-IRegisterPluginWithConfigChecker-CheckConfig(FSharpMap`2 config)
   at Microsoft.FSharp.Primitives.Basics.List.map[T,TResult](FSharpFunc`2 mapping, FSharpList`1 x)
   at FSharpLint.Framework.LoadVisitors.checkConfigsForFailures(FSharpMap`2 config, FSharpList`1 checkConfigs)
   at FSharpLint.Application.ProjectFile.checkConfig@196(FSharpList`1 configCheckers, FSharpMap`2 config)
   at FSharpLint.Application.ProjectFile.loadConfigForProject(String projectFilePath)
   at FSharpLint.Application.ProjectFile.loadProjectFile$cont@219(String projectFile, FSharpOption`1 userSuppliedFSharpCoreDirectory, Result`1 matchValue, Unit unitVar)
   at FSharpLint.Application.ProjectFile.loadProjectFile(String projectFile, FSharpOption`1 userSuppliedFSharpCoreDirectory)
   at FSharpLint.Application.RunLint.parseProject(ProjectParseInfo projectInformation)
   at FSharpLint.MSBuildIntegration.FSharpLintTask.Execute()
========== Rebuild All: 1 succeeded, 0 failed, 0 skipped ==========

In VS2013 Update 3

D:\temp\ConsoleApplication1\packages\FSharpLint.0.1.6\build\FSharpLint.targets(16,5): warning : Lint failed while analysing D:\temp\ConsoleApplication1\ConsoleApplication1\ConsoleApplication1.fsproj.
Failed with: Could not load type 'Microsoft.FSharp.Compiler.SourceCodeServices.InteractiveChecker' from assembly 'FSharp.Compiler.Service, Version=0.0.76.0, Culture=neutral, PublicKeyToken=null'.
Stack trace:    at FSharpLint.Application.RunLint.parseProject(ProjectParseInfo projectInformation)
   at FSharpLint.MSBuildIntegration.FSharpLintTask.Execute()
========== Rebuild All: 1 succeeded, 0 failed, 0 skipped ==========

The consistent thing is that this is all on a separate logical drive to the system drive.

https://github.com/duckmatt/FSharpLint/blob/master/src/FSharpLint.Rules/XmlDocumentation.fs

Rules off the top of my head to be added:

Module comment
Function (not inside of a binding expression) comment
Member comment
Type comment
Enum case comment
Union case comment
Record field comment

see: http://mascot.x9c.fr/distrib/mascot.html

Currently we have docs for:

• Using the command line tool.
• Using the MSBuild task.

It would be great to also have the usage of the FAKE task documented:

• Using the command line tool.
• Using the MSBuild task.
• Using the FAKE task.

The useless binding rule checks for any values that are then bound to the same name, there are cases where this is not useless i.e. a mutable value is bound to the same name but as immutable. Lint errors for this rule should only occur when an immutable value is bound to the same name as immutable

Currently all that's exposed is a function for linting entire projects, I'm looking to set up a web page to lint F# snippets so this would be required

Now that SuppressMessageAttribute is supported it seems like a good time to set up the projects in the solution to be linted as part of the build process and failing the build if there are any warnings

e.g. fun _ _ _ _ _ _ _ _ -> None will have a depth greater than 8, reason for this is that the lambda is represented as (fun _ -> match _ with | _ -> fun _ -> match _ with | _ -> etc)

Currently FSharpLint.Typography is turned off by default in the config, this is because at the moment it warns far too easily (hundreds of errors for most projects).

What I see that needs to be done:

• MaxCharactersOnLine should be given a higher default than 80, bumping it up to 120 seems reasonable - keeps the code from vertical scroll in most windows.
• TrailingWhitespaceOnLine needs to be either given a config setting to allow a certain number of spaces on the end of the line or to allow for a single space at the end of the line for certain statements e.g. fun () -> with the body of the lambda on the next line as that seems to be a reasonable instance for having a space on the end of the line.

In VS2013 Update 3 or 4 with F# Power Tools extension v1.6.1, which links in the later FSharp.Compiler.Service version, installed:

D:\temp\ConsoleApplication1\packages\FSharpLint.0.1.6\build\FSharpLint.targets(16,5): warning : Lint failed while analysing D:\temp\ConsoleApplication1\ConsoleApplication1\ConsoleApplication1.fsproj.
Failed with: Could not load type 'Microsoft.FSharp.Compiler.SourceCodeServices.InteractiveChecker' from assembly 'FSharp.Compiler.Service, Version=0.0.76.0, Culture=neutral, PublicKeyToken=null'.
Stack trace:    at FSharpLint.Application.RunLint.parseProject(ProjectParseInfo projectInformation)
   at FSharpLint.MSBuildIntegration.FSharpLintTask.Execute()
========== Rebuild All: 1 succeeded, 0 failed, 0 skipped ==========

Tests have stopped passing with no changes to the project. Seems to be another issue with the wrong FSharp.Core being picked up (not having .sigdata and .optdata in the same directory), strange as it never required any references before - and a backup of the project i have still passes all the tests but I can't spot a difference between them...

The MSBuild task has an optional argument that let's the user specify the directory of FSharp.Core if the tool is unable to look it up itself. Right now the targets file in the nuget package has no way of letting the user specify that property from their project file - it needs to be possible to specify the directory using an MSBuild property that the targets file will try to pass to the MSBuild task

Error messages should be multi lingual, simplest solution is to put them in a resource file

"Find all uses of global mutable state in all code and referenced DLLs"

Seems like we'll need to inspect the MSIL of the referenced assemblies to find (in c# terms) public static mutable fields, and encapsulated static mutable fields that can be mutated via the public interface

I created a default console application in VS2013u4, and set it to .net 3.5 (full profile), so F# core version 2.3.0.0.
I added F#Lint 1.10.0 through the NuGet UI in Visual Studio.
I then did a rebuild and got

Failed with: Exception of type 'FSharpLint.Framework.Ast+ParseException' was thrown.
Stack trace:    at FSharpLint.Framework.Ast.parseFile(FSharpChecker checker, FSharpProjectOptions projectOptions, String file, String input)
   at FSharpLint.Application.RunLint.parseFile(FSharpFunc`2 finishEarly, Action`1 errorReceived, Action`1 progress, ProjectFile project, FSharpChecker checker, FSharpList`1 plugins, FSharpProjectOptions projectOptions, String file)
   at [email protected](String file)
   at Microsoft.FSharp.Primitives.Basics.List.iter[T](FSharpFunc`2 f, FSharpList`1 x)
   at FSharpLint.Application.RunLint.parseProject(ProjectParseInfo projectInformation)
   at FSharpLint.MSBuildIntegration.FSharpLintTask.Execute()

(this is the simplified repro case of a problem I hit in more complicated circumstances)

Repeating the same steps for VS2010 (which links against core version 2.0.0.0) gives no problem