Distinguishing the processor architecture and the execution target

src/QsCompiler/CompilationManager/CompilationUnit.cs

@@ -280,7 +280,7 @@ public class CompilationUnit : IReaderWriterLock, IDisposable
 
         internal readonly RuntimeCapabilities RuntimeCapabilities;
         internal readonly bool IsExecutable;
-        internal readonly NonNullable<string> ExecutionTarget;
+        internal readonly NonNullable<string> ProcessorArchitecture;
 
         public void Dispose()
         { this.SyncRoot.Dispose(); }
@@ -293,7 +293,7 @@ public void Dispose()
         internal CompilationUnit(
             RuntimeCapabilities capabilities,
             bool isExecutable,
-            NonNullable<string> executionTarget,
+            NonNullable<string> processorArchitecture,
             References externals = null,
             IEnumerable<ReaderWriterLockSlim> dependentLocks = null)
         {
@@ -305,7 +305,7 @@ internal CompilationUnit(
 
             this.RuntimeCapabilities = capabilities;
             this.IsExecutable = isExecutable;
-            this.ExecutionTarget = executionTarget;
+            this.ProcessorArchitecture = processorArchitecture;
 
             this.CompiledCallables = new Dictionary<QsQualifiedName, QsCallable>();
             this.CompiledTypes = new Dictionary<QsQualifiedName, QsCustomType>();

src/QsCompiler/CompilationManager/CompilationUnitManager.cs

@@ -69,10 +69,10 @@ public CompilationUnitManager(
             bool syntaxCheckOnly = false,
             AssemblyConstants.RuntimeCapabilities capabilities = AssemblyConstants.RuntimeCapabilities.Unknown,
             bool isExecutable = false,
-            NonNullable<string> executionTarget = default)
+            NonNullable<string> processorArchitecture = default)
         {
             this.EnableVerification = !syntaxCheckOnly;
-            this.CompilationUnit = new CompilationUnit(capabilities, isExecutable, executionTarget);
+            this.CompilationUnit = new CompilationUnit(capabilities, isExecutable, processorArchitecture);
             this.FileContentManagers = new ConcurrentDictionary<NonNullable<string>, FileContentManager>();
             this.ChangedFiles = new ManagedHashSet<NonNullable<string>>(new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion));
             this.PublishDiagnostics = publishDiagnostics ?? (_ => { });
@@ -467,7 +467,7 @@ private Task SpawnGlobalTypeCheckingAsync(bool runSynchronously = false)
             var compilation = new CompilationUnit(
                 this.CompilationUnit.RuntimeCapabilities,
                 this.CompilationUnit.IsExecutable,
-                this.CompilationUnit.ExecutionTarget,
+                this.CompilationUnit.ProcessorArchitecture,
                 this.CompilationUnit.Externals,
                 sourceFiles.Select(file => file.SyncRoot));
             var content = compilation.UpdateGlobalSymbolsFor(sourceFiles);

src/QsCompiler/CompilationManager/ProjectManager.cs

@@ -23,22 +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 NonNullable<string> ProcessorArchitecture;
         public readonly bool ExposeReferencesViaTestNames;
 
         public ProjectProperties(
             string version,
             string outputPath,
             AssemblyConstants.RuntimeCapabilities runtimeCapabilities,
             bool isExecutable,
-            NonNullable<string> executionTarget,
+            NonNullable<string> processorArchitecture,
             bool loadTestNames)
         {
             this.Version = version ?? "";
             this.OutputPath = outputPath ?? throw new ArgumentNullException(nameof(outputPath));
             this.RuntimeCapabilities = runtimeCapabilities;
             this.IsExecutable = isExecutable;
-            this.ExecutionTarget = executionTarget;
+            this.ProcessorArchitecture = processorArchitecture;
             this.ExposeReferencesViaTestNames = loadTestNames;
         }
     }
