Diagnostics based on project information

src/QsCompiler/CompilationManager/CompilationUnit.cs

@@ -5,9 +5,7 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Collections.ObjectModel;
-using System.IO;
 using System.Linq;
-using System.Text.RegularExpressions;
 using System.Threading;
 using Microsoft.Quantum.QsCompiler.DataTypes;
 using Microsoft.Quantum.QsCompiler.Diagnostics;
@@ -18,6 +16,7 @@
 using Microsoft.Quantum.QsCompiler.SyntaxTree;
 using Microsoft.Quantum.QsCompiler.Transformations.SearchAndReplace;
 using Microsoft.VisualStudio.LanguageServer.Protocol;
+using static Microsoft.Quantum.QsCompiler.ReservedKeywords.AssemblyConstants;
 
 
 namespace Microsoft.Quantum.QsCompiler.CompilationBuilder
@@ -221,11 +220,16 @@ public class CompilationUnit : IReaderWriterLock, IDisposable
 
         internal References Externals { get; private set; }
         internal NamespaceManager GlobalSymbols { get; private set; }
+
         private readonly Dictionary<QsQualifiedName, QsCallable> CompiledCallables;
         private readonly Dictionary<QsQualifiedName, QsCustomType> CompiledTypes;
+
         private readonly ReaderWriterLockSlim SyncRoot;
         private readonly HashSet<ReaderWriterLockSlim> DependentLocks;
 
+        internal readonly RuntimeCapabilities RuntimeCapabilities;
+        internal readonly bool IsExecutable;
+
         public void Dispose()
         { this.SyncRoot.Dispose(); }
 
@@ -234,13 +238,18 @@ public void Dispose()
         /// with the given sequence of locks registered as dependent locks if the sequence is not null.
         /// Throws an ArgumentNullException if any of the given locks is.
         /// </summary>
-        internal CompilationUnit(References externals = null, IEnumerable<ReaderWriterLockSlim> dependentLocks = null)
+        internal CompilationUnit(RuntimeCapabilities capabilities, bool isExecutable,
+            References externals = null, IEnumerable<ReaderWriterLockSlim> dependentLocks = null)
         {
             this.SyncRoot = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
             this.DependentLocks = dependentLocks == null
                 ? new HashSet<ReaderWriterLockSlim>()
                 : new HashSet<ReaderWriterLockSlim>(dependentLocks);
             if (dependentLocks?.Contains(null) ?? false) throw new ArgumentNullException(nameof(dependentLocks), "one or more of the given locks is null");
+
+            this.RuntimeCapabilities = capabilities;
+            this.IsExecutable = isExecutable;
+
             this.CompiledCallables = new Dictionary<QsQualifiedName, QsCallable>();
             this.CompiledTypes = new Dictionary<QsQualifiedName, QsCustomType>();
             this.UpdateReferences(externals ?? References.Empty);
@@ -260,7 +269,8 @@ internal void UpdateReferences(References externals)
                 this.GlobalSymbols = new NamespaceManager(this, 
                     this.Externals.Declarations.Values.SelectMany(h => h.Callables), 
                     this.Externals.Declarations.Values.SelectMany(h => h.Specializations.Select(t => new Tuple<SpecializationDeclarationHeader, SpecializationImplementation>(t.Item1, t.Item2))), 
-                    this.Externals.Declarations.Values.SelectMany(h => h.Types));
+                    this.Externals.Declarations.Values.SelectMany(h => h.Types),
+                    this.RuntimeCapabilities, this.IsExecutable);
             }
             finally { this.ExitWriteLock(); }
         }

src/QsCompiler/CompilationManager/CompilationUnitManager.cs

@@ -10,6 +10,7 @@
 using System.Threading.Tasks;
 using Microsoft.Quantum.QsCompiler.CompilationBuilder.DataStructures;
 using Microsoft.Quantum.QsCompiler.DataTypes;
+using Microsoft.Quantum.QsCompiler.ReservedKeywords;
 using Microsoft.Quantum.QsCompiler.SyntaxProcessing;
 using Microsoft.Quantum.QsCompiler.SyntaxTokens;
 using Microsoft.Quantum.QsCompiler.SyntaxTree;
@@ -58,14 +59,16 @@ public class CompilationUnitManager : IDisposable
         protected readonly ProcessingQueue Processing;
 
         /// <summary>
-        /// Initializes a CompilationUnitManager instance.
-        /// If an <see cref="System.Action"/> for publishing diagnostics is given and is not null, 
+        /// Initializes a CompilationUnitManager instance for a project with the given properties.
+        /// If an <see cref="Action"/> for publishing diagnostics is given and is not null, 
         /// that action is called whenever diagnostics within a file have changed and are ready for publishing.
         /// </summary>
