Merge pull request #546 from FirelyTeam/262-refactor---rename-nameand…

…versionlibrarykey-to-versionedidentifer-2 262 refactor rename nameandversionlibrarykey to versionedidentifer 2
FirelyTeam · Sep 18, 2024 · ac50bbe · ac50bbe
2 parents 7e8a9ec + 7aa5439
commit ac50bbe
Show file tree

Hide file tree

Showing 26 changed files with 222 additions and 239 deletions.
diff --git a/Cql/CodeGeneration.NET/AssemblyCompiler.cs b/Cql/CodeGeneration.NET/AssemblyCompiler.cs
@@ -23,6 +23,7 @@
 using System.Linq.Expressions;
 using System.Reflection;
 using System.Text;
+using Hl7.Cql.Elm;
 
 namespace Hl7.Cql.CodeGeneration.NET
 {
@@ -106,8 +107,8 @@ void CSharpSourceCodeStep(CSharpSourceCodeStep next)
                         {
                             var library = librarySet.GetLibrary(libraryName)!;
                             var libraryAssembly = CompileNode(stream, results, librarySet, library, _referencesLazy.Value);
-                            results.Add(library.NameAndVersion()!, libraryAssembly);
-                            _assemblyDataPostProcessor?.ProcessAssemblyData(library.NameAndVersion()!, libraryAssembly);
+                            results.Add(library.GetVersionedIdentifier()!, libraryAssembly);
+                            _assemblyDataPostProcessor?.ProcessAssemblyData(library.GetVersionedIdentifier()!, libraryAssembly);
                         }
                         break;
                 }
@@ -140,23 +141,23 @@ private static AssemblyData CompileNode(
             {
                 metadataReferences.Add(MetadataReference.CreateFromFile(asm.Location));
             }
-            foreach (var libraryDependency in librarySet.GetLibraryDependencies(library.NameAndVersion()!))
+            foreach (var libraryDependency in librarySet.GetLibraryDependencies(library.GetVersionedIdentifier()!))
             {
-                if (assemblies.TryGetValue(libraryDependency.NameAndVersion()!, out var referencedDll))
+                if (assemblies.TryGetValue(libraryDependency.GetVersionedIdentifier()!, out var referencedDll))
                 {
                     metadataReferences.Add(MetadataReference.CreateFromImage(referencedDll.Binary));
                 }
             }
             var asmInfo = new StringBuilder();
-            var parts = library.NameAndVersion()!.Split('-');
+            var parts = library.GetVersionedIdentifier()!.Split('-');
             string name = parts[0];
             string version = string.Empty;
             if (parts.Length > 1)
                 version = parts[1];
             asmInfo.AppendLine(CultureInfo.InvariantCulture, $"[assembly: Hl7.Cql.Abstractions.CqlLibraryAttribute(\"{name}\", \"{version}\")]");
             var asmInfoTree = SyntaxFactory.ParseSyntaxTree(asmInfo.ToString());
 
-            var compilation = CSharpCompilation.Create($"{library.NameAndVersion()!}")
+            var compilation = CSharpCompilation.Create($"{library.GetVersionedIdentifier()!}")
                 .WithOptions(CreateCSharpCompilationOptions())
                 .WithReferences(metadataReferences)
                 .AddSyntaxTrees(tree, asmInfoTree);
@@ -184,14 +185,14 @@ private static AssemblyData CompileNode(
                     }
                     sb.AppendLine(diag.ToString());
                 }
-                var ex = new InvalidOperationException($"The following compilation errors were detected when compiling {library.NameAndVersion()!}:{Environment.NewLine}{sb}");
+                var ex = new InvalidOperationException($"The following compilation errors were detected when compiling {library.GetVersionedIdentifier()!}:{Environment.NewLine}{sb}");
                 ex.Data["Errors"] = errors;
                 ex.Data["Warnings"] = warnings;
 
                 throw ex;
             }
             var bytes = codeStream.ToArray();
-            var asmData = new AssemblyData(bytes, new Dictionary<string, string> { { library.NameAndVersion()!, sourceCode } });
+            var asmData = new AssemblyData(bytes, new Dictionary<string, string> { { library.GetVersionedIdentifier()!, sourceCode } });
             return asmData;
         }
 

