[style] fixed style

Author: MchKosticyn

VSharp.CoverageTool/CoverageTool.fs

@@ -1,13 +1,16 @@
 namespace VSharp.CoverageTool
+
+open System.Collections.Generic
 open System.Diagnostics
 open System.IO
 open System.Reflection
 open System.Runtime.InteropServices
 open Microsoft.FSharp.NativeInterop
+
+open VSharp
 open VSharp.Utils.EnvironmentUtils
 open VSharp.CSharpUtils
 
-open VSharp
 
 #nowarn "9"
 
@@ -21,9 +24,6 @@ module private ExternalCalls =
     [<DllImport("libvsharpCoverage", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)>]
     extern void SetCurrentThreadId(int id)
 
-    let inline castPtr ptr =
-        ptr |> NativePtr.toVoidPtr |> NativePtr.ofVoidPtr
-
 module private Configuration =
 
     let (|Windows|MacOs|Linux|) _ =
@@ -66,39 +66,48 @@ module private Configuration =
         methodToken: string
     }
 
-    let private withCoverageToolConfiguration mainOnly =
-        withConfiguration {
-            coreclrProfiler = "{2800fea6-9667-4b42-a2b6-45dc98e77e9e}"
-            coreclrProfilerPath = $"{Directory.GetCurrentDirectory()}{Path.DirectorySeparatorChar}libvsharpCoverage{libExtension}"
-            coreclrEnableProfiling = enabled
-            instrumentMainOnly = if mainOnly then enabled else ""
-        }
+    let private withCoverageToolConfiguration mainOnly processInfo =
+        let currentDirectory = Directory.GetCurrentDirectory()
+        let configuration =
+            {
+                coreclrProfiler = "{2800fea6-9667-4b42-a2b6-45dc98e77e9e}"
+                coreclrProfilerPath = $"{currentDirectory}{Path.DirectorySeparatorChar}libvsharpCoverage{libExtension}"
+                coreclrEnableProfiling = enabled
+                instrumentMainOnly = if mainOnly then enabled else ""
+            }
+        withConfiguration configuration processInfo
 
     let withMainOnlyCoverageToolConfiguration =
         withCoverageToolConfiguration true
 
     let withAllMethodsCoverageToolConfiguration =
         withCoverageToolConfiguration false
 
-    let withPassiveModeConfiguration (method: MethodBase) resultName =
-        withConfiguration {
-            passiveModeEnable = enabled
-            resultName = resultName
-            assemblyName = method.Module.Assembly.FullName
-            moduleName = method.Module.FullyQualifiedName
-            methodToken = method.MetadataToken.ToString()
-        }
+    let withPassiveModeConfiguration (method : MethodBase) resultName processInfo =
+        let configuration =
+            {
+                passiveModeEnable = enabled
+                resultName = resultName
+                assemblyName = method.Module.Assembly.FullName
+                moduleName = method.Module.FullyQualifiedName
+                methodToken = method.MetadataToken.ToString()
+            }
+        withConfiguration configuration processInfo
 
     let isCoverageToolAttached () = isConfigured<BaseCoverageToolConfiguration> ()
 
 type InteractionCoverageTool() =
     let mutable entryMainWasSet = false
 
+    let castPtr ptr =
+        NativePtr.toVoidPtr ptr |> NativePtr.ofVoidPtr
+
     do
         if Configuration.isCoverageToolAttached () |> not then internalfail "Coverage tool wasn't attached"
 
     member this.GetRawHistory () =
-        if not entryMainWasSet then Prelude.internalfail "Try call GetRawHistory, while entryMain wasn't set"
+        if not entryMainWasSet then
+            Prelude.internalfail "Try call GetRawHistory, while entryMain wasn't set"
         let sizePtr = NativePtr.stackalloc<uint> 1
         let dataPtrPtr = NativePtr.stackalloc<nativeint> 1
 
@@ -111,97 +120,83 @@ type InteractionCoverageTool() =
         Marshal.Copy(dataPtr, data, 0, size)
         data
 
-    member this.SetEntryMain (assembly: Assembly) (moduleName: string) (methodToken: int) =
+    member this.SetEntryMain (assembly : Assembly) (moduleName : string) (methodToken : int) =
         entryMainWasSet <- true
         let assemblyNamePtr = fixed assembly.FullName.ToCharArray()
         let moduleNamePtr = fixed moduleName.ToCharArray()
         let assemblyNameLength = assembly.FullName.Length
         let moduleNameLength = moduleName.Length
 
         ExternalCalls.SetEntryMain(
-            ExternalCalls.castPtr assemblyNamePtr,
+            castPtr assemblyNamePtr,
             assemblyNameLength,
-            ExternalCalls.castPtr moduleNamePtr,
+            castPtr moduleNamePtr,
             moduleNameLength,
             methodToken
         )
 
     member this.SetCurrentThreadId id =
         ExternalCalls.SetCurrentThreadId(id)
 
