Merge branch 'master' into feature/OmniSharpGH-1205

CHANGELOG.md

@@ -3,6 +3,7 @@ All changes to the project will be documented in this file.
 
 ## [1.32.0] - _Not Yet Released_
 * Added new `/codestructure` endpoint which serves a replacement for the `/currentfilemembersastree` endpoint. The new endpoint has a cleaner design, properly supports all C# types and members, and supports more information, such as accessibility, static vs. instance, etc. (PR: [#1211](https://github.com/OmniSharp/omnisharp-roslyn/pull/1211))
+* Fixed a bug where language services for newly created CSX files were not provided if no CSX files existed at the moment OmniSharp was started ([#1199](https://github.com/OmniSharp/omnisharp-roslyn/issues/1199), PR: [#1210](https://github.com/OmniSharp/omnisharp-roslyn/pull/1210))
 * The legacy project.json support is now disabled by default, allowing OmniSharp to start up a bit faster for common scenarios. If you wish to enable project.json support, add the following setting to your `omnisharp.json` file. (PR: [#1194](https://github.com/OmniSharp/omnisharp-roslyn/pull/1194))
 
     ```JSON

src/OmniSharp.Script/ScriptContext.cs

@@ -0,0 +1,25 @@
+using System.Collections.Generic;
+using Dotnet.Script.DependencyModel.Compilation;
+using Microsoft.CodeAnalysis;
+
+namespace OmniSharp.Script
+{
+    public class ScriptContext
+    {
+        public ScriptContext(ScriptProjectProvider scriptProjectProvider, HashSet<MetadataReference> metadataReferences, HashSet<string> assemblyReferences, CompilationDependency[] compilationDependencies)
+        {
+            ScriptProjectProvider = scriptProjectProvider;
+            MetadataReferences = metadataReferences;
+            AssemblyReferences = assemblyReferences;
+            CompilationDependencies = compilationDependencies;
+        }
+
+        public ScriptProjectProvider ScriptProjectProvider { get; }
+
+        public HashSet<MetadataReference> MetadataReferences { get; }
+
+        public HashSet<string> AssemblyReferences { get; }
+
+        public CompilationDependency[] CompilationDependencies { get; }
+    }
+}

src/OmniSharp.Script/ScriptContextModel.cs

@@ -10,7 +10,7 @@ public ScriptContextModel(string csxPath, ProjectInfo project, HashSet<string> i
         {
             Path = csxPath;
             ImplicitAssemblyReferences = implicitAssemblyReferences;
-            CommonUsings = ScriptHelper.DefaultNamespaces;
+            CommonUsings = ScriptProjectProvider.DefaultNamespaces;
             GlobalsType = project.HostObjectType;
         }
 
@@ -22,4 +22,4 @@ public ScriptContextModel(string csxPath, ProjectInfo project, HashSet<string> i
 
         public IEnumerable<string> CommonUsings { get; }
     }
-}
+}

src/OmniSharp.Script/ScriptContextProvider.cs

@@ -0,0 +1,175 @@
+using System;
+using System.Collections.Generic;
+using System.Composition;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using Dotnet.Script.DependencyModel.Compilation;
+using Microsoft.CodeAnalysis;
+using Microsoft.Extensions.Logging;
+using OmniSharp.Roslyn.Utilities;
+using OmniSharp.Services;
+using LogLevel = Dotnet.Script.DependencyModel.Logging.LogLevel;
+
+namespace OmniSharp.Script
+{
+    [Export, Shared]
+    public class ScriptContextProvider
+    {
+        private readonly ILoggerFactory _loggerFactory;
+        private readonly CompilationDependencyResolver _compilationDependencyResolver;
+        private readonly IOmniSharpEnvironment _env;
+        private readonly MetadataFileReferenceCache _metadataFileReferenceCache;
+        private readonly ILogger _logger;
+
+        [ImportingConstructor]
+        public ScriptContextProvider(ILoggerFactory loggerFactory, IOmniSharpEnvironment env, MetadataFileReferenceCache metadataFileReferenceCache)
+        {
+            _loggerFactory = loggerFactory;
+            _env = env;
+            _metadataFileReferenceCache = metadataFileReferenceCache;
+            _logger = loggerFactory.CreateLogger<ScriptContextProvider>();
+            _compilationDependencyResolver = new CompilationDependencyResolver(type =>
+            {
+                // Prefix with "OmniSharp" so that we make it through the log filter.
+                var categoryName = $"OmniSharp.Script.{type.FullName}";
+                var dependencyResolverLogger = loggerFactory.CreateLogger(categoryName);
+                return ((level, message) =>
+                {
+                    if (level == LogLevel.Debug)
+                    {
+                        dependencyResolverLogger.LogDebug(message);
+                    }
+                    if (level == LogLevel.Info)
+                    {
+                        dependencyResolverLogger.LogInformation(message);
+                    }
+                });
+            });
+        }
+
+        public ScriptContext CreateScriptContext(ScriptOptions scriptOptions)
+        {
+            var currentDomainAssemblies = AppDomain.CurrentDomain.GetAssemblies();
+
+            // explicitly inherit scripting library references to all global script object (CommandLineScriptGlobals) to be recognized
+            var inheritedCompileLibraries = currentDomainAssemblies.Where(x =>
+                x.FullName.StartsWith("microsoft.codeanalysis", StringComparison.OrdinalIgnoreCase)).ToList();
+
+            // explicitly include System.ValueTuple
+            inheritedCompileLibraries.AddRange(currentDomainAssemblies.Where(x =>
+                x.FullName.StartsWith("system.valuetuple", StringComparison.OrdinalIgnoreCase)));
+
+            CompilationDependency[] compilationDependencies = null;
+            try
+            {
+                _logger.LogInformation($"Searching for compilation dependencies with the fallback framework of '{scriptOptions.DefaultTargetFramework}'.");
+                compilationDependencies = _compilationDependencyResolver.GetDependencies(_env.TargetDirectory, scriptOptions.IsNugetEnabled(), scriptOptions.DefaultTargetFramework).ToArray();
+            }
+            catch (Exception e)
+            {
+                _logger.LogError("Failed to resolve compilation dependencies", e);
+                compilationDependencies = Array.Empty<CompilationDependency>();
+            }
+
+            var metadataReferences = new HashSet<MetadataReference>(MetadataReferenceEqualityComparer.Instance);
+            var assemblyReferences = new HashSet<string>();
+
+            var isDesktopClr = true;
+            // if we have no compilation dependencies
+            // we will assume desktop framework
+            // and add default CLR references
+            // same applies for having a context that is not a .NET Core app
+            if (!compilationDependencies.Any())
+            {
+                _logger.LogInformation("Unable to find dependency context for CSX files. Will default to non-context usage (Desktop CLR scripts).");
+                AddDefaultClrMetadataReferences(metadataReferences, assemblyReferences);
+            }
+            else
+            {
+                isDesktopClr = false;
+                HashSet<string> loadedFiles = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
+                foreach (var compilationAssembly in compilationDependencies.SelectMany(cd => cd.AssemblyPaths).Distinct())
+                {
+                    if (loadedFiles.Add(Path.GetFileName(compilationAssembly)))
+                    {
+                        _logger.LogDebug("Discovered script compilation assembly reference: " + compilationAssembly);
+                        AddMetadataReference(metadataReferences, assemblyReferences, compilationAssembly);
+                    }
+                }
+            }
+
+            // inject all inherited assemblies
+            foreach (var inheritedCompileLib in inheritedCompileLibraries)
+            {
+                _logger.LogDebug("Adding implicit reference: " + inheritedCompileLib);
+                AddMetadataReference(metadataReferences, assemblyReferences, inheritedCompileLib.Location);
+            }
+
+            var scriptProjectProvider = new ScriptProjectProvider(scriptOptions, _env, _loggerFactory, isDesktopClr);
+
+            return new ScriptContext(scriptProjectProvider, metadataReferences, assemblyReferences, compilationDependencies);
+        }
+
+        private void AddDefaultClrMetadataReferences(HashSet<MetadataReference> commonReferences, HashSet<string> assemblyReferences)
+        {
+            var assemblies = new[]
+            {
+                typeof(object).GetTypeInfo().Assembly,
+                typeof(Enumerable).GetTypeInfo().Assembly,
+                typeof(Stack<>).GetTypeInfo().Assembly,
+                typeof(Lazy<,>).GetTypeInfo().Assembly,
+                FromName("System.Runtime"),
+                FromName("mscorlib")
+            };
+
+            var references = assemblies
+                .Where(a => a != null)
+                .Select(a => a.Location)
+                .Distinct()
+                .Select(l =>
+                {
+                    assemblyReferences.Add(l);
+                    return _metadataFileReferenceCache.GetMetadataReference(l);
+                });
+
+            foreach (var reference in references)
+            {
+                commonReferences.Add(reference);
+            }
+
+            Assembly FromName(string assemblyName)
+            {
+                try
+                {
+                    return Assembly.Load(new AssemblyName(assemblyName));
+                }
+                catch
+                {
+                    return null;
+                }
+            }
+        }
+
+        private void AddMetadataReference(ISet<MetadataReference> referenceCollection, HashSet<string> assemblyReferences, string fileReference)
+        {
+            if (!File.Exists(fileReference))
+            {
+                _logger.LogWarning($"Couldn't add reference to '{fileReference}' because the file was not found.");
+                return;
+            }
+
+            var metadataReference = _metadataFileReferenceCache.GetMetadataReference(fileReference);
+            if (metadataReference == null)
+            {
+                _logger.LogWarning($"Couldn't add reference to '{fileReference}' because the loaded metadata reference was null.");
+                return;
+            }
+
+            referenceCollection.Add(metadataReference);
+            assemblyReferences.Add(fileReference);
+            _logger.LogDebug($"Added reference to '{fileReference}'");
+        }
+    }
+}

src/OmniSharp.Script/ScriptHelper.cs → src/OmniSharp.Script/ScriptProjectProvider.cs

@@ -14,7 +14,7 @@
 
 namespace OmniSharp.Script
 {
-    public class ScriptHelper
+    public class ScriptProjectProvider
     {
         private const string BinderFlagsType = "Microsoft.CodeAnalysis.CSharp.BinderFlags";
         private const string TopLevelBinderFlagsProperty = "TopLevelBinderFlags";
@@ -49,7 +49,7 @@ public class ScriptHelper
         private readonly ILogger _logger;
         private readonly bool _isDesktopClr;
 
-        public ScriptHelper(ScriptOptions scriptOptions, IOmniSharpEnvironment env, ILoggerFactory loggerFactory, bool isDesktopClr)
+        public ScriptProjectProvider(ScriptOptions scriptOptions, IOmniSharpEnvironment env, ILoggerFactory loggerFactory, bool isDesktopClr)
         {
             _scriptOptions = scriptOptions ?? throw new ArgumentNullException(nameof(scriptOptions));
             _env = env ?? throw new ArgumentNullException(nameof(env));