@@ -72,14 +72,14 @@ public ProjectInformation(
             string outputPath,
             AssemblyConstants.RuntimeCapabilities runtimeCapabilities,
             bool isExecutable,
-            NonNullable<string> executionTarget,
+            NonNullable<string> processorArchitecture,
             bool loadTestNames,
             IEnumerable<string> sourceFiles,
             IEnumerable<string> projectReferences,
             IEnumerable<string> references)
         {
             this.Properties = new ProjectProperties(
-                version, outputPath, runtimeCapabilities, isExecutable, executionTarget, loadTestNames);
+                version, outputPath, runtimeCapabilities, isExecutable, processorArchitecture, 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));
@@ -177,7 +177,7 @@ internal Project(Uri projectFile, ProjectInformation projectInfo,
                     syntaxCheckOnly: ignore,
                     this.Properties.RuntimeCapabilities,
                     this.Properties.IsExecutable,
-                    this.Properties.ExecutionTarget);
+                    this.Properties.ProcessorArchitecture);
                 this.Log = log ?? ((msg, severity) => Console.WriteLine($"{severity}: {msg}"));
 
                 this.LoadedSourceFiles = ImmutableHashSet<Uri>.Empty;

src/QsCompiler/CompilationManager/TypeChecking.cs

@@ -1257,7 +1257,7 @@ QsSpecialization BuildSpecialization(QsSpecializationKind kind, ResolvedSignatur
                     var context = ScopeContext<Position>.Create(
                         compilation.GlobalSymbols,
                         compilation.RuntimeCapabilities,
-                        compilation.ExecutionTarget,
+                        compilation.ProcessorArchitecture,
                         spec);
                     implementation = BuildUserDefinedImplementation(
                         root, spec.SourceFile, arg, requiredFunctorSupport, context, diagnostics);

src/QsCompiler/Compiler/CompilationLoader.cs

@@ -447,14 +447,14 @@ 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 executionTarget = this.Config.AssemblyConstants?.GetValueOrDefault(ExecutionTarget);
+            var processorArchitecture = this.Config.AssemblyConstants?.GetValueOrDefault(AssemblyConstants.ProcessorArchitecture);
             var compilationManager = new CompilationUnitManager(
                 this.OnCompilerException,
                 capabilities: this.Config.RuntimeCapabilities,
                 isExecutable: this.Config.IsExecutable,
-                executionTarget: NonNullable<string>.New(string.IsNullOrWhiteSpace(executionTarget)
+                processorArchitecture: NonNullable<string>.New(string.IsNullOrWhiteSpace(processorArchitecture)
                     ? "Unspecified"
-                    : executionTarget));
+                    : processorArchitecture));
             compilationManager.UpdateReferencesAsync(references);
             compilationManager.AddOrUpdateSourceFilesAsync(files);
             this.VerifiedCompilation = compilationManager.Build();

src/QsCompiler/DataStructures/Diagnostics.fs

@@ -544,12 +544,8 @@ type DiagnosticItem =
             | ErrorCode.ExpectingIterableExpr                     -> "The type {0} does not support iteration. Expecting an expression of array type or of type Range."
             | ErrorCode.ExpectingCallableExpr                     -> "The type of the expression must be a function or operation type. The given expression is of type {0}." 
             | ErrorCode.UnknownIdentifier                         -> "No identifier with the name \"{0}\" exists."
-            | ErrorCode.UnsupportedResultComparison               ->
-                // TODO: When the names of the runtime capabilities are finalized, they can be included in the error
-                // message.
-                "The execution target {0} does not support comparing measurement results. " +
-                "Choose an execution target with additional capabilities or avoid result comparisons."
-
+            // TODO: When the names of the runtime capabilities are finalized, they can be included in the error message.
+            | ErrorCode.UnsupportedResultComparison               -> "The target {0} does not support comparing measurement results."
             | ErrorCode.CallableRedefinition                      -> "Invalid callable declaration. A function or operation with the name \"{0}\" already exists."
             | ErrorCode.CallableOverlapWithTypeConstructor        -> "Invalid callable declaration. A type constructor with the name \"{0}\" already exists."
             | ErrorCode.TypeRedefinition                          -> "Invalid type declaration. A type with the name \"{0}\" already exists."

src/QsCompiler/DataStructures/ReservedKeywords.fs

@@ -234,13 +234,14 @@ module GeneratedAttributes =
 module AssemblyConstants = 
     let OutputPath = "OutputPath"
     let AssemblyName = "AssemblyName"
