Prevent result equality comparisons for QPRGen0 runtime capabilities

src/QsCompiler/CompilationManager/CompilationUnit.cs

@@ -234,6 +234,7 @@ public class CompilationUnit : IReaderWriterLock, IDisposable
 
         internal readonly RuntimeCapabilities RuntimeCapabilities;
         internal readonly bool IsExecutable;
+        internal readonly NonNullable<string> ExecutionTarget;
 
         public void Dispose()
         { this.SyncRoot.Dispose(); }
@@ -243,8 +244,12 @@ 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(RuntimeCapabilities capabilities, bool isExecutable,
-            References externals = null, IEnumerable<ReaderWriterLockSlim> dependentLocks = null)
+        internal CompilationUnit(
+            RuntimeCapabilities capabilities,
+            bool isExecutable,
+            NonNullable<string> executionTarget,
+            References externals = null,
+            IEnumerable<ReaderWriterLockSlim> dependentLocks = null)
         {
             this.SyncRoot = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
             this.DependentLocks = dependentLocks == null
@@ -254,6 +259,7 @@ internal CompilationUnit(RuntimeCapabilities capabilities, bool isExecutable,
 
             this.RuntimeCapabilities = capabilities;
             this.IsExecutable = isExecutable;
+            this.ExecutionTarget = executionTarget;
 
             this.CompiledCallables = new Dictionary<QsQualifiedName, QsCallable>();
             this.CompiledTypes = new Dictionary<QsQualifiedName, QsCustomType>();

src/QsCompiler/CompilationManager/CompilationUnitManager.cs

@@ -64,11 +64,15 @@ public class CompilationUnitManager : IDisposable
         /// 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,
-            AssemblyConstants.RuntimeCapabilities capabilities = AssemblyConstants.RuntimeCapabilities.Unknown, bool isExecutable = false)
+            Action<Exception> exceptionLogger = null,
+            Action<PublishDiagnosticParams> publishDiagnostics = null,
+            bool syntaxCheckOnly = false,
+            AssemblyConstants.RuntimeCapabilities capabilities = AssemblyConstants.RuntimeCapabilities.Unknown,
+            bool isExecutable = false,
+            NonNullable<string> executionTarget = default)
         {
             this.EnableVerification = !syntaxCheckOnly;
-            this.CompilationUnit = new CompilationUnit(capabilities, isExecutable);
+            this.CompilationUnit = new CompilationUnit(capabilities, isExecutable, executionTarget);
             this.FileContentManagers = new ConcurrentDictionary<NonNullable<string>, FileContentManager>();
             this.ChangedFiles = new ManagedHashSet<NonNullable<string>>(new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion));
             this.PublishDiagnostics = publishDiagnostics ?? (_ => { });
@@ -440,7 +444,12 @@ 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.RuntimeCapabilities, this.CompilationUnit.IsExecutable, this.CompilationUnit.Externals, sourceFiles.Select(file => file.SyncRoot));
+            var compilation = new CompilationUnit(
+                this.CompilationUnit.RuntimeCapabilities,
+                this.CompilationUnit.IsExecutable,
+                this.CompilationUnit.ExecutionTarget,
+                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

@@ -23,17 +23,22 @@ internal class ProjectProperties
         public readonly string OutputPath;
         public readonly AssemblyConstants.RuntimeCapabilities RuntimeCapabilities;
         public readonly bool IsExecutable;
+        public readonly NonNullable<string> ExecutionTarget;
         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)
+        public ProjectProperties(
+            string version,
+            string outputPath,
+            AssemblyConstants.RuntimeCapabilities runtimeCapabilities,
+            bool isExecutable,
+            NonNullable<string> executionTarget,
+            bool loadTestNames)
         {
             this.Version = version ?? "";
             this.OutputPath = outputPath ?? throw new ArgumentNullException(nameof(outputPath));
             this.RuntimeCapabilities = runtimeCapabilities;
             this.IsExecutable = isExecutable;
+            this.ExecutionTarget = executionTarget;
             this.ExposeReferencesViaTestNames = loadTestNames;
         }
     }
@@ -47,13 +52,34 @@ public class ProjectInformation
         public readonly ImmutableArray<string> ProjectReferences;
         public readonly ImmutableArray<string> References;
 
-        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, AssemblyConstants.RuntimeCapabilities runtimeCapabilities, bool isExecutable, bool loadTestNames,
-            IEnumerable<string> sourceFiles, IEnumerable<string> projectReferences, IEnumerable<string> references)
+        internal static ProjectInformation Empty(
+                string version,
+                string outputPath,
+                AssemblyConstants.RuntimeCapabilities runtimeCapabilities) =>
+            new ProjectInformation(
+                version, 
+                outputPath, 
+                runtimeCapabilities,
+                false,
+                NonNullable<string>.New("Unspecified"),
+                false,
+                Enumerable.Empty<string>(),
+                Enumerable.Empty<string>(),
+                Enumerable.Empty<string>());
+
+        public ProjectInformation(
+            string version,
+            string outputPath,
+            AssemblyConstants.RuntimeCapabilities runtimeCapabilities,
+            bool isExecutable,
+            NonNullable<string> executionTarget,
+            bool loadTestNames,
+            IEnumerable<string> sourceFiles,
+            IEnumerable<string> projectReferences,
+            IEnumerable<string> references)
         {
-            this.Properties = new ProjectProperties(version, outputPath, runtimeCapabilities, isExecutable, loadTestNames);
+            this.Properties = new ProjectProperties(
+                version, outputPath, runtimeCapabilities, isExecutable, executionTarget, 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));
@@ -146,8 +172,12 @@ internal Project(Uri projectFile, ProjectInformation projectInfo,
                 // 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.Properties.RuntimeCapabilities, this.Properties.IsExecutable); 
+                    onException,
+                    ignore ? null : publishDiagnostics,
+                    syntaxCheckOnly: ignore,
+                    this.Properties.RuntimeCapabilities,
+                    this.Properties.IsExecutable,
+                    this.Properties.ExecutionTarget);
                 this.Log = log ?? ((msg, severity) => Console.WriteLine($"{severity}: {msg}"));
 
                 this.LoadedSourceFiles = ImmutableHashSet<Uri>.Empty;