Apply more automatic code formatting (#13110)

* adjust settings

* adjust settings

* adjust settings

* adjust settings

* adjust settings

* adjust settings

* apply formatting

Author: dsyme

.fantomasignore

@@ -26,3 +26,8 @@
 **/Query.fsi
 **/resumable.fsi
 **/async.fsi
+
+## https://github.com/fsprojects/fantomas/issues/2230
+**/array.fsi
+**/tasks.fsi
+**/seq.fsi

DEVGUIDE.md

@@ -147,6 +147,22 @@ Linux/macOS:
 export TEST_UPDATE_BSL=1
 ```
 
+## Automated Source Code Formatting
+
+Some of the code in this repository is formatted automatically by [Fantomas](https://github.com/fsprojects/fantomas). To format all files use:
+
+```cmd
+dotnet fantomas src/fsharp -r
+```
+
+The formatting is checked automatically by CI:
+
+```cmd
+dotnet fantomas src/fsharp -r --check
+```
+
+At the time of writing only a subset of signature files (`*.fsi`) are formatted. See the settings in `.fantomasignore` and `.editorconfig`.
+
 ## Developing the F# tools for Visual Studio
 
 As you would expect, doing this requires both Windows and Visual Studio are installed.
@@ -191,6 +207,20 @@ To fix this, delete these folders:
 
 Where `<version>` corresponds to the latest Visual Studio version on your machine.
 
+## Coding conventions
+
+* Coding conventions vary from file to file
+
+* Format using [the F# style guide](https://docs.microsoft.com/en-us/dotnet/fsharp/style-guide/)
+
+* Avoid tick identifiers like `body'`. They are generally harder to read and can't be inspected in the debugger as things stand. Generaly use R suffix instead, e.g. `bodyR`. The R can stand for "rewritten" or "result"
+
+* Avoid abbreviations like `bodyty` that run together lowercase are bad, really hard to head for newcomers. Use `bodyTy` instead.
+
+* See the comiler docs for common abbreviations
+
+* Don't use `List.iter` and `Array.iter` in the compiler, a `for ... do ...` loop is simpler to read and debug
+
 ## Performance and debugging
 
 Use the `Debug` configuration to test your changes locally. It is the default. Do not use the `Release` configuration! Local development and testing of Visual Studio tooling is not designed for the `Release` configuration.

azure-pipelines.yml

@@ -285,10 +285,10 @@ stages:
             env:
               DOTNET_ROLL_FORWARD_TO_PRERELEASE: 1
             displayName: Install tools
-          - script: dotnet fantomas src/fsharp --check
+          - script: dotnet fantomas src/fsharp -r --check
             env:
               DOTNET_ROLL_FORWARD_TO_PRERELEASE: 1
-            displayName: Check code formatting (run dotnet fantomas src/fsharp to fix)
+            displayName: Check code formatting (run 'dotnet fantomas src/fsharp -r' to fix)
 
         # Linux
         - job: Linux

src/fsharp/CheckExpressions.fs

@@ -1865,7 +1865,8 @@ let FreshenTyconRef (g: TcGlobals) m rigid (tcref: TyconRef) declaredTyconTypars
     let origTypars = declaredTyconTypars
     let freshTypars = copyTypars origTypars
     if rigid <> TyparRigidity.Rigid then
-        freshTypars |> List.iter (fun tp -> tp.SetRigidity rigid)
+        for tp in freshTypars do
+            tp.SetRigidity rigid
 
     let renaming, tinst = FixupNewTypars m [] [] origTypars freshTypars
     let origTy = TType_app(tcref, List.map mkTyparTy origTypars, g.knownWithoutNull)

src/fsharp/DependencyManager/DependencyProvider.fsi

@@ -13,10 +13,10 @@ type IResolveDependenciesResult =
     abstract Success: bool
 
     /// The resolution output log
-    abstract StdOut: string[]
+    abstract StdOut: string []
 
     /// The resolution error log (process stderr)
-    abstract StdError: string[]
+    abstract StdError: string []
 
     /// The resolution paths - the full paths to selected resolved dll's.
     /// In scripts this is equivalent to #r @"c:\somepath\to\packages\ResolvedPackage\1.1.1\lib\netstandard2.0\ResolvedAssembly.dll"
@@ -51,10 +51,19 @@ type IDependencyManagerProvider =
     abstract Key: string
 
     /// The help messages for this dependency manager inster
-    abstract HelpMessages: string[]
+    abstract HelpMessages: string []
 
     /// Resolve the dependencies, for the given set of arguments, go find the .dll references, scripts and additional include values.
-    abstract ResolveDependencies: scriptDir: string * mainScriptName: string * scriptName: string * scriptExt: string * packageManagerTextLines: (string * string) seq * tfm: string * rid: string * timeout: int -> IResolveDependenciesResult
+    abstract ResolveDependencies:
+        scriptDir: string *
+        mainScriptName: string *
+        scriptName: string *
+        scriptExt: string *
+        packageManagerTextLines: (string * string) seq *
+        tfm: string *
+        rid: string *
+        timeout: int ->
+            IResolveDependenciesResult
 
 /// Todo describe this API
 [<RequireQualifiedAccess>]
@@ -66,7 +75,7 @@ type ResolvingErrorReport = delegate of ErrorReportType * int * string -> unit
 
 /// Provides DependencyManagement functions.
 ///
-/// The class incrementally collects IDependencyManagerProvider, indexed by key, and 
+/// The class incrementally collects IDependencyManagerProvider, indexed by key, and
 /// queries them.  These are found and instantiated with respect to the compilerTools and outputDir
 /// provided each time the TryFindDependencyManagerByKey and TryFindDependencyManagerInPath are
 /// executed, which are assumed to be invariant over the lifetime of the DependencyProvider.
@@ -83,16 +92,31 @@ type DependencyProvider =
     new: assemblyProbingPaths: AssemblyResolutionProbe * nativeProbingRoots: NativeResolutionProbe -> DependencyProvider
 
     /// Returns a formatted help messages for registered dependencymanagers for the host to present
-    member GetRegisteredDependencyManagerHelpText: string seq * string * ResolvingErrorReport -> string[]
+    member GetRegisteredDependencyManagerHelpText: string seq * string * ResolvingErrorReport -> string []
 
     /// Returns a formatted error message for the host to present
     member CreatePackageManagerUnknownError: string seq * string * string * ResolvingErrorReport -> int * string
 
     /// Resolve reference for a list of package manager lines
-    member Resolve : packageManager: IDependencyManagerProvider * scriptExt: string * packageManagerTextLines: (string * string) seq * reportError: ResolvingErrorReport * executionTfm: string * [<Optional;DefaultParameterValue(null:string MaybeNull)>]executionRid: string  * [<Optional;DefaultParameterValue("")>]implicitIncludeDir: string * [<Optional;DefaultParameterValue("")>]mainScriptName: string * [<Optional;DefaultParameterValue("")>]fileName: string * [<Optional;DefaultParameterValue(-1)>]timeout: int -> IResolveDependenciesResult
+    member Resolve:
+        packageManager: IDependencyManagerProvider *
+        scriptExt: string *
+        packageManagerTextLines: (string * string) seq *
+        reportError: ResolvingErrorReport *
+        executionTfm: string *
+        [<Optional; DefaultParameterValue(null: string MaybeNull)>] executionRid: string *
+        [<Optional; DefaultParameterValue("")>] implicitIncludeDir: string *
+        [<Optional; DefaultParameterValue("")>] mainScriptName: string *
+        [<Optional; DefaultParameterValue("")>] fileName: string *
+        [<Optional; DefaultParameterValue(-1)>] timeout: int ->
+            IResolveDependenciesResult
 
     /// Fetch a dependencymanager that supports a specific key
-    member TryFindDependencyManagerByKey: compilerTools: string seq * outputDir: string * reportError: ResolvingErrorReport * key: string -> IDependencyManagerProvider MaybeNull
+    member TryFindDependencyManagerByKey:
+        compilerTools: string seq * outputDir: string * reportError: ResolvingErrorReport * key: string ->
+            IDependencyManagerProvider MaybeNull
 
     /// TryFindDependencyManagerInPath - given a #r "key:sometext" go and find a DependencyManager that satisfies the key
-    member TryFindDependencyManagerInPath: compilerTools: string seq * outputDir: string * reportError: ResolvingErrorReport * path: string -> string MaybeNull * IDependencyManagerProvider MaybeNull
+    member TryFindDependencyManagerInPath:
+        compilerTools: string seq * outputDir: string * reportError: ResolvingErrorReport * path: string ->
+            string MaybeNull * IDependencyManagerProvider MaybeNull

src/fsharp/DependencyManager/NativeDllResolveHandler.fsi

@@ -13,7 +13,7 @@ type NativeDllResolveHandler =
 
     /// Construct a new NativeDllResolveHandler
     new: nativeProbingRoots: NativeResolutionProbe -> NativeDllResolveHandler
-    
+
     /// Construct a new NativeDllResolveHandler
     internal new: nativeProbingRoots: NativeResolutionProbe option -> NativeDllResolveHandler
 

src/fsharp/FSharp.Core/Linq.fsi

@@ -18,73 +18,74 @@ open Microsoft.FSharp.Quotations
 module LeafExpressionConverter =
     /// <summary>
     /// When used in a quotation, this function indicates a specific conversion
-    /// should be performed when converting the quotation to a LINQ expression. 
+    /// should be performed when converting the quotation to a LINQ expression.
     ///
-    /// This function should not be called directly. 
+    /// This function should not be called directly.
     /// </summary>
     //
-    // NOTE: when an F# expression tree is converted to a Linq expression tree using ToLinqExpression 
+    // NOTE: when an F# expression tree is converted to a Linq expression tree using ToLinqExpression
     // the transformation of <c>LinqExpressionHelper(e)</c> is the same as the transformation of
-    // 'e'. This allows ImplicitExpressionConversionHelper to be used as a marker to satisfy the C# design where 
+    // 'e'. This allows ImplicitExpressionConversionHelper to be used as a marker to satisfy the C# design where
     // certain expression trees are constructed using methods with a signature that expects an
     // expression tree of type <c>Expression<T></c> but are passed an expression tree of type T.
     //[<System.Obsolete("This type is for use by the quotation to LINQ expression tree converter and is not for direct use from user code")>]
     val ImplicitExpressionConversionHelper: 'T -> Expression<'T>
 
     /// <summary>
     /// When used in a quotation, this function indicates a specific conversion
-    /// should be performed when converting the quotation to a LINQ expression. 
+    /// should be performed when converting the quotation to a LINQ expression.
     ///
-    /// This function should not be called directly. 
+    /// This function should not be called directly.
     /// </summary>
     //[<System.Obsolete("This type is for use by the quotation to LINQ expression tree converter and is not for direct use from user code")>]
     val MemberInitializationHelper: 'T -> 'T
 
     /// <summary>
     /// When used in a quotation, this function indicates a specific conversion
-    /// should be performed when converting the quotation to a LINQ expression. 
+    /// should be performed when converting the quotation to a LINQ expression.
     ///
-    /// This function should not be called directly. 
+    /// This function should not be called directly.
     /// </summary>
     //[<System.Obsolete("This type is for use by the quotation to LINQ expression tree converter and is not for direct use from user code")>]
-    val NewAnonymousObjectHelper: 'T ->  'T
+    val NewAnonymousObjectHelper: 'T -> 'T
 
     /// <summary>
     /// Converts a subset of F# quotations to a LINQ expression, for the subset of LINQ expressions represented by the
     /// expression syntax in the C# language.
     /// </summary>
-    /// 
+    ///
     /// <example-tbd></example-tbd>
     val QuotationToExpression: Expr -> Expression
 
     /// <summary>
     /// Converts a subset of F# quotations to a LINQ expression, for the subset of LINQ expressions represented by the
-    /// expression syntax in the C# language. 
+    /// expression syntax in the C# language.
     /// </summary>
-    /// 
+    ///
     /// <example-tbd></example-tbd>
     val QuotationToLambdaExpression: Expr<'T> -> Expression<'T>
 
     /// <summary>
     /// Evaluates a subset of F# quotations by first converting to a LINQ expression, for the subset of LINQ expressions represented by the
     /// expression syntax in the C# language.
     /// </summary>
-    /// 
+    ///
     /// <example-tbd></example-tbd>
     val EvaluateQuotation: Expr -> obj
 
     /// <summary>
     /// A runtime helper used to evaluate nested quotation literals.
     /// </summary>
-    /// 
+    ///
     /// <example-tbd></example-tbd>
-    val SubstHelper: Expr * Var[] * obj[] -> Expr<'T>
+    val SubstHelper: Expr * Var [] * obj [] -> Expr<'T>
 
     /// <summary>
     /// A runtime helper used to evaluate nested quotation literals.
     /// </summary>
-    /// 
+    ///
     /// <example-tbd></example-tbd>
-    val SubstHelperRaw: Expr * Var[] * obj[] -> Expr
+    val SubstHelperRaw: Expr * Var [] * obj [] -> Expr
 
-    val internal (|SpecificCallToMethod|_|): System.RuntimeMethodHandle -> (Expr -> (Expr option * Type list * Expr list) option)
+    val internal (|SpecificCallToMethod|_|):
+        System.RuntimeMethodHandle -> (Expr -> (Expr option * Type list * Expr list) option)