-        public CompilationUnitManager(Action<Exception> exceptionLogger = null, Action<PublishDiagnosticParams> publishDiagnostics = null, bool syntaxCheckOnly = false)
+        public CompilationUnitManager(
+            Action<Exception> exceptionLogger = null, Action<PublishDiagnosticParams> publishDiagnostics = null, bool syntaxCheckOnly = false,
+            AssemblyConstants.RuntimeCapabilities capabilities = AssemblyConstants.RuntimeCapabilities.Unknown, bool isExecutable = false)
         {
             this.EnableVerification = !syntaxCheckOnly;
-            this.CompilationUnit = new CompilationUnit();
+            this.CompilationUnit = new CompilationUnit(capabilities, isExecutable);
             this.FileContentManagers = new ConcurrentDictionary<NonNullable<string>, FileContentManager>();
             this.ChangedFiles = new ManagedHashSet<NonNullable<string>>(new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion));
             this.PublishDiagnostics = publishDiagnostics ?? (_ => { });
@@ -437,7 +440,7 @@ private Task SpawnGlobalTypeCheckingAsync(bool runSynchronously = false)
             // work with a separate compilation unit instance such that processing of all further edits can go on in parallel
             var sourceFiles = this.FileContentManagers.Values.OrderBy(m => m.FileName);
             this.ChangedFiles.RemoveAll(f => sourceFiles.Any(m => m.FileName.Value == f.Value));
-            var compilation = new CompilationUnit(this.CompilationUnit.Externals, sourceFiles.Select(file => file.SyncRoot));
+            var compilation = new CompilationUnit(this.CompilationUnit.RuntimeCapabilities, this.CompilationUnit.IsExecutable, this.CompilationUnit.Externals, sourceFiles.Select(file => file.SyncRoot));
             var content = compilation.UpdateGlobalSymbolsFor(sourceFiles);
             foreach (var file in sourceFiles) this.PublishDiagnostics(file.Diagnostics());
 

src/QsCompiler/CompilationManager/ProjectManager.cs

@@ -11,31 +11,49 @@
 using System.Threading.Tasks;
 using Microsoft.Quantum.QsCompiler.DataTypes;
 using Microsoft.Quantum.QsCompiler.Diagnostics;
