correct dependency files

Author: dsyme

docs/content/react.fsx

@@ -0,0 +1,74 @@
+(*** hide ***)
+#I "../../bin/v4.5/"
+(**
+Compiler Services: Reacting to Changes
+============================================
+
+This tutorial discusses some technical aspects of how to make sure the F# compiler service is 
+providing up-to-date results especially when hosted in an IDE. See also [project wide analysis](project.html)
+for information on project analysis.
+
+> **NOTE:** The FSharp.Compiler.Service API is subject to change when later versions of the nuget package are published.
+
+The logical results of all "Check" routines (``ParseAndCheckFileInProject``, ``GetBackgroundCheckResultsForFileInProject``, 
+``TryGetRecentTypeCheckResultsForFile``, ``ParseAndCheckProject``) depend on results reported by the file system,
+especially the ``IFileSystem`` implementation described in the tutorial on [project wide analysis](project.html).
+Logically speaking, these results would be different if file system changes occur.  For example,
+referenced DLLs may change on disk, or referenced files may change.
+
+The ``FSharpChecker`` component from FSharp.Compiler.Service does _not_ actively "listen"
+to changes in the file system.  However ``FSharpChecker`` _does_ repeatedly ask for
+time stamps from the file system which it uses to decide if recomputation is needed.
+FCS doesn’t listen for changes directly - for example, it creates no ``FileWatcher`` object (and the
+``IFileSystem`` API has no ability to create such objects).  This is partly for legacy reasons,
+and partly because some hosts forbid the creation of FileWatcher objects.
+
+In most cases the repeated timestamp requests are sufficient. If you don't actively
+listen for changes, then ``FSharpChecker`` will still do _approximately_ 
+the right thing, because it is asking for time stamps repeatedly.  However, some updates on the file system
+(such as a DLL appearing after a build, or the user randomly pasting a file into a folder) 
+may not actively be noticed by ``FSharpChecker`` until some operation happens to ask for a timestamp.
+By issuing fresh requests, you can ensure that FCS actively reassesses the state of play when
+stays up-to-date when changes are observed.
+
+If you want to more actively listen for changes, then you should add watchers for the
+files specified in the ``DependencyFiles`` property of ``FSharpCheckFileResults`` and ``FSharpCheckProjectResults``.
+Here’s what you need to do: 
+
+* When your client notices an CHANGE event on a DependencyFile, it should schedule a refresh call to perform the ParseAndCheckFileInProject (or other operation) again.
+  This will result in fresh FileSystem calls to compute time stamps.
+
+* When your client notices an ADD event on a DependencyFile, it should call ``checker.InvalidateConfiguration`` 
+  for all active projects in which the file occurs. This will result in fresh FileSystem calls to compute time 
+  stamps, and fresh calls to compute whether files exist.
+
+* Generally clients don’t listen for DELETE events on files.  Although it would be logically more consistent 
+  to do so, in practice it’s very irritating for a "project clean" to invalidate all intellisense and 
+  cause lots of red squiggles.  Some source control tools also make a change by removing and adding files, which 
+  is best noticed as a single change event.
+
+
+
+If your host happens to be Visual Studio, then this is one technique you can use:
+* Listeners should be associated with a visual source file buffer
+* Use fragments like this to watch the DependencyFiles:
+
+        // Get the service
+        let vsFileWatch = fls.GetService(typeof<SVsFileChangeEx >) :?> IVsFileChangeEx
+
+        // Watch the Add and Change events
+        let fileChangeFlags = 
+            uint32 (_VSFILECHANGEFLAGS.VSFILECHG_Add ||| 
+                    // _VSFILECHANGEFLAGS.VSFILECHG_Del ||| // don't listen for deletes - if a file (such as a 'Clean'ed project reference) is deleted, just keep using stale info
+                    _VSFILECHANGEFLAGS.VSFILECHG_Time)
+
+        // Advise on file changes...
+        let cookie = Com.ThrowOnFailure1(vsFileWatch.AdviseFileChange(file, fileChangeFlags, changeEvents))
+
+        ...
+        
+        // Unadvise file changes...
+        Com.ThrowOnFailure0(vsFileWatch.UnadviseFileChange(cookie))
+
+
+*)

