do Trace.TraceInformation("{0:n3} (start) UnusedDeclarationsAnalyzer", DateTime.Now.TimeOfDay.TotalSeconds)

do! Async.Sleep DefaultTuning.UnusedDeclarationsAnalyzerInitialDelay|> liftAsync// be less intrusive, give other work priority most of the time

match getProjectInfoManager(document).TryGetOptionsForEditingDocumentOrProject(document)with

|Some(_parsingOptions, projectOptions)->

match! getProjectInfoManager(document).TryGetOptionsForEditingDocumentOrProject(document)with

|(_parsingOptions, projectOptions)->

let!sourceText= document.GetTextAsync()

letchecker= getChecker document

let!_,_,checkResults= checker.ParseAndCheckDocument(document, projectOptions, sourceText= sourceText, userOpName= userOpName)

unusedRanges

|> Seq.map(fun m-> Diagnostic.Create(Descriptor, RoslynHelpers.RangeToLocation(m, sourceText, document.FilePath)))

|> Seq.toImmutableArray

| None->return ImmutableArray.Empty

|> Async.map(Option.defaultValue ImmutableArray.Empty)

|> RoslynHelpers.StartAsyncAsTask cancellationToken

let!sourceText= document.GetTextAsync(cancellationToken)|> Async.AwaitTask

let!options= document.GetOptionsAsync(cancellationToken)|> Async.AwaitTask

letindentStyle= options.GetOption(FormattingOptions.SmartIndent, FSharpConstants.FSharpLanguageName)

letprojectOptionsOpt= projectInfoManager.TryGetOptionsForEditingDocumentOrProject document

let!projectOptionsOpt= projectInfoManager.TryGetOptionsForEditingDocumentOrProject document

let!textChange= FSharpEditorFormattingService.GetFormattingChanges(document.Id, sourceText, document.FilePath, checkerProvider.Checker, indentStyle, projectOptionsOpt, position)

return textChange|> Option.toList|> toIList

let!options= document.GetOptionsAsync(cancellationToken)|> Async.AwaitTask

lettabSize= options.GetOption<int>(FormattingOptions.TabSize, FSharpConstants.FSharpLanguageName)

match projectInfoManager.TryGetOptionsForEditingDocumentOrProject documentwith

match! projectInfoManager.TryGetOptionsForEditingDocumentOrProject documentwith

| Some(parsingOptions,_)->

let!textChanges= FSharpEditorFormattingService.GetPasteChanges(document.Id, sourceText, document.FilePath, settings.Formatting, tabSize, parsingOptions, currentClipboard, span)

return textChanges|> Option.defaultValue Seq.empty|> toIList

let!options= document.GetOptionsAsync(cancellationToken)|> Async.AwaitTask

lettabSize= options.GetOption<int>(FormattingOptions.TabSize, FSharpConstants.FSharpLanguageName)

letindentStyle= options.GetOption(FormattingOptions.SmartIndent, FSharpConstants.FSharpLanguageName)

letprojectOptionsOpt= projectInfoManager.TryGetOptionsForEditingDocumentOrProject document

let!projectOptionsOpt= projectInfoManager.TryGetOptionsForEditingDocumentOrProject document

letindent= FSharpIndentationService.GetDesiredIndentation(document.Id, sourceText, document.FilePath, lineNumber, tabSize, indentStyle, projectOptionsOpt)

match indentwith

lethier= workspace.GetHierarchy(project.Id)

match projectOptionsTablewith

| Some(options)-> options.GetCommandLineOptionsWithProjectId(projectId)

| None->[||],[||],[||]

new IProvideProjectSitewith

letfst(a,_,_)= a

letsnd(_,b,_)= b

letreporter= ProjectExternalErrorReporter(project.Id,"FS", serviceProvider)

Some(reporter:> IVsLanguageServiceBuildErrorReporter2)

new IProjectSitewith

member__.Description= project.Name

member__.CompilationSourceFiles= getCommandLineOptionsWithProjectId(project.Id)|> fst

let_,references,options= getCommandLineOptionsWithProjectId(project.Id)

