mirror of
https://github.com/OPCFoundation/UA-.NETStandard.git
synced 2026-10-18 14:43:08 +08:00
Wolfgang Colsman
716858aa7d
# Description For a NodeSet2 input the generator built the predefined nodes from the merged instance hierarchy. A subtype therefore got a copy of every Mandatory InstanceDeclaration of its supertypes as a new child node, with a NodeId the NodeSet2 never assigned (the supertype's numeric identifier in the subtype's namespace, or a string identifier derived from the path when the supertype comes from a referenced assembly). A DeviceType subtype got eight such children from DI's DeviceType, so the address space a server loads from the generated code differs from the NodeSet2 it was generated from. ModelSourceGeneratorEmitNodeSetNodesOnly (GeneratorOptions .EmitNodeSetNodesOnly), off by default, makes the predefined nodes of a NodeSet2 input exactly the nodes the NodeSet2 declares: a child the generator derives from a supertype or type definition is not added to a predefined node. The typed state classes are unchanged and still reach inherited members through the state classes of their supertypes, and the CreateInstanceOf* factories still create every Mandatory child of the type. ModelDesign inputs are not affected. IModelDesign.IsSourceNodeSet tells the generator whether the target model was read from a NodeSet2. A test in Opc.Ua.Di.Tests generates a DI-style NodeSet2 with the option on, exports the generated predefined nodes as a NodeSet2 and compares it with the input, node for node and reference for reference. ## Related Issues None. ## Checklist - [x] I have signed the [CLA](https://opcfoundation.org/license/cla/ContributorLicenseAgreementv1.0.pdf) and read the [CONTRIBUTING](https://github.com/OPCFoundation/UA-.NETStandard/blob/master/CONTRIBUTING.md) doc. - [x] I have added tests that prove my fix is effective or that my feature works and increased code coverage. - [x] I have added all necessary documentation. - [x] I have verified that my changes do not introduce (new) build or analyzer warnings. - [x] I ran **all** tests locally using the **UA.slnx** solution against at least .net **framework** and .net **10**, and all passed. - [x] I fixed **all** failing and flaky tests in the CI pipelines and **all** CodeQL warnings. - [ ] I have addressed **all** PR feedback received. --------- Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Co-authored-by: Marc Schier <marcschier@users.noreply.github.com>
606 lines
29 KiB
C#
606 lines
29 KiB
C#
/* ========================================================================
|
|
* Copyright (c) 2005-2025 The OPC Foundation, Inc. All rights reserved.
|
|
*
|
|
* OPC Foundation MIT License 1.00
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person
|
|
* obtaining a copy of this software and associated documentation
|
|
* files (the "Software"), to deal in the Software without
|
|
* restriction, including without limitation the rights to use,
|
|
* copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following
|
|
* conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be
|
|
* included in all copies or substantial portions of the Software.
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
* OTHER DEALINGS IN THE SOFTWARE.
|
|
*
|
|
* The complete license agreement can be found here:
|
|
* http://opcfoundation.org/License/MIT/1.00/
|
|
* ======================================================================*/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.Immutable;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using Microsoft.CodeAnalysis;
|
|
using Microsoft.CodeAnalysis.CSharp;
|
|
using Opc.Ua.SourceGeneration.Dependency;
|
|
|
|
namespace Opc.Ua.SourceGeneration
|
|
{
|
|
/// <summary>
|
|
/// Compiles the model. This honors the options of the compile command
|
|
/// of the tool. However, it does not generate identifier files and
|
|
/// assumes that if identifiers are required they are loaded from a
|
|
/// csv file that is side by side with the design files. Also, this
|
|
/// does not produce xsd or bsd nor nodeset files, which cannot be
|
|
/// added to a compilation using roslyn source generator (yet).
|
|
/// </summary>
|
|
internal sealed class ModelCompilation
|
|
{
|
|
/// <summary>
|
|
/// Create compilation
|
|
/// </summary>
|
|
public ModelCompilation(
|
|
SourceProductionContext context,
|
|
ImmutableArray<(AdditionalText, NodesetFileOptions)> inputFiles,
|
|
ImmutableArray<AdditionalText> csvFiles,
|
|
ImmutableArray<AdditionalText> identifierFiles,
|
|
ModelCompilationOptions options,
|
|
CompilationOptions compilationOptions,
|
|
ImmutableArray<ModelDependencyReference> referencedModels,
|
|
ImmutableArray<ModelFluentAccessorProviderReference> referencedAccessorProviders,
|
|
ImmutableArray<NodeManagerAttributeDiscovery> nodeManagerBindings,
|
|
ImmutableHashSet<string> availableStateTypeNames)
|
|
{
|
|
m_context = context;
|
|
m_input = inputFiles;
|
|
m_csvFiles = csvFiles;
|
|
m_identifierFiles = identifierFiles;
|
|
m_options = options;
|
|
m_compilationOptions = compilationOptions;
|
|
m_nodeManagerBindings = nodeManagerBindings;
|
|
m_referencedModels = referencedModels;
|
|
m_referencedAccessorProviders = referencedAccessorProviders;
|
|
m_availableStateTypeNames = availableStateTypeNames;
|
|
m_telemetry = SourceGeneratorTelemetry.Create(m_context);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Perform the compilation
|
|
/// </summary>
|
|
public void Emit(CancellationToken cancellationToken)
|
|
{
|
|
if (!CheckCompilationOptions())
|
|
{
|
|
return;
|
|
}
|
|
var sourceFiles = new SourceGeneratorFileSystem(
|
|
m_input.Select(i => i.Item1).Concat(m_csvFiles));
|
|
|
|
using var vfs = new VirtualFileSystem(); // Use a virtual file sytem
|
|
try
|
|
{
|
|
if (m_input.Length == 0)
|
|
{
|
|
// Nothing to do
|
|
return;
|
|
}
|
|
if (m_options.ClientAccessorsOnly && m_options.Options.GenerateNodeManager)
|
|
{
|
|
throw new InvalidOperationException(
|
|
"Client accessor-only generation cannot be combined with node manager generation.");
|
|
}
|
|
|
|
string[] exclusions = [.. m_options.Exclude
|
|
.Append("Draft")
|
|
.Distinct()];
|
|
var generatorOptions = new GeneratorOptions
|
|
{
|
|
Cancellation = cancellationToken,
|
|
Exclusions = exclusions,
|
|
// csharp10 or below does not support utf8 string literals
|
|
UseUtf8StringLiterals =
|
|
m_compilationOptions.LanguageVersion >= LanguageVersion.CSharp11,
|
|
OptimizeForCompileSpeed =
|
|
m_compilationOptions.OptimizationLevel == OptimizationLevel.Debug,
|
|
OmitObjectTypeProxies = m_options.OmitObjectTypeProxies,
|
|
ObjectTypeProxyNamespace =
|
|
string.IsNullOrWhiteSpace(m_options.ObjectTypeProxyNamespace)
|
|
? null
|
|
: m_options.ObjectTypeProxyNamespace,
|
|
UseTypeDefinitionModellingRules =
|
|
m_options.UseTypeDefinitionModellingRules,
|
|
EmitNodeSetNodesOnly = m_options.EmitNodeSetNodesOnly,
|
|
EmitDependencyMetadata = ResolveEmitDependencyMetadata(),
|
|
OmitFluentApi = m_options.OmitFluentApi,
|
|
FluentAccessorsOnly = m_options.FluentAccessorsOnly,
|
|
ClientAccessorsOnly = m_options.ClientAccessorsOnly,
|
|
ClientAccessorNamespace = m_options.ClientAccessorNamespace,
|
|
ClientAccessorClassName = m_options.ClientAccessorClassName,
|
|
OmitEventRecords = m_options.OmitEventRecords
|
|
};
|
|
|
|
// Load all available nodeset files from the input
|
|
NodesetFileCollection nodesets = m_input.ToNodeSetFileCollection(
|
|
m_csvFiles,
|
|
sourceFiles, // .WithFallback(vfs),
|
|
m_telemetry);
|
|
ReportNodesetIdentifierDiagnostics(nodesets.IdentifierValidationErrors);
|
|
|
|
// Resolve [NodeManager] bindings: validate partial-ness and
|
|
// build the binding list to pass into both GenerateCode calls
|
|
// (nodeset-derived and design-file-derived).
|
|
var bindings = new List<NodeManagerAttributeBinding>();
|
|
var bindingByPayload =
|
|
new Dictionary<NodeManagerAttributeBinding, NodeManagerAttributeDiscovery>();
|
|
foreach (NodeManagerAttributeDiscovery discovery in m_nodeManagerBindings)
|
|
{
|
|
// An invalid discovery is reported by
|
|
// NodeManagerAttributeDiscovery.ReportDiagnostics, in a
|
|
// separate output that has the compilation to report it
|
|
// at a source location.
|
|
if (discovery == null || discovery.IsInvalid)
|
|
{
|
|
continue;
|
|
}
|
|
bindings.Add(discovery.Binding);
|
|
bindingByPayload[discovery.Binding] = discovery;
|
|
}
|
|
|
|
void reportBinding(NodeManagerAttributeBinding binding, string message)
|
|
{
|
|
// Reported while the models are generated, which does not
|
|
// depend on the compilation (to stay cached), so there is
|
|
// no syntax tree to report at: an external location.
|
|
Location loc =
|
|
bindingByPayload.TryGetValue(binding, out NodeManagerAttributeDiscovery d) &&
|
|
d != null
|
|
? d.Location.ToLocation()
|
|
: Location.None;
|
|
m_context.ReportDiagnostic(
|
|
Diagnostic.Create(
|
|
SourceGenerator.NodeManagerBindingError,
|
|
loc,
|
|
message));
|
|
}
|
|
|
|
void reportFluentAccessorsOnly(
|
|
string modelUri,
|
|
string prefix,
|
|
string path,
|
|
string reason)
|
|
{
|
|
m_context.ReportDiagnostic(
|
|
Diagnostic.Create(
|
|
SourceGenerator.FluentAccessorsOnlyModelError,
|
|
Location.None,
|
|
modelUri,
|
|
prefix,
|
|
path,
|
|
reason));
|
|
}
|
|
|
|
// Reduce referenced model attributes to a single dictionary by
|
|
// model URI (with tie-break on highest version+publication date)
|
|
// so the downstream generators can apply override resolution
|
|
// and decode the carried dependency payloads.
|
|
IReadOnlyDictionary<string, ModelDependencyReference>
|
|
referencedModels = BuildReferencedModelMap();
|
|
|
|
// The design files that are not NodeSet2 inputs form the
|
|
// ModelDesign pass. Compute them up front so the total model
|
|
// count (NodeSet2 models + ModelDesign targets) can be shared
|
|
// with both passes: [NodeManager] bindings are resolved across
|
|
// both passes, so single-model fallback / ambiguity detection
|
|
// must see the global model count, not the per-pass count.
|
|
// Use a set for O(1) membership tests instead of an O(n)
|
|
// ContainsValue scan per input (Ordinal preserves the previous
|
|
// dictionary-value equality semantics exactly).
|
|
// AllFilePaths, not Files.Values: Files exposes one entry per
|
|
// model URI, so a superseded NodeSet2 version would not be
|
|
// recognised as a NodeSet input and would be picked up as a
|
|
// ModelDesign target and generated a second time.
|
|
var nodesetPaths = new HashSet<string>(
|
|
nodesets.AllFilePaths, StringComparer.Ordinal);
|
|
// Distinct: a project can list the same file as an AdditionalFile
|
|
// more than once (a glob overlapping an explicit item). The file
|
|
// system dedupes its own view, but a repeated design target is
|
|
// generated twice and the second AddSource throws on the
|
|
// duplicate hint name - and it also inflates totalModelCount,
|
|
// which decides the single-model [NodeManager] fallback.
|
|
List<string> designInputs = [.. m_input
|
|
.Where(f => !nodesetPaths.Contains(f.Item1.Path))
|
|
.Select(f => f.Item1.Path)
|
|
.Distinct(StringComparer.Ordinal)];
|
|
// A design marked ModelSourceGeneratorIgnore is, like an
|
|
// ignored NodeSet2 input, only there to resolve references
|
|
// of the other inputs: it stays a dependency but is not
|
|
// generated, or its types would be emitted a second time
|
|
// next to the assembly that already provides them.
|
|
var ignoredDesigns = new HashSet<string>(
|
|
m_input.Where(f => f.Item2?.Ignore == true).Select(f => f.Item1.Path),
|
|
StringComparer.Ordinal);
|
|
List<string> designTargets = [.. designInputs
|
|
.Where(path => !ignoredDesigns.Contains(path))];
|
|
|
|
var designDependencies = new List<string>(nodesets.DesignFileEntries);
|
|
designDependencies.AddRange(designInputs);
|
|
|
|
// A CSV that a NodeSet claims through its IdentifierFile metadata
|
|
// is that NodeSet's sidecar. Left in the list, the ModelDesign
|
|
// pass adopts it as the identifier file of a design that has no
|
|
// same-named CSV and is the only design in the folder, and the
|
|
// design silently takes the NodeSet's numeric ids.
|
|
var claimedIdentifierFiles = new HashSet<string>(
|
|
nodesets.IdentifierFilePaths, StringComparer.Ordinal);
|
|
List<string> designIdentifierFiles = [.. m_identifierFiles
|
|
.Select(i => i.Path)
|
|
.Where(path => !claimedIdentifierFiles.Contains(path))];
|
|
|
|
// A [NodeManager] may bind to a model produced by either pass
|
|
// (a NodeSet2 type model or a ModelDesign instance model). The
|
|
// "used" set is therefore shared across both passes and the
|
|
// unmatched-binding diagnostics are reported once, after both
|
|
// passes — reporting per pass would false-positive a binding
|
|
// that the other pass matched (issue #3937).
|
|
HashSet<NodeManagerAttributeBinding> usedBindings =
|
|
bindings.Count > 0 ? [] : null;
|
|
int totalModelCount = nodesets.ModelUris.Count() + designTargets.Count;
|
|
|
|
// Enter the standard method-state fallback scope for the whole
|
|
// model-generation pass: a reference to a standard
|
|
// global::Opc.Ua.*MethodState class degrades to the base
|
|
// MethodState only when the typed class is neither present in
|
|
// the compilation nor declared by this pass. The Stack
|
|
// generator (which builds Opc.Ua.Core) never enters this scope.
|
|
using IDisposable fallbackScope =
|
|
StandardMethodStateFallback.Enter(m_availableStateTypeNames);
|
|
|
|
nodesets.GenerateCode(
|
|
sourceFiles.WithFallback(vfs),
|
|
string.Empty,
|
|
m_telemetry,
|
|
generatorOptions,
|
|
m_options.UseAllowSubtypes,
|
|
referencedModels,
|
|
bindings.Count > 0 ? bindings : null,
|
|
bindings.Count > 0 ? reportBinding : null,
|
|
// Derived from referencedModels, which carries the payloads.
|
|
null,
|
|
usedBindings,
|
|
totalModelCount,
|
|
reportFluentAccessorsOnly,
|
|
m_referencedModels,
|
|
m_referencedAccessorProviders);
|
|
|
|
// Process the remaining design files. Every NodeSet2 input
|
|
// (encoded with the prefix/name computed by the nodeset
|
|
// pass) and every other ModelDesign input is supplied as a
|
|
// dependency so cross-model references resolve — both
|
|
// ModelDesign -> NodeSet2 (e.g. an instance whose
|
|
// TypeDefinition is a NodeSet2-defined ObjectType) and
|
|
// ModelDesign -> ModelDesign across directories. The
|
|
// referenced models carry the upstream dependency payloads,
|
|
// so a design file can also subtype a structure of a
|
|
// referenced model that is not present in AdditionalFiles.
|
|
new DesignFileCollection
|
|
{
|
|
Targets = designTargets,
|
|
Dependencies = designDependencies,
|
|
Options = m_options.Options
|
|
}.GenerateCode(
|
|
sourceFiles.WithFallback(vfs),
|
|
string.Empty,
|
|
m_telemetry,
|
|
generatorOptions,
|
|
m_options.UseAllowSubtypes,
|
|
designIdentifierFiles,
|
|
referencedModels,
|
|
bindings.Count > 0 ? bindings : null,
|
|
bindings.Count > 0 ? reportBinding : null,
|
|
usedBindings,
|
|
totalModelCount,
|
|
reportFluentAccessorsOnly,
|
|
m_referencedModels,
|
|
m_referencedAccessorProviders);
|
|
|
|
// Report any [NodeManager] bindings that neither pass matched,
|
|
// once, against the shared used-set aggregated across passes.
|
|
Generators.ReportUnmatchedNodeManagerBindings(
|
|
bindings,
|
|
usedBindings,
|
|
totalModelCount,
|
|
reportBinding);
|
|
|
|
// Collect all generated cs files and produce them into the compilation
|
|
foreach (string file in vfs.CreatedFiles
|
|
.Where(f => f.EndsWith(".cs", StringComparison.OrdinalIgnoreCase)))
|
|
{
|
|
string content = Encoding.UTF8.GetString(vfs.Get(file));
|
|
m_context.AddSource(file, content);
|
|
}
|
|
}
|
|
catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
|
|
{
|
|
// A cancelled run is not a generator failure: let the driver
|
|
// see the cancellation instead of caching an error diagnostic.
|
|
throw;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
m_context.ReportDiagnostic(
|
|
Diagnostic.Create(
|
|
SourceGenerator.Exception,
|
|
Location.None,
|
|
ex.Message,
|
|
ex.ToString()));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tests the compilation options are valid
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private bool CheckCompilationOptions()
|
|
{
|
|
if (m_compilationOptions.LanguageVersion < LanguageVersion.CSharp8)
|
|
{
|
|
m_context.ReportDiagnostic(
|
|
Diagnostic.Create(
|
|
SourceGenerator.GenericError,
|
|
Location.None,
|
|
"Minimum required language version is CSharp 8."));
|
|
return false;
|
|
}
|
|
if (m_options.FluentAccessorsOnly && m_options.OmitFluentApi)
|
|
{
|
|
m_context.ReportDiagnostic(
|
|
Diagnostic.Create(
|
|
SourceGenerator.FluentAccessorsOnlyOptionsError,
|
|
Location.None,
|
|
"ModelSourceGeneratorFluentAccessorsOnly and " +
|
|
"ModelSourceGeneratorOmitFluentApi cannot both be enabled."));
|
|
return false;
|
|
}
|
|
// The project-wide switch would emit a conventionally named
|
|
// manager into the *referenced* model's own C# namespace for
|
|
// every design in the project. A [NodeManager] says which model
|
|
// gets a manager and what it is called, so that is the way to
|
|
// put one on a model a reference supplies.
|
|
if (m_options.FluentAccessorsOnly && m_options.Options.GenerateNodeManager)
|
|
{
|
|
m_context.ReportDiagnostic(
|
|
Diagnostic.Create(
|
|
SourceGenerator.FluentAccessorsOnlyOptionsError,
|
|
Location.None,
|
|
"ModelSourceGeneratorFluentAccessorsOnly cannot be combined with " +
|
|
"ModelSourceGeneratorGenerateNodeManager. Apply a [NodeManager] " +
|
|
"attribute to the manager class instead; it binds to a model a " +
|
|
"referenced assembly supplies without re-emitting the model."));
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private void ReportNodesetIdentifierDiagnostics(
|
|
IEnumerable<NodesetIdentifierValidationError> errors)
|
|
{
|
|
foreach (NodesetIdentifierValidationError error in errors)
|
|
{
|
|
m_context.ReportDiagnostic(
|
|
Diagnostic.Create(
|
|
error.Kind switch
|
|
{
|
|
NodesetIdentifierValidationErrorKind.MissingFile =>
|
|
SourceGenerator.NodesetIdentifierFileMissing,
|
|
NodesetIdentifierValidationErrorKind.DuplicateSymbolicName =>
|
|
SourceGenerator.NodesetIdentifierDuplicateSymbolicName,
|
|
NodesetIdentifierValidationErrorKind.DuplicateNumericId =>
|
|
SourceGenerator.NodesetIdentifierDuplicateNumericId,
|
|
NodesetIdentifierValidationErrorKind.UnknownSymbol =>
|
|
SourceGenerator.NodesetIdentifierUnknownSymbol,
|
|
NodesetIdentifierValidationErrorKind.NumericIdMismatch =>
|
|
SourceGenerator.NodesetIdentifierNumericIdMismatch,
|
|
NodesetIdentifierValidationErrorKind.NodeClassMismatch =>
|
|
SourceGenerator.NodesetIdentifierNodeClassMismatch,
|
|
NodesetIdentifierValidationErrorKind.AssignedToMultipleModels =>
|
|
SourceGenerator.NodesetIdentifierAssignedToMultipleModels,
|
|
_ => SourceGenerator.NodesetIdentifierInvalidRow
|
|
},
|
|
Location.None,
|
|
error.NodeSetFilePath,
|
|
error.IdentifierFilePath,
|
|
error.SymbolicName,
|
|
error.Value));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Group the referenced-assembly attributes by model URI; when more
|
|
/// than one assembly contributes the same URI, prefer a payload-bearing
|
|
/// self producer over payloadless transitive re-exports, then use the
|
|
/// highest <c>(Version, PublicationDate)</c> tuple per the contract on
|
|
/// <see cref="ModelDependencyAttribute"/> (see
|
|
/// <see cref="CompareReferencedModels"/>).
|
|
/// </summary>
|
|
private IReadOnlyDictionary<string, ModelDependencyReference>
|
|
BuildReferencedModelMap()
|
|
{
|
|
if (m_referencedModels.IsDefaultOrEmpty)
|
|
{
|
|
return ImmutableDictionary<string, ModelDependencyReference>.Empty;
|
|
}
|
|
var map = new Dictionary<string, ModelDependencyReference>(
|
|
StringComparer.Ordinal);
|
|
foreach (ModelDependencyReference candidate in m_referencedModels)
|
|
{
|
|
if (!candidate.IsValid)
|
|
{
|
|
continue;
|
|
}
|
|
if (!map.TryGetValue(candidate.ModelUri, out ModelDependencyReference existing))
|
|
{
|
|
map[candidate.ModelUri] = candidate;
|
|
continue;
|
|
}
|
|
if (IsMatchingTransitiveReference(candidate, existing))
|
|
{
|
|
if (IsModelProducer(candidate))
|
|
{
|
|
map[candidate.ModelUri] = candidate;
|
|
}
|
|
continue;
|
|
}
|
|
int cmp = CompareReferencedModels(candidate, existing);
|
|
if (cmp == 0)
|
|
{
|
|
continue;
|
|
}
|
|
ModelDependencyReference selected = cmp > 0 ? candidate : existing;
|
|
ModelDependencyReference ignored = cmp > 0 ? existing : candidate;
|
|
if (cmp > 0)
|
|
{
|
|
map[candidate.ModelUri] = candidate;
|
|
}
|
|
m_context.ReportDiagnostic(
|
|
Diagnostic.Create(
|
|
SourceGenerator.ModelDependencyTieBreak,
|
|
Location.None,
|
|
selected.ModelUri,
|
|
selected.AssemblyName,
|
|
ignored.AssemblyName));
|
|
}
|
|
return map;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Identifies matching dependency metadata, not another assembly that emits the model's types.
|
|
/// </summary>
|
|
private static bool IsMatchingTransitiveReference(
|
|
ModelDependencyReference candidate,
|
|
ModelDependencyReference existing)
|
|
{
|
|
if (!string.Equals(candidate.ModelUri, existing.ModelUri, StringComparison.Ordinal) ||
|
|
!string.Equals(candidate.Prefix, existing.Prefix, StringComparison.Ordinal) ||
|
|
!string.Equals(candidate.Version, existing.Version, StringComparison.Ordinal) ||
|
|
!string.Equals(candidate.PublicationDate, existing.PublicationDate, StringComparison.Ordinal) ||
|
|
!string.Equals(candidate.Name, existing.Name, StringComparison.Ordinal))
|
|
{
|
|
return false;
|
|
}
|
|
return (candidate.Payload.Length == 0 &&
|
|
(existing.Payload.Length == 0 || IsModelProducer(existing))) ||
|
|
(existing.Payload.Length == 0 && IsModelProducer(candidate));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Orders two referenced-assembly entries for the same model URI: a
|
|
/// payload-bearing self producer first, then the version, then the
|
|
/// publication date. The newest entry is picked by pairwise
|
|
/// replacement, so this must be a total order or the winner depends on
|
|
/// the order the assemblies are referenced in. The versions go through
|
|
/// <see cref="SemVer.CompareModels"/>, the OPC 10000-6 F.2 comparator
|
|
/// NodesetFileCollection uses, so the two halves of the pipeline cannot
|
|
/// pick different winners. An ordinal assembly-name tie-break keeps
|
|
/// equally versioned distinct producers deterministic.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// <see cref="ModelDependencyAttribute"/> and its ModelDependencyV1
|
|
/// payload carry a single version string and no separate ModelVersion.
|
|
/// That string is the version the producing generator publishes as the
|
|
/// model's version (the ModelDesign pipeline derives the
|
|
/// NamespaceMetadata ModelVersion from it), so it takes the ModelVersion
|
|
/// slot of the comparison; there is no separate Version label to fall
|
|
/// back to. The raw publication date text breaks what is left.
|
|
/// </remarks>
|
|
internal static int CompareReferencedModels(
|
|
ModelDependencyReference candidate,
|
|
ModelDependencyReference existing)
|
|
{
|
|
int cmp = IsModelProducer(candidate).CompareTo(IsModelProducer(existing));
|
|
if (cmp == 0)
|
|
{
|
|
cmp = SemVer.CompareModels(
|
|
candidate.Version,
|
|
ParsePublicationDate(candidate.PublicationDate),
|
|
null,
|
|
existing.Version,
|
|
ParsePublicationDate(existing.PublicationDate),
|
|
null);
|
|
}
|
|
if (cmp == 0)
|
|
{
|
|
cmp = string.CompareOrdinal(
|
|
candidate.PublicationDate, existing.PublicationDate);
|
|
}
|
|
if (cmp == 0)
|
|
{
|
|
cmp = string.CompareOrdinal(existing.AssemblyName, candidate.AssemblyName);
|
|
}
|
|
return cmp;
|
|
}
|
|
|
|
private static DateTime ParsePublicationDate(string publicationDate)
|
|
{
|
|
return !string.IsNullOrEmpty(publicationDate) &&
|
|
DateTime.TryParse(
|
|
publicationDate,
|
|
CultureInfo.InvariantCulture,
|
|
DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal,
|
|
out DateTime date)
|
|
? date
|
|
: DateTime.MinValue;
|
|
}
|
|
|
|
private static bool IsModelProducer(ModelDependencyReference reference)
|
|
{
|
|
ModelDependencyV1 dependency = reference.GetDependency();
|
|
return dependency != null &&
|
|
string.Equals(dependency.ModelUri, reference.ModelUri, StringComparison.Ordinal);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resolve whether the model-dependency assembly attribute
|
|
/// should be emitted, honouring the compilation's OutputKind
|
|
/// in <c>Auto</c> mode.
|
|
/// </summary>
|
|
private bool ResolveEmitDependencyMetadata()
|
|
{
|
|
return m_options.EmitDependencyMetadata switch
|
|
{
|
|
EmitDependencyMetadataMode.Always => true,
|
|
EmitDependencyMetadataMode.Never => false,
|
|
_ => m_compilationOptions.OutputKind is
|
|
OutputKind.DynamicallyLinkedLibrary or
|
|
OutputKind.NetModule
|
|
};
|
|
}
|
|
|
|
private readonly SourceProductionContext m_context;
|
|
private readonly ImmutableArray<(AdditionalText, NodesetFileOptions)> m_input;
|
|
private readonly ImmutableArray<AdditionalText> m_csvFiles;
|
|
private readonly ImmutableArray<AdditionalText> m_identifierFiles;
|
|
private readonly ModelCompilationOptions m_options;
|
|
private readonly CompilationOptions m_compilationOptions;
|
|
private readonly ImmutableArray<ModelDependencyReference> m_referencedModels;
|
|
private readonly ImmutableArray<ModelFluentAccessorProviderReference>
|
|
m_referencedAccessorProviders;
|
|
private readonly ImmutableArray<NodeManagerAttributeDiscovery> m_nodeManagerBindings;
|
|
private readonly ImmutableHashSet<string> m_availableStateTypeNames;
|
|
private readonly SourceGeneratorTelemetry m_telemetry;
|
|
}
|
|
}
|