Listen for file renames

src/OmniSharp.Abstractions/FileWatching/IFileSystemWatcher.cs

@@ -1,12 +1,20 @@
 using System;
+using OmniSharp.Models.FilesChanged;
 
 namespace OmniSharp.FileWatching
 {
     // TODO: Flesh out this API more
     public interface IFileSystemWatcher
     {
-        void Watch(string path, Action<string> callback);
+        void Watch(string path, Action<string, FileChangeType> callback);
 
-        void TriggerChange(string path);
+        /// <summary>
+        /// Called when a file is created, changed, or deleted.
+        /// </summary>
+        /// <param name="path">The path to the file</param>
+        /// <param name="changeType">The type of change. Hosts are not required to pass a change type</param>
+        void TriggerChange(string path, FileChangeType changeType);
+
+        void WatchDirectory(string path, Action<string, FileChangeType> callback);
     }
-}
+}

src/OmniSharp.Abstractions/Models/v1/FilesChanged/FileChangeType.cs

@@ -0,0 +1,10 @@
+namespace OmniSharp.Models.FilesChanged
+{
+    public enum FileChangeType
+    {
+        Unspecified = 0,
+        Change,
+        Create,
+        Delete
+    }
+}

src/OmniSharp.Abstractions/Models/v1/FilesChanged/FilesChangedRequest.cs

@@ -3,6 +3,9 @@
 
 namespace OmniSharp.Models.FilesChanged
 {
-    [OmniSharpEndpoint(OmniSharpEndpoints.FilesChanged, typeof(IEnumerable<Request>), typeof(FilesChangedResponse))]
-    public class FilesChangedRequest : IRequest { }
+    [OmniSharpEndpoint(OmniSharpEndpoints.FilesChanged, typeof(IEnumerable<FilesChangedRequest>), typeof(FilesChangedResponse))]
+    public class FilesChangedRequest : Request
+    {
+        public FileChangeType ChangeType { get; set; }
+    }
 }

src/OmniSharp.DotNet/DotNetProjectSystem.cs

@@ -166,13 +166,13 @@ private void UpdateProject(string projectDirectory)
             _projectStates.Update(projectDirectory, contexts, AddProject, RemoveProject);
 
             var projectFilePath = contexts.First().ProjectFile.ProjectFilePath;
-            _fileSystemWatcher.Watch(projectFilePath, file =>
+            _fileSystemWatcher.Watch(projectFilePath, (file, changeType) =>
             {
                 _logger.LogInformation($"Watcher: {file} updated.");
                 Update(allowRestore: true);
             });
 
-            _fileSystemWatcher.Watch(Path.ChangeExtension(projectFilePath, "lock.json"), file =>
+            _fileSystemWatcher.Watch(Path.ChangeExtension(projectFilePath, "lock.json"), (file, changeType) =>
             {
                 _logger.LogInformation($"Watcher: {file} updated.");
                 Update(allowRestore: false);

src/OmniSharp.Host/FileWatching/ManualFileSystemWatcher.cs

@@ -1,24 +1,44 @@
 using System;
 using System.Collections.Generic;
+using System.IO;
+using OmniSharp.Models.FilesChanged;
 
 namespace OmniSharp.FileWatching
 {
     public class ManualFileSystemWatcher : IFileSystemWatcher
     {
-        private readonly Dictionary<string, Action<string>> _callbacks = new Dictionary<string, Action<string>>();
+        private readonly Dictionary<string, Action<string, FileChangeType>> _callbacks = new Dictionary<string, Action<string, FileChangeType>>();
+        private readonly Dictionary<string, Action<string, FileChangeType>> _directoryCallBacks = new Dictionary<string, Action<string, FileChangeType>>();
 
-        public void TriggerChange(string path)
+        public void TriggerChange(string path, FileChangeType changeType)
         {
-            Action<string> callback;
-            if (_callbacks.TryGetValue(path, out callback))
+            if (_callbacks.TryGetValue(path, out var callback))
             {
-                callback(path);
+                callback(path, changeType);
+            }
+
+            var directoryPath = Path.GetDirectoryName(path);
+            if (_directoryCallBacks.TryGetValue(directoryPath, out var fileCallback))
+            {
+                fileCallback(path, changeType);
             }
         }
 
-        public void Watch(string path, Action<string> callback)
+        public void Watch(string path, Action<string, FileChangeType> callback)
         {
             _callbacks[path] = callback;
         }
+
+        public void WatchDirectory(string path, Action<string, FileChangeType> callback)
+        {
+            if (_directoryCallBacks.TryGetValue(path, out var existingCallback))
+            {
+                _directoryCallBacks[path] = (Action<string, FileChangeType>)Delegate.Combine(callback, existingCallback);
+            }
+            else
+            {
+                _directoryCallBacks[path] = callback;
+            }
+        }
     }
-}
+}

src/OmniSharp.MSBuild/MSBuildHelpers.cs

@@ -87,7 +87,8 @@ public static bool CanInitializeVisualStudioBuildEnvironment()
 
             var mode = GetPropertyValue("Mode", buildEnvironment, s_BuildEnvironmentType, BindingFlags.NonPublic | BindingFlags.Instance);
 
-            return mode?.ToString() == "VisualStudio";
+            // return mode?.ToString() == "VisualStudio";
+            return false;
         }
     }
 }