Array.concat[options; references|> Array.map(fun r->"-r:"+ r)]

member__.CompilationReferences= getCommandLineOptionsWithProjectId(project.Id)|> snd

membersite.CompilationBinOutputPath= site.CompilationOptions|> Array.tryPick(fun s->if s.StartsWith("-o:")then Some s.[3..]else None)

member__.ProjectFileName= project.FilePath

member__.ProjectGuid= project.Id.Id.ToString()

member__.LoadTime= System.DateTime.Now

member__.ProjectProvider= Some(x)

member__.BuildErrorReporterwith get()= errorReporterandset(v)= errorReporter<- v

interface IVsHierarchywith

member__.SetSite(psp)= hier.SetSite(psp)

member__.GetSite(psp)= hier.GetSite(ref psp)

member__.QueryClose(pfCanClose)= hier.QueryClose(ref pfCanClose)

member__.Close()= hier.Close()

member__.GetGuidProperty(itemid,propid,pguid)= hier.GetGuidProperty(itemid, propid, ref pguid)

member__.SetGuidProperty(itemid,propid,rguid)= hier.SetGuidProperty(itemid, propid, ref rguid)

member__.GetProperty(itemid,propid,pvar)= hier.GetProperty(itemid, propid, ref pvar)

member__.SetProperty(itemid,propid,var)= hier.SetProperty(itemid, propid, var)

hier.GetNestedHierarchy(itemid, ref iidHierarchyNested, ref ppHierarchyNested, ref pitemidNested)

member__.GetCanonicalName(itemid,pbstrName)= hier.GetCanonicalName(itemid, ref pbstrName)

member__.ParseCanonicalName(pszName,pitemid)= hier.ParseCanonicalName(pszName, ref pitemid)

member__.Unused0()= hier.Unused0()

member__.AdviseHierarchyEvents(pEventSink,pdwCookie)= hier.AdviseHierarchyEvents(pEventSink, ref pdwCookie)

member__.UnadviseHierarchyEvents(dwCookie)= hier.UnadviseHierarchyEvents(dwCookie)

member__.Unused1()= hier.Unused1()

member__.Unused2()= hier.Unused2()

member__.Unused3()= hier.Unused3()

member__.Unused4()= hier.Unused4()

| TryGetOptionsofProject*AsyncReplyChannel<(FSharpParsingOptions*FSharpProjectOptions)option>

| ClearOptionsofProjectId

letcancellationTokenSource=new CancellationTokenSource()

letcache= Dictionary<ProjectId, VersionStamp* FSharpParsingOptions* FSharpProjectOptions>()

letprojectId= project.Id

letprojectStamp= project.Version

match cache.TryGetValue(projectId)with

if settings.LanguageServicePerformance.EnableInMemoryCrossProjectReferencesthen

project.ProjectReferences