-    let QsharpOutputType = "ResolvedQsharpOutputType"
+    let QsharpOutputType = "QsharpOutputType"
     let QsharpExe = "QsharpExe"
     let QsharpLibrary = "QsharpLibrary"
-    let ExecutionTarget = "ResolvedExecutionTarget"
+    let ProcessorArchitecture = "ProcessorArchitecture"
     let HoneywellProcessor = "HoneywellProcessor"
     let IonQProcessor = "IonQProcessor"
     let QCIProcessor = "QCIProcessor"
+    let ExecutionTarget = "ExecutionTarget"
     let DefaultSimulator = "DefaultSimulator"
     let QuantumSimulator = "QuantumSimulator"
     let ToffoliSimulator = "ToffoliSimulator"

src/QsCompiler/LanguageServer/EditorState.cs

@@ -106,7 +106,7 @@ internal bool QsProjectLoader(Uri projectFile, out ProjectInformation info)
             var targetFile = projectInstance.GetPropertyValue("TargetFileName");
             var outputPath = Path.Combine(projectInstance.Directory, outputDir, targetFile);
 
-            var executionTarget = projectInstance.GetPropertyValue("ResolvedQsharpExecutionTarget");
+            var processorArchitecture = projectInstance.GetPropertyValue("ResolvedProcessorArchitecture");
             var resRuntimeCapability = projectInstance.GetPropertyValue("ResolvedRuntimeCapabilities");
             var runtimeCapabilities = Enum.TryParse(resRuntimeCapability, out AssemblyConstants.RuntimeCapabilities capability) 
                 ? capability 
@@ -132,7 +132,7 @@ internal bool QsProjectLoader(Uri projectFile, out ProjectInformation info)
                 outputPath,
                 runtimeCapabilities,
                 isExecutable,
-                NonNullable<string>.New(string.IsNullOrWhiteSpace(executionTarget) ? "Unspecified" : executionTarget),
+                NonNullable<string>.New(string.IsNullOrWhiteSpace(processorArchitecture) ? "Unspecified" : processorArchitecture),
                 loadTestNames,
                 sourceFiles,
                 projectReferences,

src/QsCompiler/SyntaxProcessor/ExpressionVerification.fs

@@ -253,7 +253,7 @@ let private VerifyEqualityComparison context addError (lhsType, lhsRange) (rhsTy
     let baseType = CommonBaseType addError argumentError context.Symbols.Parent (lhsType, lhsRange) (rhsType, rhsRange)
     match baseType.Resolution with
     | Result when context.Capabilities = RuntimeCapabilities.QPRGen0 ->
-        addError (ErrorCode.UnsupportedResultComparison, [context.ExecutionTarget.Value]) rhsRange
+        addError (ErrorCode.UnsupportedResultComparison, [context.ProcessorArchitecture.Value]) rhsRange
     | _ ->
         let unsupportedError = ErrorCode.InvalidTypeInEqualityComparison, [toString baseType]
         VerifyIsOneOf (fun t -> t.supportsEqualityComparison) unsupportedError addError (baseType, rhsRange) |> ignore

src/QsCompiler/SyntaxProcessor/ScopeTools.fs

@@ -290,8 +290,8 @@ type ScopeContext<'a> =
       ReturnType : ResolvedType
       /// The runtime capabilities for the compilation unit.
       Capabilities : RuntimeCapabilities
-      /// The name of the execution target for the compilation unit.
-      ExecutionTarget : NonNullable<string> }
+      /// The name of the processor architecture for the compilation unit.
+      ProcessorArchitecture : NonNullable<string> }
     with
 
     /// <summary>
@@ -307,13 +307,13 @@ type ScopeContext<'a> =
     /// </exception>
     static member Create (nsManager : NamespaceManager)
                          capabilities
-                         executionTarget
+                         processorArchitecture
                          (spec : SpecializationDeclarationHeader) =
         match nsManager.TryGetCallable spec.Parent (spec.Parent.Namespace, spec.SourceFile) with
         | Found declaration ->
             { Symbols = SymbolTracker<'a> (nsManager, spec.SourceFile, spec.Parent)
               IsInOperation = declaration.Kind = Operation
               ReturnType = StripPositionInfo.Apply declaration.Signature.ReturnType
               Capabilities = capabilities
-              ExecutionTarget = executionTarget }
+              ProcessorArchitecture = processorArchitecture }
         | _ -> raise <| ArgumentException "The specialization's parent callable does not exist."