diff --git a/Cql/CodeGeneration.NET/CSharpLibrarySetToStreamsWriter.cs b/Cql/CodeGeneration.NET/CSharpLibrarySetToStreamsWriter.cs
@@ -20,8 +20,10 @@
 using System.Reflection;
 using System.Text;
 using Hl7.Cql.Compiler;
+using Hl7.Cql.Elm;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.Extensions.Options;
+using Expression = System.Linq.Expressions.Expression;
 
 namespace Hl7.Cql.CodeGeneration.NET
 {
@@ -169,7 +171,7 @@ public void ProcessDefinitions(
 
             foreach (var library in librarySet)
             {
-                string libraryName = library.NameAndVersion()!;
+                string libraryName = library.GetVersionedIdentifier()!;
                 if (!callbacks.ShouldWriteLibrary(libraryName))
                 {
                     _logger.LogInformation($"Skipping library {libraryName} as per callback.");
@@ -222,13 +224,13 @@ private void WriteClass(DefinitionDictionary<LambdaExpression> definitions,
 
             var libraryAttribute = libraryName;
             var versionAttribute = string.Empty;
-            var nameAndVersion = libraryName.Split('-');
-            if (nameAndVersion.Length == 2)
+            var versionedIdentifier = libraryName.Split('-');
+            if (versionedIdentifier.Length == 2)
             {
-                if (Version.TryParse(nameAndVersion[1], out _))
+                if (Version.TryParse(versionedIdentifier[1], out _))
                 {
-                    libraryAttribute = nameAndVersion[0];
-                    versionAttribute = nameAndVersion[1];
+                    libraryAttribute = versionedIdentifier[0];
+                    versionAttribute = versionedIdentifier[1];
                 }
             }
 
@@ -314,7 +316,7 @@ private static void WriteDependencies(
 
             foreach (var dependentLibrary in requiredLibraries)
             {
-                var typeName = libraryNameToClassName(dependentLibrary.NameAndVersion()!);
+                var typeName = libraryNameToClassName(dependentLibrary.GetVersionedIdentifier()!);
                 var memberName = typeName;
                 writer.WriteLine(indentLevel, $"{memberName} = new {typeName}(context);");
             }
@@ -366,7 +368,7 @@ private void WriteLibraryMembers(TextWriter writer,
                     writer.WriteLine();
                 }
 
-                var typeName = libraryNameToClassName(dependentLibrary.NameAndVersion()!);
+                var typeName = libraryNameToClassName(dependentLibrary.GetVersionedIdentifier()!);
                 var memberName = typeName;
                 writer.WriteLine(indent, $"public {typeName} {memberName} {{ get; }}");
             }

diff --git a/Cql/Cql.Compiler/BuilderContextDebuggerInfo.cs b/Cql/Cql.Compiler/BuilderContextDebuggerInfo.cs
@@ -55,7 +55,7 @@ public static BuilderContextDebuggerInfo FromElement(Element element)
         string? GetNameText(Element elem)
         {
             StringBuilder sb = new();
-            Append(FromNameAndVersion());
+            Append(FromVersionedIdentifier());
             Append(FromLibraryName());
             Append(FromContext());
             Append(FromName());
@@ -71,7 +71,7 @@ void Append(string? text)
 
             string? FromPath() => (elem as IGetPath)?.path;
             string? FromContext() => (elem as ExpressionDef)?.context;
-            string? FromNameAndVersion() => (elem as IGetNameAndVersion)?.NameAndVersion(throwError: false);
+            string? FromVersionedIdentifier() => (elem as IGetVersionedIdentifier)?.GetVersionedIdentifier(throwError: false);
             string? FromLibraryName() => (elem as IGetLibraryName)?.libraryName;
             string? FromName() => (elem as IGetName)?.name;
         }

diff --git a/Cql/Cql.Compiler/Errors.cs b/Cql/Cql.Compiler/Errors.cs
@@ -32,9 +32,9 @@ internal readonly record struct LibraryIdentifierMustBeUniqueError(Library Libra
     public string GetMessage() => $"Library did not have a unique name and version in the set. Duplicate Identifier: '{Library}'";
 }
 
-internal readonly record struct CouldNotResolveAliasFromTheLibraryNameAndVersionError(Library Library) : ILibraryError
+internal readonly record struct CouldNotResolveAliasFromTheLibraryVersionedIdentifierError(Library Library) : ILibraryError
 {
-    public string GetMessage() => $"Could not resolve alias from the Library name and version. Library Identifier: '{Library}'";
+    public string GetMessage() => $"Could not resolve alias from the Library versioned identifier. Library Identifier: '{Library}'";
 }
 
 internal readonly record struct LibraryAliasUnresolvedError(Library Library, string Alias) : ILibraryError

diff --git a/Cql/Cql.Compiler/ExpressionBuilderContext.DebuggerView.cs b/Cql/Cql.Compiler/ExpressionBuilderContext.DebuggerView.cs
@@ -10,6 +10,7 @@
 using System.Diagnostics;
 using System.Linq;
 using Hl7.Cql.Abstractions.Infrastructure;
+using Hl7.Cql.Elm;
 
 namespace Hl7.Cql.Compiler;
 
@@ -34,8 +35,8 @@ private string FormatMessage(string message, Elm.Element? element = null)
         var locator = element?.locator;
 
         return string.IsNullOrWhiteSpace(locator)
-            ? $"{_libraryContext.LibraryKey}: {message}"
-            : $"{_libraryContext.LibraryKey} line {locator}: {message}";
+            ? $"{_libraryContext.LibraryVersionedIdentifier}: {message}"
+            : $"{_libraryContext.LibraryVersionedIdentifier} line {locator}: {message}";
     }
 
     public string DebuggerView => this.GetDebuggerView();

diff --git a/Cql/Cql.Compiler/ExpressionBuilderContext.LibraryDefs.cs b/Cql/Cql.Compiler/ExpressionBuilderContext.LibraryDefs.cs
@@ -39,13 +39,13 @@ public void ProcessCodeSystemDef(
                             ));
                     var arrayOfCodesInitializer = Expression.NewArrayInit(typeof(CqlCode), initMembers);
                     var lambda = Expression.Lambda(arrayOfCodesInitializer, CqlExpressions.ParameterExpression);
-                    _libraryContext.LibraryDefinitions.Add(_libraryContext.LibraryKey, codeSystem.name, lambda);
+                    _libraryContext.LibraryDefinitions.Add(_libraryContext.LibraryVersionedIdentifier, codeSystem.name, lambda);
                 }
                 else
                 {
                     var newArray = Expression.NewArrayBounds(typeof(CqlCode), Expression.Constant(0, typeof(int)));
                     var lambda = Expression.Lambda(newArray, CqlExpressions.ParameterExpression);
-                    _libraryContext.LibraryDefinitions.Add(_libraryContext.LibraryKey, codeSystem.name, lambda);
+                    _libraryContext.LibraryDefinitions.Add(_libraryContext.LibraryVersionedIdentifier, codeSystem.name, lambda);
                 }
             }
         });