|> Seq.choose(fun projectReference->

letreferenceProject= project.Solution.GetProject(projectReference.ProjectId)

tryComputeOptions referenceProject

|> Option.map(fun(_,projectOptions)->

(referenceProject.OutputFilePath, projectOptions)

|> Seq.toArray

lethier= workspace.GetHierarchy(projectId)

match hierwith

|(:? IProvideProjectSiteas provideSite)-> provideSite.GetProjectSite()

letprovideSite= mapProjectToSite(workspace, project, serviceProvider, Some(optionsTable))

provideSite.GetProjectSite()

ProjectFileName= projectSite.ProjectFileName

ProjectId= None

SourceFiles= projectSite.CompilationSourceFiles

OtherOptions= projectSite.CompilationOptions

ReferencedProjects= referencedProjects

IsIncompleteTypeCheckEnvironment= projectSite.IsIncompleteTypeCheckEnvironment

UseScriptResolutionRules= SourceFile.MustBeSingleFileProject(Path.GetFileName(project.FilePath))

LoadTime= projectSite.LoadTime

UnresolvedReferences= None

OriginalLoadReferences=[]

ExtraProjectInfo= None

Stamp= Some(int64<| projectStamp.GetHashCode())

if Array.isEmpty projectOptions.SourceFilesthen

None

checkerProvider.Checker.InvalidateConfiguration(projectOptions, startBackgroundCompileIfAlreadySeen=true, userOpName="computeOptions")

letparsingOptions,_= checkerProvider.Checker.GetParsingOptionsFromProjectOptions(projectOptions)

cache.[projectId]<-(projectStamp, parsingOptions, projectOptions)

Some(parsingOptions, projectOptions)

|true,(projectStamp2, parsingOptions, projectOptions)->

if projectStamp<> projectStamp2then

cache.Remove(projectId)|> ignore

tryComputeOptions project

Some(parsingOptions, projectOptions)

match! agent.Receive()with

| FSharpProjectOptionsMessage.TryGetOptions(project, reply)->

reply.Reply(tryComputeOptions project)

| FSharpProjectOptionsMessage.ClearOptions(projectId)->

cache.Remove(projectId)|> ignore

letagent= MailboxProcessor.Start((fun agent-> loop agent), cancellationToken= cancellationTokenSource.Token)

agent.PostAndAsyncReply(fun reply-> FSharpProjectOptionsMessage.TryGetOptions(project, reply))

agent.Post(FSharpProjectOptionsMessage.ClearOptions(projectId))

interface IDisposablewith

cancellationTokenSource.Cancel()

cancellationTokenSource.Dispose()

(agent:> IDisposable).Dispose()

letprojectOptionsTable= FSharpProjectOptionsTable()

letreactor=new FSharpProjectOptionsReactor(workspace, settings, projectOptionsTable, serviceProvider, checkerProvider)

letsingleFileProjectTable= ConcurrentDictionary<ProjectId, DateTime* FSharpParsingOptions* FSharpProjectOptions>()

member__.FSharpOptions= projectOptionsTable

memberthis.ClearInfoForProject(projectId:ProjectId)= projectOptionsTable.ClearInfoForProject(projectId)

projectOptionsTable.ClearInfoForProject(projectId)

reactor.ClearOptionsByProjectId(projectId)

Assert.Exception(ex)

return None

match this.TryGetOptionsForProject(projectId)with

| Some(parsingOptions, site, projectOptions)->

{ projectOptionswith

ReferencedProjects=

document.Project.ProjectReferences

|> Seq.choose(fun projectReference->

letreferenceProject= document.Project.Solution.GetProject(projectReference.ProjectId)

match this.TryGetOptionsForProject(projectReference.ProjectId)with

| Some(_,_, referenceProjectOptions)-> Some(referenceProject.OutputFilePath, referenceProjectOptions)

|_-> None

|> Seq.toArray

return Some(parsingOptions, site, projectOptions)

|_->return None

match! reactor.TryGetOptionsByProjectAsync(document.Project)with

| Some(parsingOptions, projectOptions)->

return Some(parsingOptions, None, projectOptions)

return None

letprojectId= document.Project.Id

match singleFileProjectTable.TryGetValue(projectId)with

|true,(_loadTime, parsingOptions, originalOptions)-> Some(parsingOptions, originalOptions)

|_-> this.TryGetOptionsForProject(projectId)|> Option.map(fun(parsingOptions,_,projectOptions)-> parsingOptions, projectOptions)

|true,(_loadTime, parsingOptions, originalOptions)->async{return Some(parsingOptions, originalOptions)}

let!result= this.TryGetOptionsForDocumentOrProject(document)

return result|> Option.map(fun(parsingOptions,_,projectOptions)-> parsingOptions, projectOptions)

memberthis.ProvideProjectSiteProvider(project:Project)= provideProjectSiteProvider(workspace, project, serviceProvider, Some projectOptionsTable)

letreferencePaths= references|> Seq.map(fun r-> fullPath r.Reference)|> Seq.toArray

projectOptionsTable.SetOptionsWithProjectId(projectId, sourcePaths, referencePaths, options.ToArray())

this.UpdateProjectInfoWithProjectId(projectId,"HandleCommandLineChanges", invalidateConfig=true, solution=workspace.CurrentSolution)

member__.Checker= checkerProvider.Checker