src/QuantumSdk/DefaultItems/DefaultItems.targets

@@ -28,31 +28,31 @@
     <ValidOutputTypes>Possible values are 'Exe', or 'Library'.</ValidOutputTypes>
   </PropertyGroup>
 
-  <!-- Resolving the ExecutionTarget to either HoneywellProcessor, IonQProcessor, QCIProcessor or Unspecified.-->
+  <!-- Initializing the ResolvedProcessorArchitecture to either HoneywellProcessor, IonQProcessor, QCIProcessor or Unspecified.-->
   <PropertyGroup>
-    <ResolvedQsharpExecutionTarget Condition="('$(ResolvedQsharpOutputType)' == 'QsharpExe' Or '$(NoEntryPoint)' == 'true') And $(ExecutionTarget.StartsWith('honeywell.'))">HoneywellProcessor</ResolvedQsharpExecutionTarget>
-    <ResolvedQsharpExecutionTarget Condition="('$(ResolvedQsharpOutputType)' == 'QsharpExe' Or '$(NoEntryPoint)' == 'true') And $(ExecutionTarget.StartsWith('ionq.'))">IonQProcessor</ResolvedQsharpExecutionTarget>
-    <ResolvedQsharpExecutionTarget Condition="('$(ResolvedQsharpOutputType)' == 'QsharpExe' Or '$(NoEntryPoint)' == 'true') And $(ExecutionTarget.StartsWith('qci.'))">QCIProcessor</ResolvedQsharpExecutionTarget>
-    <ResolvedQsharpExecutionTarget Condition="'$(ExecutionTarget)' == 'Any'">Unspecified</ResolvedQsharpExecutionTarget>
-    <ResolvedQsharpExecutionTarget Condition="'$(ResolvedQsharpExecutionTarget)' != 'HoneywellProcessor' And '$(ResolvedQsharpExecutionTarget)' != 'IonQProcessor' And '$(ResolvedQsharpExecutionTarget)' != 'QCIProcessor' And '$(ResolvedQsharpExecutionTarget)' != 'Unspecified'"></ResolvedQsharpExecutionTarget>
+    <ResolvedProcessorArchitecture Condition="('$(ResolvedQsharpOutputType)' == 'QsharpExe' Or '$(NoEntryPoint)' == 'true') And $(ExecutionTarget.StartsWith('honeywell.'))">HoneywellProcessor</ResolvedProcessorArchitecture>
+    <ResolvedProcessorArchitecture Condition="('$(ResolvedQsharpOutputType)' == 'QsharpExe' Or '$(NoEntryPoint)' == 'true') And $(ExecutionTarget.StartsWith('ionq.'))">IonQProcessor</ResolvedProcessorArchitecture>
+    <ResolvedProcessorArchitecture Condition="('$(ResolvedQsharpOutputType)' == 'QsharpExe' Or '$(NoEntryPoint)' == 'true') And $(ExecutionTarget.StartsWith('qci.'))">QCIProcessor</ResolvedProcessorArchitecture>
+    <ResolvedProcessorArchitecture Condition="'$(ExecutionTarget)' == 'Any'">Unspecified</ResolvedProcessorArchitecture>
+    <ResolvedProcessorArchitecture Condition="'$(ResolvedProcessorArchitecture)' != 'HoneywellProcessor' And '$(ResolvedProcessorArchitecture)' != 'IonQProcessor' And '$(ResolvedProcessorArchitecture)' != 'QCIProcessor' And '$(ResolvedProcessorArchitecture)' != 'Unspecified'"></ResolvedProcessorArchitecture>
     <ValidExecutionTargets Condition="'$(ResolvedQsharpOutputType)' == 'QsharpExe' Or '$(NoEntryPoint)' == 'true'">Possible values must match 'ionq.*', 'honeywell.*', 'qci.*', or 'Any'.</ValidExecutionTargets>
     <ValidExecutionTargets Condition="'$(ResolvedQsharpOutputType)' == 'QsharpLibrary'">The execution target for a Q# library needs to be 'Any'.</ValidExecutionTargets>
   </PropertyGroup>
 
   <!-- Resolving the QuantumIntrinsics to either OpenQASM, ExtendedQASM, or Default.-->
   <PropertyGroup>