src/fsharp/CompileOps.fs

@@ -1750,10 +1750,10 @@ type IRawFSharpAssemblyData =
     abstract HasMatchingFSharpSignatureDataAttribute : ILGlobals -> bool
 
 type TimeStampCache() = 
-    let now = DateTime.Now
+    let cacheCreation = DateTime.Now
     let files = Dictionary<string,DateTime>()
     let projects = Dictionary<IProjectReference,DateTime>(HashIdentity.Reference)
-    member x.Now = now
+    member x.CacheCreation = cacheCreation
     member x.Files = files
     member x.Projects = projects
 

src/fsharp/CompileOps.fsi

@@ -169,7 +169,7 @@ type IRawFSharpAssemblyData =
 
 type TimeStampCache = 
     new : unit -> TimeStampCache
-    member Now: DateTime
+    member CacheCreation: DateTime
     member Files: Dictionary<string,DateTime> 
     member Projects:Dictionary<IProjectReference,DateTime>
 

src/fsharp/vs/IncrementalBuild.fs

@@ -1021,6 +1021,7 @@ type TypeCheckAccumulator =
       tcSymbolUses: TcSymbolUses list
       topAttribs:TopAttribs option
       typedImplFiles:TypedImplFile list
+      tcDependencyFiles: string list
       tcErrors:(PhasedError * FSharpErrorSeverity) list } // errors=true, warnings=false
 
 
@@ -1115,6 +1116,7 @@ type PartialCheckResults =
       Errors: (PhasedError * FSharpErrorSeverity) list 
       TcResolutions: TcResolutions list 
       TcSymbolUses: TcSymbolUses list 
+      TcDependencyFiles: string list 
       TopAttribs: TopAttribs option
       TimeStamp: System.DateTime }
 
@@ -1127,6 +1129,7 @@ type PartialCheckResults =
           Errors = tcAcc.tcErrors
           TcResolutions = tcAcc.tcResolutions
           TcSymbolUses = tcAcc.tcSymbolUses
+          TcDependencyFiles = tcAcc.tcDependencyFiles
           TopAttribs = tcAcc.topAttribs
           TimeStamp = timestamp }
 
@@ -1163,21 +1166,22 @@ type IncrementalBuilder(frameworkTcImportsCache: FrameworkImportsCache, tcConfig
         let flags = tcConfig.ComputeCanContainEntryPoint(sourceFiles |> List.map snd)
         (sourceFiles,flags) ||> List.map2 (fun (m,nm) flag -> (m,nm,flag))
 
+    let defaultTimeStamp = DateTime.Now
     let getFileTimeStamp (cache: TimeStampCache) fileName = 
         let ok, v = cache.Files.TryGetValue(fileName)
         if ok then v else 
         let v = 
             if FileSystem.SafeExists(fileName) then
                 FileSystem.GetLastWriteTimeShim(fileName)
             else
-                cache.Now                  
+                defaultTimeStamp            
         cache.Files.[fileName] <- v
         v
 
     let getProjectReferenceTimeStamp (cache: TimeStampCache) (pr: IProjectReference) = 
         let ok, v = cache.Projects.TryGetValue(pr)
         if ok then v else 
-        let v = defaultArg (pr.GetLogicalTimeStamp cache) cache.Now
+        let v = defaultArg (pr.GetLogicalTimeStamp cache) defaultTimeStamp
         cache.Projects.[pr] <- v
         v
 
@@ -1200,6 +1204,23 @@ type IncrementalBuilder(frameworkTcImportsCache: FrameworkImportsCache, tcConfig
           for pr in projectReferences  do
             yield Choice2Of2 pr, (fun cache -> getProjectReferenceTimeStamp cache pr) ]
 
+
+
+    let basicDependencies = 
+        [ for (UnresolvedAssemblyReference(referenceText, _))  in unresolvedReferences do
+            // Exclude things that are definitely not a file name
+            if not(FileSystem.IsInvalidPathShim(referenceText)) then 
+                let file = if FileSystem.IsPathRootedShim(referenceText) then referenceText else Path.Combine(projectDirectory,referenceText) 
+                yield file 
+
+          for r in nonFrameworkResolutions do 
+                yield  r.resolvedPath  ]
+
+    let allDependencies =
+        [ yield! basicDependencies
+          for (_,f,_) in sourceFiles do
+                yield f ]
+
     // The IncrementalBuilder needs to hold up to one item that needs to be disposed, which is the tcImports for the incremental
     // build. 
     let mutable cleanupItem = None: TcImports option
@@ -1303,6 +1324,7 @@ type IncrementalBuilder(frameworkTcImportsCache: FrameworkImportsCache, tcConfig
               tcSymbolUses=[]
               topAttribs=None
               typedImplFiles=[]
+              tcDependencyFiles=basicDependencies
               tcErrors=errorLogger.GetErrors() }   
         tcAcc
 
@@ -1342,7 +1364,8 @@ type IncrementalBuilder(frameworkTcImportsCache: FrameworkImportsCache, tcConfig
                                        typedImplFiles=typedImplFiles
                                        tcResolutions=tcAcc.tcResolutions @ [tcResolutions]
                                        tcSymbolUses=tcAcc.tcSymbolUses @ [tcSymbolUses]
-                                       tcErrors = tcAcc.tcErrors @ parseErrors @ capturingErrorLogger.GetErrors() } 
+                                       tcErrors = tcAcc.tcErrors @ parseErrors @ capturingErrorLogger.GetErrors() 
+                                       tcDependencyFiles = filename :: tcAcc.tcDependencyFiles } 
                 }
 
             // Run part of the Eventually<_> computation until a timeout is reached. If not complete, 