-    static member WithCoverageTool (procInfo: ProcessStartInfo) =
+    static member WithCoverageTool (procInfo : ProcessStartInfo) =
         Configuration.withMainOnlyCoverageToolConfiguration procInfo
 
 type PassiveCoverageTool(workingDirectory: DirectoryInfo, method: MethodBase) =
 
     let resultName = "coverage.cov"
 
     let getHistory () =
-        workingDirectory.EnumerateFiles(resultName)
-        |> Seq.tryHead
-        |> Option.map (fun x -> File.ReadAllBytes(x.FullName))
-        |> Option.map CoverageDeserializer.getRawReports
-        |> Option.map CoverageDeserializer.reportsFromRawReports
-
-
-    let printCoverage (allBlocks: seq<BasicBlock>) (visited: seq<BasicBlock>) =
+        let coverageFile = workingDirectory.EnumerateFiles(resultName) |> Seq.tryHead
+        match coverageFile with
+        | Some coverageFile ->
+            File.ReadAllBytes(coverageFile.FullName)
+            |> CoverageDeserializer.getRawReports
+            |> CoverageDeserializer.reportsFromRawReports
+            |> Some
+        | None -> None
+
+    let printCoverage (allBlocks: ResizeArray<BasicBlock>) (visited: HashSet<BasicBlock>) =
         Logger.writeLine $"Coverage for method {method.Name}:"
 
-        let hasNonCovered = allBlocks |> Seq.exists (fun b -> Seq.contains b visited |> not)
-
-        if hasNonCovered then
-            allBlocks
-            |> Seq.iter (fun block ->
-                if Seq.contains block visited |> not then
-                    Logger.writeLine $"Block [0x{block.StartOffset:X} .. 0x{block.FinalOffset:X}] not covered"
-            )
-        else
+        let mutable allCovered = true
+        for block in allBlocks do
+            if visited.Contains block |> not then
+                Logger.writeLine $"Block [0x{block.StartOffset:X} .. 0x{block.FinalOffset:X}] not covered"
+                allCovered <- false
+        if allCovered then
             Logger.writeLine "All blocks are covered"
 
-    let computeCoverage (cfg: CfgInfo) (visited: seq<CoverageReport>) =
-        // filtering coverage records that are only relevant to this method
-        let visitedInMethod =
-            visited
-            |> Seq.map (fun x -> x.coverageLocations)
-            |> Seq.concat
-            |> Seq.filter (fun x ->
-                x.methodToken = method.MetadataToken
-                && x.moduleName = method.Module.FullyQualifiedName
-            )
-
-        let visitedBlocks = System.Collections.Generic.HashSet<BasicBlock>()
+    let computeCoverage (cfg: CfgInfo) (visited: CoverageReport[]) =
+        let visitedBlocks = HashSet<BasicBlock>()
 
-        for location in visitedInMethod do
-            let offset = LanguagePrimitives.Int32WithMeasure location.offset
-            let block = cfg.ResolveBasicBlock(offset)
-            if block.FinalOffset = offset then
-                visitedBlocks.Add block |> ignore
+        let token = method.MetadataToken
+        let moduleName = method.Module.FullyQualifiedName
+        for coverageReport in visited do
+            for loc in coverageReport.coverageLocations do
+                // Filtering coverage records that are only relevant to this method
+                if loc.methodToken = token && loc.moduleName = moduleName then
+                    let offset = Offset.from loc.offset
+                    let block = cfg.ResolveBasicBlock offset
+                    if block.FinalOffset = offset then
+                        visitedBlocks.Add block |> ignore
 
         printCoverage cfg.SortedBasicBlocks visitedBlocks
-
         let coveredSize = visitedBlocks |> Seq.sumBy (fun x -> x.BlockSize)
-
         (double coveredSize) / (double cfg.MethodSize) * 100. |> int
 
     member this.RunWithCoverage (args: string) =