src/OmniSharp.MSBuild/MSBuildProjectSystem.cs

@@ -12,6 +12,8 @@
 using OmniSharp.Eventing;
 using OmniSharp.FileWatching;
 using OmniSharp.Models.Events;
+using OmniSharp.Models.FilesChanged;
+using OmniSharp.Models.UpdateBuffer;
 using OmniSharp.Models.WorkspaceInformation;
 using OmniSharp.MSBuild.Models;
 using OmniSharp.MSBuild.Models.Events;
@@ -232,14 +234,14 @@ private void WatchProject(ProjectFileInfo project)
         {
             // TODO: This needs some improvement. Currently, it tracks both deletions and changes
             // as "updates". We should properly remove projects that are deleted.
-            _fileSystemWatcher.Watch(project.FilePath, file =>
+            _fileSystemWatcher.Watch(project.FilePath, (file, changeType) =>
             {
                 OnProjectChanged(project.FilePath, allowAutoRestore: true);
             });
 
             if (!string.IsNullOrEmpty(project.ProjectAssetsFile))
             {
-                _fileSystemWatcher.Watch(project.ProjectAssetsFile, file =>
+                _fileSystemWatcher.Watch(project.ProjectAssetsFile, (file, changeType) =>
                 {
                     OnProjectChanged(project.FilePath, allowAutoRestore: false);
                 });
@@ -378,6 +380,8 @@ private void UpdateSourceFiles(Project project, IList<string> sourceFiles)
             // Add source files to the project.
             foreach (var sourceFile in sourceFiles)
             {
+                WatchDirectoryContainingFile(sourceFile);
+
                 // If a document for this source file already exists in the project, carry on.
                 if (currentDocuments.Remove(sourceFile))
                 {
@@ -400,6 +404,31 @@ private void UpdateSourceFiles(Project project, IList<string> sourceFiles)
             }
         }
 
+        private void WatchDirectoryContainingFile(string sourceFile) => _fileSystemWatcher.WatchDirectory(Path.GetDirectoryName(sourceFile), OnDirectoryFileChanged);
+
+        private void OnDirectoryFileChanged(string path, FileChangeType changeType)
+        {
+            // Hosts may not have passed through a file change type
+            if (changeType == FileChangeType.Unspecified && !File.Exists(path) || changeType == FileChangeType.Delete)
+            {
+                foreach (var documentId in _workspace.CurrentSolution.GetDocumentIdsWithFilePath(path))
+                {
+                    _workspace.RemoveDocument(documentId);
+                }
+            }
+
+            if (changeType == FileChangeType.Unspecified && File.Exists(path) || changeType == FileChangeType.Create)
+            {
+                // Only add .cs files to the workspace
+                if (string.Equals(Path.GetExtension(path), ".cs", StringComparison.CurrentCultureIgnoreCase))
+                {
+                    // Use the buffer manager to add the new file to the appropriate projects
+                    // Hosts that don't pass the FileChangeType may wind up updating the buffer twice
+                    _workspace.BufferManager.UpdateBufferAsync(new UpdateBufferRequest() { FileName = path, FromDisk = true }).Wait();
+                }
+            }
+        }
+
         private void UpdateParseOptions(Project project, LanguageVersion languageVersion, IEnumerable<string> preprocessorSymbolNames, bool generateXmlDocumentation)
         {
             var existingParseOptions = (CSharpParseOptions)project.ParseOptions;

src/OmniSharp.Roslyn.CSharp/Services/Files/OnFilesChangedService.cs

@@ -4,13 +4,12 @@
 using Microsoft.CodeAnalysis;
 using OmniSharp.FileWatching;
 using OmniSharp.Mef;
-using OmniSharp.Models;
 using OmniSharp.Models.FilesChanged;
 
 namespace OmniSharp.Roslyn.CSharp.Services.Files
 {
     [OmniSharpHandler(OmniSharpEndpoints.FilesChanged, LanguageNames.CSharp)]
-    public class OnFilesChangedService : IRequestHandler<IEnumerable<Request>, FilesChangedResponse>
+    public class OnFilesChangedService : IRequestHandler<IEnumerable<FilesChangedRequest>, FilesChangedResponse>
     {
         private readonly IFileSystemWatcher _watcher;
 
@@ -20,11 +19,11 @@ public OnFilesChangedService(IFileSystemWatcher watcher)
             _watcher = watcher;
         }
 
-        public Task<FilesChangedResponse> Handle(IEnumerable<Request> requests)
+        public Task<FilesChangedResponse> Handle(IEnumerable<FilesChangedRequest> requests)
         {
             foreach (var request in requests)
             {
-                _watcher.TriggerChange(request.FileName);
+                _watcher.TriggerChange(request.FileName, request.ChangeType);
             }
             return Task.FromResult(new FilesChangedResponse());
         }