+using Microsoft.Quantum.QsCompiler.ReservedKeywords;
 using Microsoft.VisualStudio.LanguageServer.Protocol;
 
 
 namespace Microsoft.Quantum.QsCompiler.CompilationBuilder
 {
-    public class ProjectInformation
+    internal class ProjectProperties
     {
-        public delegate bool Loader(Uri projectFile, out ProjectInformation projectInfo);
-
         public readonly string Version;
         public readonly string OutputPath;
+        public readonly AssemblyConstants.RuntimeCapabilities RuntimeCapabilities;
+        public readonly bool IsExecutable;
         public readonly bool ExposeReferencesViaTestNames;
+
+        internal static ProjectProperties Default =>
+            new ProjectProperties("Latest", "", AssemblyConstants.RuntimeCapabilities.Unknown, false, false);
+
+        public ProjectProperties(string version, string outputPath, AssemblyConstants.RuntimeCapabilities runtimeCapabilities, bool isExecutable, bool loadTestNames)
+        {
+            this.Version = version ?? "";
+            this.OutputPath = outputPath ?? throw new ArgumentNullException(nameof(outputPath));
+            this.RuntimeCapabilities = runtimeCapabilities;
+            this.IsExecutable = isExecutable;
+            this.ExposeReferencesViaTestNames = loadTestNames;
+        }
+    }
+
+    public class ProjectInformation
+    {
+        public delegate bool Loader(Uri projectFile, out ProjectInformation projectInfo);
+
+        internal readonly ProjectProperties Properties;
         public readonly ImmutableArray<string> SourceFiles;
         public readonly ImmutableArray<string> ProjectReferences;
         public readonly ImmutableArray<string> References;
 
-        internal static ProjectInformation Empty(string version, string outputPath) =>
-            new ProjectInformation(version, outputPath, false, Enumerable.Empty<string>(), Enumerable.Empty<string>(), Enumerable.Empty<string>());
+        internal static ProjectInformation Empty(string version, string outputPath, AssemblyConstants.RuntimeCapabilities runtimeCapabilities) =>
+            new ProjectInformation(version, outputPath, runtimeCapabilities, false, false, Enumerable.Empty<string>(), Enumerable.Empty<string>(), Enumerable.Empty<string>());
 
-        public ProjectInformation(string version, string outputPath, bool loadTestNames,
+        public ProjectInformation(string version, string outputPath, AssemblyConstants.RuntimeCapabilities runtimeCapabilities, bool isExecutable, bool loadTestNames,
             IEnumerable<string> sourceFiles, IEnumerable<string> projectReferences, IEnumerable<string> references)
         {
-            this.Version = version ?? ""; 
-            this.OutputPath = outputPath ?? throw new ArgumentNullException(nameof(outputPath));
-            this.ExposeReferencesViaTestNames = loadTestNames;
+            this.Properties = new ProjectProperties(version, outputPath, runtimeCapabilities, isExecutable, loadTestNames);
             this.SourceFiles = sourceFiles?.ToImmutableArray() ?? throw new ArgumentNullException(nameof(sourceFiles));
             this.ProjectReferences = projectReferences?.ToImmutableArray() ?? throw new ArgumentNullException(nameof(projectReferences));
             this.References = references?.ToImmutableArray() ?? throw new ArgumentNullException(nameof(references));
@@ -48,7 +66,7 @@ private class Project : IDisposable
         {
             public readonly Uri ProjectFile;
             public Uri OutputPath { get; private set; }
-            private bool ExposeReferencesViaTestNames;
+            public ProjectProperties Properties { get; private set; }
             private bool IsLoaded;
 
             /// <summary>
@@ -120,14 +138,16 @@ internal Project(Uri projectFile, ProjectInformation projectInfo,
                 this.ProjectFile = projectFile ?? throw new ArgumentNullException(nameof(projectFile));
                 this.SetProjectInformation(projectInfo ?? throw new ArgumentNullException(nameof(projectInfo)));
 
-                var version = Version.TryParse(projectInfo.Version, out Version v) ? v : null;
-                if (projectInfo.Version.Equals("Latest", StringComparison.InvariantCultureIgnoreCase)) version = new Version(0, 3);
+                var version = Version.TryParse(projectInfo.Properties.Version, out Version v) ? v : null;
+                if (projectInfo.Properties.Version.Equals("Latest", StringComparison.InvariantCultureIgnoreCase)) version = new Version(0, 3);
                 var ignore = version == null || version < new Version(0, 3) ? true : false;
 
                 // We track the file contents for unsupported projects in case the files are migrated to newer projects while editing,
                 // but we don't do any semantic verification, and we don't publish diagnostics for them. 
                 this.Processing = new ProcessingQueue(onException);
-                this.Manager = new CompilationUnitManager(onException, ignore ? null : publishDiagnostics, syntaxCheckOnly: ignore); 
+                this.Manager = new CompilationUnitManager(
+                    onException, ignore ? null : publishDiagnostics, syntaxCheckOnly: ignore,
+                    this.Properties.RuntimeCapabilities, this.Properties.IsExecutable); 
                 this.Log = log ?? ((msg, severity) => Console.WriteLine($"{severity}: {msg}"));
 
                 this.LoadedSourceFiles = ImmutableHashSet<Uri>.Empty;
@@ -144,10 +164,10 @@ internal Project(Uri projectFile, ProjectInformation projectInfo,
             private void SetProjectInformation(ProjectInformation projectInfo)
             {
                 if (projectInfo == null) throw new ArgumentNullException(nameof(projectInfo));
-                this.ExposeReferencesViaTestNames = projectInfo.ExposeReferencesViaTestNames;
+                this.Properties = projectInfo.Properties;
                 this.IsLoaded = false;
 
-                var outputPath = projectInfo.OutputPath;
+                var outputPath = projectInfo.Properties.OutputPath;
                 try { outputPath = Path.GetFullPath(outputPath); }
                 catch { outputPath = null; }
                 var outputUri = Uri.TryCreate(outputPath, UriKind.Absolute, out Uri uri) ? uri : null;
@@ -261,7 +281,7 @@ private Task LoadProjectReferencesAsync(
                     projectReferences, GetProjectOutputPath(projectOutputPaths, diagnostics),
                     diagnostics.Add, this.Manager.LogException);
 
-                this.LoadedProjectReferences = new References(loadedHeaders);
+                this.LoadedProjectReferences = new References(loadedHeaders, this.Properties.ExposeReferencesViaTestNames);
                 var importedDeclarations = this.LoadedReferences.CombineWith(this.LoadedProjectReferences,
                     (code,args) => diagnostics.Add(Errors.LoadError(code, args, MessageSource(this.ProjectFile))));
                 this.ProjectReferenceDiagnostics = diagnostics.ToImmutableArray();
@@ -288,7 +308,7 @@ private void ReloadProjectReference(IDictionary<Uri, Uri> projectOutputPaths, Ur
                 var loadedHeaders = ProjectManager.LoadProjectReferences(
                     new string[] { projectReference.LocalPath }, GetProjectOutputPath(projectOutputPaths, diagnostics),
                     diagnostics.Add, this.Manager.LogException);
-                var loaded = new References(loadedHeaders);
+                var loaded = new References(loadedHeaders, this.Properties.ExposeReferencesViaTestNames);
 
                 QsCompilerError.Verify(!loaded.Declarations.Any() ||
                     (loaded.Declarations.Count == 1 && loaded.Declarations.First().Key.Value == projRefId.Value),
@@ -320,7 +340,7 @@ private Task LoadReferencedAssembliesAsync(IEnumerable<string> references, bool
                 var loadedHeaders = ProjectManager.LoadReferencedAssemblies(references, 
                     diagnostics.Add, this.Manager.LogException);
 
-                this.LoadedReferences = new References(loadedHeaders);
+                this.LoadedReferences = new References(loadedHeaders, this.Properties.ExposeReferencesViaTestNames);
                 var importedDeclarations = this.LoadedReferences.CombineWith(this.LoadedProjectReferences,
                     (code, args) => diagnostics.Add(Errors.LoadError(code, args, MessageSource(this.ProjectFile))));                    
                 this.ReferenceDiagnostics = diagnostics.ToImmutableArray();
@@ -342,7 +362,7 @@ private void ReloadReferencedAssembly(Uri reference)
                 var diagnostics = new List<Diagnostic>();
                 var loadedHeaders = ProjectManager.LoadReferencedAssemblies(new string[] { reference.LocalPath },
                     diagnostics.Add, this.Manager.LogException);
-                var loaded = new References(loadedHeaders);
+                var loaded = new References(loadedHeaders, this.Properties.ExposeReferencesViaTestNames);
 
                 QsCompilerError.Verify(!loaded.Declarations.Any() || 
                     (loaded.Declarations.Count == 1 && loaded.Declarations.First().Key.Value == refId.Value),
@@ -687,7 +707,7 @@ public Task ProjectChangedOnDiskAsync(Uri projectFile, ProjectInformation.Loader
                 if (!loaded)
                 {
                     existing?.LoadProjectAsync(ImmutableDictionary<Uri,Uri>.Empty, null, MigrateToDefaultManager(openInEditor), 
-                        ProjectInformation.Empty("Latest", existing.OutputPath.LocalPath))?.Wait(); // does need to block, or the call to the DefaultManager in ManagerTaskAsync needs to be adapted
+                        ProjectInformation.Empty("Latest", existing.OutputPath.LocalPath, AssemblyConstants.RuntimeCapabilities.Unknown))?.Wait(); // does need to block, or the call to the DefaultManager in ManagerTaskAsync needs to be adapted
                     if (existing != null) this.ProjectReferenceChangedOnDiskChangeAsync(projectFile);
                     return;
                 }

src/QsCompiler/CompilationManager/Properties/AssemblyInfo.cs

@@ -6,3 +6,4 @@
 
 // Allow the test assembly to use our internal methods
 [assembly: InternalsVisibleTo("Tests.Microsoft.Quantum.QsCompiler" + SigningConstants.PUBLIC_KEY)]
+[assembly: InternalsVisibleTo("Tests.Microsoft.Quantum.QsLanguageServer" + SigningConstants.PUBLIC_KEY)]

src/QsCompiler/Compiler/CompilationLoader.cs

@@ -23,7 +23,7 @@
 
 using MetadataReference = Microsoft.CodeAnalysis.MetadataReference;
 using OptimizationLevel = Microsoft.CodeAnalysis.OptimizationLevel;
-using RuntimeCapabilities = Microsoft.Quantum.QsCompiler.ReservedKeywords.AssemblyConstants.RuntimeCapabilities;
+using static Microsoft.Quantum.QsCompiler.ReservedKeywords.AssemblyConstants;
 
 
 namespace Microsoft.Quantum.QsCompiler
@@ -435,7 +435,7 @@ public CompilationLoader(SourceLoader loadSources, ReferenceLoader loadReference
             RaiseCompilationTaskStart("OverallCompilation", "Build");
             this.CompilationStatus.Validation = Status.Succeeded;
             var files = CompilationUnitManager.InitializeFileManagers(sourceFiles, null, this.OnCompilerException); // do *not* live track (i.e. use publishing) here!
-            var compilationManager = new CompilationUnitManager(this.OnCompilerException);
+            var compilationManager = new CompilationUnitManager(this.OnCompilerException, capabilities: this.Config.RuntimeCapabilities, isExecutable: this.Config.IsExecutable); 
             compilationManager.UpdateReferencesAsync(references);
             compilationManager.AddOrUpdateSourceFilesAsync(files);
             this.VerifiedCompilation = compilationManager.Build();
@@ -450,9 +450,6 @@ public CompilationLoader(SourceLoader loadSources, ReferenceLoader loadReference
                 this.Logger?.Log(WarningCode.MissingEntryPoint, Array.Empty<string>());
 
             }
-            // TODO: 
-            // give warnings and ignore entry points in libraries, 
-            // and check additional restriction on the return type for execution on quantum processors.
 
             // executing the specified rewrite steps