@@ -61,7 +61,7 @@ public void ProcessConceptDef(
                 {
                     var newArray = Expression.NewArrayBounds(typeof(CqlCode), Expression.Constant(0, typeof(int)));
                     var lambda = Expression.Lambda(newArray, CqlExpressions.ParameterExpression);
-                    _libraryContext.LibraryDefinitions.Add(_libraryContext.LibraryKey, conceptDef.name, lambda);
+                    _libraryContext.LibraryDefinitions.Add(_libraryContext.LibraryVersionedIdentifier, conceptDef.name, lambda);
                 }
                 else
                 {
@@ -87,7 +87,7 @@ public void ProcessConceptDef(
                     var display = Expression.Constant(conceptDef.display, typeof(string));
                     var newConcept = Expression.New(ConstructorInfos.CqlConcept!, asEnumerable, display);
                     var lambda = Expression.Lambda(newConcept, CqlExpressions.ParameterExpression);
-                    _libraryContext.LibraryDefinitions.Add(_libraryContext.LibraryKey, conceptDef.name, lambda);
+                    _libraryContext.LibraryDefinitions.Add(_libraryContext.LibraryVersionedIdentifier, conceptDef.name, lambda);
                 }
             }
         });
@@ -122,7 +122,7 @@ public void ProcessCodeDef(
                     NullExpression.String!
                 );
                 var lambda = Expression.Lambda(newCodingExpression, CqlExpressions.ParameterExpression);