-        let procInfo =
-            ProcessStartInfo()
-            |> (fun x ->
-                    x.Arguments <- args
-                    x.FileName <- DotnetExecutablePath.ExecutablePath
-                    x.WorkingDirectory <- workingDirectory.FullName
-                    x
-            )
-            |> Configuration.withMainOnlyCoverageToolConfiguration
-            |> Configuration.withPassiveModeConfiguration method resultName
-
-        let applicationMethod = Application.getMethod(method)
+        let procInfo = ProcessStartInfo()
+        procInfo.Arguments <- args
+        procInfo.FileName <- DotnetExecutablePath.ExecutablePath
+        procInfo.WorkingDirectory <- workingDirectory.FullName
+        Configuration.withMainOnlyCoverageToolConfiguration procInfo
+        Configuration.withPassiveModeConfiguration method resultName procInfo
 
-        if applicationMethod.HasBody |> not then
-            Logger.warning $"CoverageRunner was given a method without body; 100%% coverage assumed"
+        let method = Application.getMethod method
+        if not method.HasBody then
+            Logger.warning "CoverageRunner was given a method without body; 100%% coverage assumed"
             100
         else
-
             let proc = procInfo.StartWithLogging(
                 (fun x -> Logger.info $"{x}"),
                 (fun x -> Logger.error $"{x}")
@@ -213,7 +208,7 @@ type PassiveCoverageTool(workingDirectory: DirectoryInfo, method: MethodBase) =
                 -1
             else
                 match getHistory () with
-                | Some history -> computeCoverage applicationMethod.CFG history
+                | Some history -> computeCoverage method.CFG history
                 | None ->
-                    Logger.error $"Failed to retrieve coverage locations"
+                    Logger.error "Failed to retrieve coverage locations"
                     -1

VSharp.Fuzzer/Interaction.fs

@@ -9,7 +9,6 @@ open System.Threading.Tasks
 open VSharp
 open VSharp.CSharpUtils
 open VSharp.Fuzzer.Communication
-open Logger
 open VSharp.Fuzzer.Communication.Contracts
 open VSharp.Fuzzer.Communication.Services
 open VSharp.Fuzzer.Startup
@@ -76,7 +75,7 @@ type private TestRestorer (fuzzerOptions, assemblyPath, outputDirectory) =
             | Some test ->
                 let testPath = $"{outputDirectory}{Path.DirectorySeparatorChar}fuzzer_error_{errorTestIdGenerator.NextId()}.vst"
                 test.Serialize(testPath)
-            | None _ -> error "Failed to create test while restoring"
+            | None -> Logger.error "Failed to create test while restoring"
 
         | None -> internalfail "Unexpected generic solving fail"
 
@@ -98,9 +97,8 @@ type private FuzzingProcess(outputPath, targetAssemblyPath, fuzzerOptions, fuzze
     let mutable state = NotStarted
     let mutable lastRequestTime = Unchecked.defaultof<DateTime>
 
-
     let unhandledExceptionPath = $"{outputPath}{Path.DirectorySeparatorChar}exception.info"
-    let logFuzzingProcess msg = traceCommunication $"[FuzzingProcess] {msg}"
+    let logFuzzingProcess msg = Logger.traceCommunication $"[FuzzingProcess] {msg}"
 
     let fuzzerStarted () = fuzzerProcess <> null
     let fuzzerAlive () = fuzzerStarted () && (not fuzzerProcess.HasExited)

VSharp.Fuzzer/Startup.fs

@@ -45,7 +45,6 @@ let internal waitDebuggerAttached () =
     if value = "1" then
         while not Diagnostics.Debugger.IsAttached do ()
 
-
 let internal startFuzzer options developerOptions =
     let info = Diagnostics.ProcessStartInfo()
     info.WorkingDirectory <- IO.Directory.GetCurrentDirectory()
@@ -65,7 +64,7 @@ let internal startFuzzer options developerOptions =
     if developerOptions.redirectStdout then
         info.RedirectStandardOutput <- true
 
-    let info = InteractionCoverageTool.WithCoverageTool info
+    InteractionCoverageTool.WithCoverageTool info
     let proc = System.Diagnostics.Process.Start info
 
     let stderrTag = "Fuzzer STDERR"
@@ -80,10 +79,11 @@ let internal startFuzzer options developerOptions =
         proc.OutputDataReceived.Add (fun x -> Logger.infoWithTag stdoutTag $"{x.Data}")
         proc.BeginOutputReadLine ()
 
-    if
+    let waitDebugger =
         developerOptions.waitDebuggerAttachedFuzzer
         || developerOptions.waitDebuggerAttachedCoverageTool
-        || developerOptions.waitDebuggerAttachedOnAssertCoverageTool then
+        || developerOptions.waitDebuggerAttachedOnAssertCoverageTool
+    if waitDebugger then
         Logger.warning $"One of \"Wait debugger\" options is enabled, you may attach to process by pid {proc.Id}"
 
     if proc.HasExited then

VSharp.Fuzzer/Utils.fs

@@ -6,7 +6,7 @@ open System.Runtime.InteropServices
 let inline isNull value = obj.ReferenceEquals(value, null)
 let inline failIfNull value message = if isNull value then VSharp.Prelude.internalfail message
 
-type IdGenerator(initValue: int) =
+type IdGenerator(initValue : int) =
     let mutable currentValue = initValue
     member this.NextId() =
         currentValue <- currentValue + 1

VSharp.IL/CFG.fs

@@ -210,7 +210,7 @@ and CfgInfo internal (method : MethodWithBody) =
                     addEdge srcBasicBlock newBasicBlock
                     dfs' newBasicBlock dst k
 
-                let processCall (callee: MethodWithBody) callFrom returnTo k =
+                let processCall (callee : MethodWithBody) callFrom returnTo k =
                     calls.Add(currentBasicBlock, CallInfo(callee :?> Method, callFrom, returnTo))
                     currentBasicBlock.FinalOffset <- callFrom
                     let newBasicBlock = makeNewBasicBlock returnTo
@@ -497,31 +497,31 @@ type ApplicationGraph() =
     let getShortestDistancesToGoals (states : array<codeLocation>) =
         __notImplemented__()
 
-    member this.RegisterMethod (method: Method) =
+    member this.RegisterMethod (method : Method) =
         assert method.HasBody
 
     member this.AddCallEdge (sourceLocation : codeLocation) (targetLocation : codeLocation) =
         addCallEdge sourceLocation targetLocation
 
-    member this.SpawnState (state:IGraphTrackableState) =
-        [|state|] |> addStates None
+    member this.SpawnState (state : IGraphTrackableState) =
+        [| state |] |> addStates None
 
-    member this.SpawnStates (states:seq<IGraphTrackableState>) =
+    member this.SpawnStates (states : seq<IGraphTrackableState>) =
         Array.ofSeq states |> addStates None
 
-    member this.AddForkedStates (parentState:IGraphTrackableState) (forkedStates:seq<IGraphTrackableState>) =
+    member this.AddForkedStates (parentState : IGraphTrackableState) (forkedStates : seq<IGraphTrackableState>) =
         addStates (Some parentState) (Array.ofSeq forkedStates)
 
     member this.MoveState (fromLocation : codeLocation) (toLocation : IGraphTrackableState) =
         moveState fromLocation toLocation
 
-    member x.AddGoal (location:codeLocation) =
+    member x.AddGoal (location : codeLocation) =
         ()
 
-    member x.AddGoals (locations:array<codeLocation>) =
+    member x.AddGoals (locations : array<codeLocation>) =
         ()
 
-    member x.RemoveGoal (location:codeLocation) =
+    member x.RemoveGoal (location : codeLocation) =
         ()
 
 type IVisualizer =

VSharp.SILI.Core/Terms.fs

@@ -50,7 +50,7 @@ type stackKey =
             | TemporaryLocalVariableKey (typ, index) -> $"temporary##%s{Reflection.getFullTypeName typ}%d{index}"
         fullname.GetDeterministicHashCode()
     interface IComparable with
-        override x.CompareTo(other: obj) =
+        override x.CompareTo(other : obj) =
             match other with
             | :? stackKey as other ->
                 match x, other with

VSharp.SILI.Core/TypeSolver.fs

@@ -271,15 +271,15 @@ module TypeSolver =
 
     let private typeParameterCandidates makeGenericCandidates =
         let getMock _ = EmptyTypeMock() :> ITypeMock
-        let validate (t: Type) =
+        let validate (t : Type) =
             if t.IsGenericTypeDefinition then
                 makeGenericCandidates t |> Option.map GenericCandidate
             else Candidate t |> Some
         let assemblies = getAssemblies()
         enumerateTypes List.empty getMock validate assemblies
 
     let private typeParameterGroundCandidates getMock subst (parameter : Type, constraints : typeConstraints) =
-        let validate (typ: Type) =
+        let validate (typ : Type) =
             if not typ.IsGenericTypeDefinition && GroundUtils.satisfiesTypeParameterConstraints parameter subst typ then
                 Candidate typ |> Some
             else None
@@ -303,7 +303,7 @@ module TypeSolver =
             makeGenericCandidate
             childDepth
 
-    let private makeGenericCandidate (typedef: Type) depth =
+    let private makeGenericCandidate (typedef : Type) depth =
         let childDepth _ _ _ = Int32.MaxValue
         genericCandidate.TryCreate typedef depth (makeParameterSubstitutions childDepth)