@@ -1509,20 +1532,6 @@ type IncrementalBuilder(frameworkTcImportsCache: FrameworkImportsCache, tcConfig
     // END OF BUILD DESCRIPTION
     // ---------------------------------------------------------------------------------------------            
 
-
-    let fileDependencies = 
-        [ for (UnresolvedAssemblyReference(referenceText, _))  in unresolvedReferences do
-            // Exclude things that are definitely not a file name
-            if not(FileSystem.IsInvalidPathShim(referenceText)) then 
-                let file = if FileSystem.IsPathRootedShim(referenceText) then referenceText else Path.Combine(projectDirectory,referenceText) 
-                yield file 
-
-          for r in nonFrameworkResolutions do 
-                yield  r.resolvedPath 
-
-          for (_,f,_) in sourceFiles do
-                yield f ]
-
     let sourceFileInputs = 
         [ for (a,sourceFile,c) in sourceFiles do
             yield a, sourceFile, c, (fun cache -> getFileTimeStamp cache sourceFile) ]
@@ -1562,7 +1571,7 @@ type IncrementalBuilder(frameworkTcImportsCache: FrameworkImportsCache, tcConfig
     member __.FileChecked = fileChecked.Publish
     member __.ProjectChecked = projectChecked.Publish
     member __.ImportedCcusInvalidated = importsInvalidated.Publish
-    member __.Dependencies = fileDependencies 
+    member __.AllDependenciesDeprecated = allDependencies 
 
 #if EXTENSIONTYPING
     member __.ThereAreLiveTypeProviders = 

src/fsharp/vs/IncrementalBuild.fsi

@@ -73,6 +73,7 @@ type internal PartialCheckResults =
       Errors : (PhasedError * FSharpErrorSeverity) list 
       TcResolutions: TcResolutions list 
       TcSymbolUses: TcSymbolUses list 
+      TcDependencyFiles: string list
       TopAttribs: TypeChecker.TopAttribs option
       TimeStamp: DateTime }
 
@@ -112,7 +113,7 @@ type internal IncrementalBuilder =
       member ImportedCcusInvalidated : IEvent<string>
 
       /// The list of files the build depends on
-      member Dependencies : string list
+      member AllDependenciesDeprecated : string list
 #if EXTENSIONTYPING
       /// Whether there are any 'live' type providers that may need a refresh when a project is Cleaned
       member ThereAreLiveTypeProviders : bool