-    <ResolvedQuantumIntrinsics Condition="'$(ResolvedQsharpExecutionTarget)' == 'HoneywellProcessor'">OpenQASM</ResolvedQuantumIntrinsics>
-    <ResolvedQuantumIntrinsics Condition="'$(ResolvedQsharpExecutionTarget)' == 'IonQProcessor'">ExtendedQASM</ResolvedQuantumIntrinsics>
-    <ResolvedQuantumIntrinsics Condition="'$(ResolvedQsharpExecutionTarget)' == 'QCIProcessor'">OpenQASM</ResolvedQuantumIntrinsics>
-    <ResolvedQuantumIntrinsics Condition="'$(ResolvedQsharpExecutionTarget)' != 'HoneywellProcessor' And '$(ResolvedQsharpExecutionTarget)' != 'IonQProcessor' And '$(ResolvedQsharpExecutionTarget)' != 'QCIProcessor'">Default</ResolvedQuantumIntrinsics>
+    <ResolvedQuantumIntrinsics Condition="'$(ResolvedProcessorArchitecture)' == 'HoneywellProcessor'">OpenQASM</ResolvedQuantumIntrinsics>
+    <ResolvedQuantumIntrinsics Condition="'$(ResolvedProcessorArchitecture)' == 'IonQProcessor'">ExtendedQASM</ResolvedQuantumIntrinsics>
+    <ResolvedQuantumIntrinsics Condition="'$(ResolvedProcessorArchitecture)' == 'QCIProcessor'">OpenQASM</ResolvedQuantumIntrinsics>
+    <ResolvedQuantumIntrinsics Condition="'$(ResolvedProcessorArchitecture)' != 'HoneywellProcessor' And '$(ResolvedProcessorArchitecture)' != 'IonQProcessor' And '$(ResolvedProcessorArchitecture)' != 'QCIProcessor'">Default</ResolvedQuantumIntrinsics>
   </PropertyGroup>
 
   <!-- Resolving the RuntimeCapabilites to either QPRGen0, QPRGen1, or Unknown.-->
   <PropertyGroup>
-    <ResolvedRuntimeCapabilities Condition="'$(ResolvedQsharpExecutionTarget)' == 'HoneywellProcessor'">QPRGen1</ResolvedRuntimeCapabilities>
-    <ResolvedRuntimeCapabilities Condition="'$(ResolvedQsharpExecutionTarget)' == 'IonQProcessor'">QPRGen0</ResolvedRuntimeCapabilities>
-    <ResolvedRuntimeCapabilities Condition="'$(ResolvedQsharpExecutionTarget)' == 'QCIProcessor'">QPRGen1</ResolvedRuntimeCapabilities>
-    <ResolvedRuntimeCapabilities Condition="'$(ResolvedQsharpExecutionTarget)' != 'HoneywellProcessor' And '$(ResolvedQsharpExecutionTarget)' != 'IonQProcessor' And '$(ResolvedQsharpExecutionTarget)' != 'QCIProcessor'">Unknown</ResolvedRuntimeCapabilities>
+    <ResolvedRuntimeCapabilities Condition="'$(ResolvedProcessorArchitecture)' == 'HoneywellProcessor'">QPRGen1</ResolvedRuntimeCapabilities>
+    <ResolvedRuntimeCapabilities Condition="'$(ResolvedProcessorArchitecture)' == 'IonQProcessor'">QPRGen0</ResolvedRuntimeCapabilities>
+    <ResolvedRuntimeCapabilities Condition="'$(ResolvedProcessorArchitecture)' == 'QCIProcessor'">QPRGen1</ResolvedRuntimeCapabilities>
+    <ResolvedRuntimeCapabilities Condition="'$(ResolvedProcessorArchitecture)' != 'HoneywellProcessor' And '$(ResolvedProcessorArchitecture)' != 'IonQProcessor' And '$(ResolvedProcessorArchitecture)' != 'QCIProcessor'">Unknown</ResolvedRuntimeCapabilities>
   </PropertyGroup>
 
   <!-- Set all unspecified properties configuring the paths for output generated during Q# compilation. -->