-                _libraryContext.LibraryDefinitions.Add(_libraryContext.LibraryKey, codeDef.name!, lambda);
+                _libraryContext.LibraryDefinitions.Add(_libraryContext.LibraryVersionedIdentifier, codeDef.name!, lambda);
             }
         });
 
@@ -142,7 +142,7 @@ public void ProcessExpressionDef(
                         null);
                 }
 
-                var expressionKey = $"{_libraryContext.LibraryKey}.{expressionDef.name}";
+                var expressionKey = $"{_libraryContext.LibraryVersionedIdentifier}.{expressionDef.name}";
                 Type[] functionParameterTypes = Type.EmptyTypes;
                 var parameters = new[] { CqlExpressions.ParameterExpression };
                 var function = expressionDef as FunctionDef;
@@ -181,7 +181,7 @@ public void ProcessExpressionDef(
                                 @params[o + 1] = (funcOps[o].name, functionParameterTypes[o]);
                             var notImplemented = NotImplemented(expressionKey, @params, returnType);
                             var paramTypes = @params.Select(p => p.type).ToArray();
-                            _libraryContext.LibraryDefinitions.Add(_libraryContext.LibraryKey, expressionDef.name,
+                            _libraryContext.LibraryDefinitions.Add(_libraryContext.LibraryVersionedIdentifier, expressionDef.name,
                                paramTypes, notImplemented);
                             _logger.LogWarning(FormatMessage(
                                 $"Function '{expressionDef.name}' is declared external, but it was not defined in the expression scope. " +
@@ -198,7 +198,7 @@ public void ProcessExpressionDef(
                 var bodyExpression = TranslateArg(expressionDef.expression);
                 var lambda = Expression.Lambda(bodyExpression, parameters);
                 if (function?.operand != null &&
-                    _libraryContext.LibraryDefinitions.ContainsKey(_libraryContext.LibraryKey, expressionDef.name,
+                    _libraryContext.LibraryDefinitions.ContainsKey(_libraryContext.LibraryVersionedIdentifier, expressionDef.name,
                         functionParameterTypes))
                 {
                     var ops = function.operand
@@ -218,13 +218,13 @@ public void ProcessExpressionDef(
                         foreach (var tag in tags)
                         {
                             string[] values = [tag.value ?? ""];
-                            _libraryContext.LibraryDefinitions.AddTag(_libraryContext.LibraryKey, expressionDef.name,
+                            _libraryContext.LibraryDefinitions.AddTag(_libraryContext.LibraryVersionedIdentifier, expressionDef.name,
                                 functionParameterTypes, tag.name, values);
                         }
                     }
 
                     Type[] signature = functionParameterTypes ?? [];
-                    _libraryContext.LibraryDefinitions.Add(_libraryContext.LibraryKey, expressionDef.name, signature,
+                    _libraryContext.LibraryDefinitions.Add(_libraryContext.LibraryVersionedIdentifier, expressionDef.name, signature,
                         lambda);
                 }
             }
@@ -240,10 +240,10 @@ public void ProcessIncludes(
                             ?? throw this.NewExpressionBuildingException(
                                 $"Include {includeDef.localId} does not have a alias.");
 
-                var libNav = includeDef.NameAndVersion(false) ??
+                var libNav = includeDef.GetVersionedIdentifier(false) ??
                              throw this.NewExpressionBuildingException(
                                  $"Include {includeDef.localId} does not have a well-formed name and version");
-                _libraryContext.AddAliasForNameAndVersion(alias, libNav);
+                _libraryContext.AddAliasLibraryVersionedIdentifier(alias, libNav);
             }
         });
 
@@ -253,7 +253,7 @@ public void ProcessParameterDef(
         {
             using (PushElement(parameter))
             {
-                if (_libraryContext.LibraryDefinitions.ContainsKey(_libraryContext.LibraryKey, parameter.name!))
+                if (_libraryContext.LibraryDefinitions.ContainsKey(_libraryContext.LibraryVersionedIdentifier, parameter.name!))
                     throw this.NewExpressionBuildingException($"There is already a definition named {parameter.name}",
                         null);
 
@@ -262,13 +262,13 @@ public void ProcessParameterDef(
                     defaultValue = TranslateArg(parameter.@default).NewTypeAsExpression<object>();
                 else defaultValue = NullExpression.Object;
 
-                var resolveParam = _cqlContextBinder.ResolveParameter(_libraryContext.LibraryKey, parameter.name, defaultValue);
+                var resolveParam = _cqlContextBinder.ResolveParameter(_libraryContext.LibraryVersionedIdentifier, parameter.name, defaultValue);
 
                 var parameterType = TypeFor(parameter.parameterTypeSpecifier)!;
                 var cast = _cqlOperatorsBinder.CastToType(resolveParam, parameterType);
                 // e.g. (bundle, context) => context.Parameters["Measurement Period"]
                 var lambda = Expression.Lambda(cast, CqlExpressions.ParameterExpression);
-                _libraryContext.LibraryDefinitions.Add(_libraryContext.LibraryKey, parameter.name!, lambda);
+                _libraryContext.LibraryDefinitions.Add(_libraryContext.LibraryVersionedIdentifier, parameter.name!, lambda);
             }
         });
 
@@ -283,7 +283,7 @@ public void ProcessValueSetDef(
                     Expression.Constant(valueSetDef.version, typeof(string)));
                 var contextParameter = CqlExpressions.ParameterExpression;
                 var lambda = Expression.Lambda(@new, contextParameter);
-                _libraryContext.LibraryDefinitions.Add(_libraryContext.LibraryKey, valueSetDef.name!, lambda);
+                _libraryContext.LibraryDefinitions.Add(_libraryContext.LibraryVersionedIdentifier, valueSetDef.name!, lambda);
             }
         });
 }
diff --git a/Cql/Cql.Compiler/ExpressionBuilderContext.TypeFor.cs b/Cql/Cql.Compiler/ExpressionBuilderContext.TypeFor.cs
@@ -33,7 +33,7 @@ partial class ExpressionBuilderContext
         {
             case ExpressionRef expressionRef:
             {
-                var libraryName = expressionRef.libraryName ?? _libraryContext.LibraryKey;
+                var libraryName = expressionRef.libraryName ?? _libraryContext.LibraryVersionedIdentifier;
                 if (!_libraryContext.LibraryDefinitions.TryGetValue(libraryName, expressionRef.name, out var definition))
                 {
                     if (throwIfNotFound)

diff --git a/Cql/Cql.Compiler/ExpressionBuilderContext.cs b/Cql/Cql.Compiler/ExpressionBuilderContext.cs
@@ -1139,7 +1139,7 @@ protected Expression ExpressionRef(ExpressionRef expressionRef)
 
     protected Expression ParameterRef(ParameterRef op)
     {
-        if (_libraryContext.LibraryDefinitions.TryGetValue(_libraryContext.LibraryKey, op.name!, out var lambda) && lambda != null)
+        if (_libraryContext.LibraryDefinitions.TryGetValue(_libraryContext.LibraryVersionedIdentifier, op.name!, out var lambda) && lambda != null)
         {
             var invoke = InvokeDefinitionThroughRuntimeContext(op.name!, null, lambda);
             return invoke;
@@ -1161,7 +1161,7 @@ protected Expression InvokeDefinedFunctionThroughRuntimeContext(
         Expression[] arguments,
         TypeSpecifier returnType)
     {
-        string libraryName = _libraryContext.GetNameAndVersionFromAlias(libraryAlias, throwError: false)
+        string libraryName = _libraryContext.GetLibraryVersionedIdentifierFromAlias(libraryAlias, throwError: false)
                              ?? throw this.NewExpressionBuildingException($"Local library {libraryAlias} is not defined; are you missing a using statement?");
 
         var rtt = TypeFor(returnType) ?? throw this.NewExpressionBuildingException($"Unable to resolve type for {returnType}");
@@ -1216,7 +1216,7 @@ protected Expression InvokeDefinitionThroughRuntimeContext(
         string? libraryAlias,
         Type definitionReturnType)
     {
-        string libraryName = _libraryContext.GetNameAndVersionFromAlias(libraryAlias, throwError: false)
+        string libraryName = _libraryContext.GetLibraryVersionedIdentifierFromAlias(libraryAlias, throwError: false)
                              ?? throw this.NewExpressionBuildingException($"Local library {libraryAlias} is not defined; are you missing a using statement?");
 
         var funcType = typeof(Func<,>).MakeGenericType(typeof(CqlContext), definitionReturnType);