260 refactor pass tuple types as a result from expressionbuilder not via the typemanager

Cql/CodeGeneration.NET/AssemblyCompiler.cs

@@ -28,21 +28,19 @@ namespace Hl7.Cql.CodeGeneration.NET
 {
     internal class AssemblyCompiler
     {
-        private readonly TypeManager _typeManager;
         private readonly CSharpLibrarySetToStreamsWriter _cSharpLibrarySetToStreamsWriter;
         private readonly CSharpCodeStreamPostProcessor? _cSharpCodeStreamPostProcessor;
         private readonly Lazy<Assembly[]> _referencesLazy;
         private readonly AssemblyDataPostProcessor? _assemblyDataPostProcessor;
 
         public AssemblyCompiler(
             CSharpLibrarySetToStreamsWriter cSharpLibrarySetToStreamsWriter,
-            TypeManager typeManager,
+            TypeResolver typeResolver,
             CSharpCodeStreamPostProcessor? cSharpCodeStreamPostProcessor = null,
             AssemblyDataPostProcessor? assemblyDataPostProcessor = null)
         {
             _assemblyDataPostProcessor = assemblyDataPostProcessor;
             _cSharpLibrarySetToStreamsWriter = cSharpLibrarySetToStreamsWriter;
-            _typeManager = typeManager;
             _cSharpCodeStreamPostProcessor = cSharpCodeStreamPostProcessor;
             _referencesLazy = new Lazy<Assembly[]>(
                 () =>
@@ -62,7 +60,7 @@ public AssemblyCompiler(
 
                         }                                        // @formatter on
                         .Select(type => type.Assembly)
-                        .Concat(typeManager.Resolver.ModelAssemblies)
+                        .Concat(typeResolver.ModelAssemblies)
                         .Distinct()
                         .ToArray();
                     return references;

Cql/CodeGeneration.NET/PostProcessors/WriteToFileCSharpCodeStreamPostProcessor.cs

@@ -11,18 +11,13 @@
 
 namespace Hl7.Cql.CodeGeneration.NET.PostProcessors;
 
-internal class WriteToFileCSharpCodeStreamPostProcessor : CSharpCodeStreamPostProcessor
+internal class WriteToFileCSharpCodeStreamPostProcessor(
+    IOptions<CSharpCodeWriterOptions> csharpCodeWriterOptions,
+    ILogger<WriteToFileCSharpCodeStreamPostProcessor> logger)
+    : CSharpCodeStreamPostProcessor
 {
-    private readonly CSharpCodeWriterOptions _csharpCodeWriterOptions;
-    private readonly ILogger<WriteToFileCSharpCodeStreamPostProcessor> _logger;
-
-    public WriteToFileCSharpCodeStreamPostProcessor(
-        IOptions<CSharpCodeWriterOptions> csharpCodeWriterOptions,
-        ILogger<WriteToFileCSharpCodeStreamPostProcessor> logger)
-    {
-        _logger = logger;
-        _csharpCodeWriterOptions = csharpCodeWriterOptions.Value;
-    }
+    private readonly CSharpCodeWriterOptions _csharpCodeWriterOptions = csharpCodeWriterOptions.Value;
+    private readonly ILogger<WriteToFileCSharpCodeStreamPostProcessor> _logger = logger;
 
     public override void ProcessStream(string name, Stream stream)
     {

Cql/CoreTests/ExpressionBuilderTests.cs

@@ -18,7 +18,7 @@ public void AggregateQueries_1_0_0()
             var cqlCompilerServices = CqlServicesInitializer.CreateCqlCompilerServices(disposeContext.Token);
             var elm = new FileInfo(@"Input\ELM\Test\Aggregates-1.0.0.json");
             var elmPackage = Hl7.Cql.Elm.Library.LoadFromJson(elm);
-            var definitions = cqlCompilerServices.LibraryExpressionBuilder.ProcessLibrary(elmPackage);
+            var definitions = cqlCompilerServices.LibraryExpressionBuilderScoped().ProcessLibrary(elmPackage);
             Assert.IsNotNull(definitions);
             Assert.IsTrue(definitions.Libraries.Any());
         }
@@ -30,7 +30,7 @@ public void FHIRConversionTest_1_0_0()
             var cqlCompilerServices = CqlServicesInitializer.CreateCqlCompilerServices(disposeContext.Token);
             var elm = new FileInfo(@"Input\ELM\HL7\FHIRConversionTest.json");
             var elmPackage = Hl7.Cql.Elm.Library.LoadFromJson(elm);
-            var definitions = cqlCompilerServices.LibraryExpressionBuilder.ProcessLibrary(elmPackage);
+            var definitions = cqlCompilerServices.LibraryExpressionBuilderScoped().ProcessLibrary(elmPackage);
             Assert.IsNotNull(definitions);
             Assert.IsTrue(definitions.Libraries.Any());
         }
@@ -42,7 +42,7 @@ public void QueriesTest_1_0_0()
             var cqlCompilerServices = CqlServicesInitializer.CreateCqlCompilerServices(disposeContext.Token);
             var elm = new FileInfo(@"Input\ELM\Test\QueriesTest-1.0.0.json");
             var elmPackage = Hl7.Cql.Elm.Library.LoadFromJson(elm);
-            var definitions = cqlCompilerServices.LibraryExpressionBuilder.ProcessLibrary(elmPackage);
+            var definitions = cqlCompilerServices.LibraryExpressionBuilderScoped().ProcessLibrary(elmPackage);
             Assert.IsNotNull(definitions);
             Assert.IsTrue(definitions.Libraries.Any());
         }
@@ -66,7 +66,7 @@ public void Medication_Request_Example_Test()
             var fs = new FhirDateTime(fdts);
             Assert.AreEqual(fdt, fs);
 
-            var definitions = cqlCompilerServices.LibrarySetExpressionBuilder.ProcessLibrarySet(librarySet);
+            var definitions = cqlCompilerServices.LibrarySetExpressionBuilderScoped().ProcessLibrarySet(librarySet);
             Assert.IsNotNull(definitions);
             Assert.IsTrue(definitions.Libraries.Any());
         }
@@ -77,7 +77,7 @@ public void Get_Property_Uses_TypeResolver()
         {
             using var disposeContext = new DisposeContext();
             var cqlCompilerServices = CqlServicesInitializer.CreateCqlCompilerServices(disposeContext.Token);
-            var property = ExpressionBuilder.GetProperty(typeof(MeasureReport.PopulationComponent), "id", cqlCompilerServices.TypeManager.Resolver)!;
+            var property = ExpressionBuilder.GetProperty(typeof(MeasureReport.PopulationComponent), "id", cqlCompilerServices.TypeResolver)!;
             Assert.AreEqual(typeof(Element), property.DeclaringType);
             Assert.AreEqual(nameof(Element.ElementId), property.Name);
         }

Cql/CoreTests/LibrarySetExpressionBuilderTests.cs

@@ -16,7 +16,7 @@ public void LoadLibraryAndDependencies_CrossLibraryCodeSystems()
 
         LibrarySet librarySet = new();
         librarySet.LoadLibraryAndDependencies(LibrarySetsDirs.Cms.ElmDir, "CumulativeMedicationDuration");
-        var definitionDictionary = cqlCompilerServices.LibrarySetExpressionBuilder.ProcessLibrarySet(librarySet);
+        var definitionDictionary = cqlCompilerServices.LibrarySetExpressionBuilderScoped().ProcessLibrarySet(librarySet);
         var lambdaExpression = definitionDictionary["CumulativeMedicationDuration-4.0.000", "Every eight hours (qualifier value)"];
         Assert.IsNotNull(lambdaExpression);
 

Cql/CoreTests/PrimitiveTests.cs

@@ -3411,7 +3411,7 @@ public void Aggregate_Query_Test()
             var librarySet = new LibrarySet();
             librarySet.LoadLibraryAndDependencies(new DirectoryInfo("Input\\ELM\\Test"),"Aggregates", "1.0.0");
             var elmPackage = librarySet.GetLibrary("Aggregates-1.0.0");
-            var definitions = cqlCodeGenerationServices.GetCqlCompilerServices().LibraryExpressionBuilder.ProcessLibrary(elmPackage);
+            var definitions = cqlCodeGenerationServices.GetCqlCompilerServices().LibraryExpressionBuilderScoped().ProcessLibrary(elmPackage);
             var writer = cqlCodeGenerationServices.CSharpLibrarySetToStreamsWriter;
             var isDone = false;
             writer.ProcessDefinitions(

Cql/CoreTests/QueriesTest.cs

@@ -23,7 +23,7 @@ public static void Initialize(TestContext context)
 
             var elm = new FileInfo(@"Input\ELM\Test\QueriesTest-1.0.0.json");
             var elmPackage = Hl7.Cql.Elm.Library.LoadFromJson(elm);
-            var definitions = cqlCompilerServices.LibraryExpressionBuilder.ProcessLibrary(elmPackage);
+            var definitions = cqlCompilerServices.LibraryExpressionBuilderScoped().ProcessLibrary(elmPackage);
             QueriesDefinitions = definitions.CompileAll();
             ValueSets = new HashValueSetDictionary();
             ValueSets.Add("http://hl7.org/fhir/ValueSet/example-expansion",
@@ -32,7 +32,7 @@ public static void Initialize(TestContext context)
 
             elm = new FileInfo(@"Input\ELM\Test\Aggregates-1.0.0.json");
             elmPackage = Hl7.Cql.Elm.Library.LoadFromJson(elm);
-            cqlCompilerServices.LibraryExpressionBuilder.ProcessLibrary(elmPackage, libraryDefinitions: definitions);
+            cqlCompilerServices.LibraryExpressionBuilderScoped().ProcessLibrary(elmPackage, libraryDefinitions: definitions);
             AggregatesDefinitions = definitions.CompileAll();
         }
 

Cql/Cql.Compiler/AmbiguousOverloadCorrector.cs

@@ -6,7 +6,6 @@
  * available at https://raw.githubusercontent.com/FirelyTeam/firely-cql-sdk/main/LICENSE
  */
 
-using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using Hl7.Cql.Elm;

Cql/Cql.Compiler/CqlOperatorsBinder.cs

@@ -24,38 +24,27 @@ namespace Hl7.Cql.Compiler
     /// by converting the method name and <see cref="Expression"/> arguments
     /// to the appropriate overload of the method.
     /// </summary>
-    internal partial class CqlOperatorsBinder
+    /// <param name="logger">
+    /// The logger used.
+    /// </param>
+    /// <param name="typeResolver">
+    /// The type resolver used.
+    /// Note that if you provide a different instance of this class to <see cref="CqlOperators"/>, you will get errors at runtime.
+    /// </param>
+    /// <param name="typeConverter">
+    /// If provided, this binding will use the supplied instance to determine whether
+    /// a conversion is possible.  Note that if you provide a different instance of this class to <see cref="CqlOperators"/>,
+    /// you may get errors at runtime, because this binding will think a conversion is possible when at runtime it is not.
+    /// If not provided, only conversions defined in <see cref="CqlOperators"/> will be used.
+    /// </param>
+    internal partial class CqlOperatorsBinder(
+        ILogger<CqlOperatorsBinder> logger,
+        TypeResolver typeResolver,
+        TypeConverter typeConverter)
     {
-        private readonly ILogger<CqlOperatorsBinder> _logger;
-        private readonly TypeConverter _typeConverter;
-        private readonly TypeResolver _typeResolver;
-
-
-        /// <summary>
-        /// Creates an instance.
-        /// </summary>
-        /// <param name="logger">
-        /// The logger used.
-        /// </param>
-        /// <param name="typeResolver">
-        /// The type resolver used.
-        /// Note that if you provide a different instance of this class to <see cref="CqlOperators"/>, you will get errors at runtime.
-        /// </param>
-        /// <param name="typeConverter">
-        /// If provided, this binding will use the supplied instance to determine whether
-        /// a conversion is possible.  Note that if you provide a different instance of this class to <see cref="CqlOperators"/>,
-        /// you may get errors at runtime, because this binding will think a conversion is possible when at runtime it is not.
-        /// If not provided, only conversions defined in <see cref="CqlOperators"/> will be used.
-        /// </param>
-        public CqlOperatorsBinder(
-            ILogger<CqlOperatorsBinder> logger,
-            TypeResolver typeResolver,
-            TypeConverter typeConverter)
-        {
-            _typeConverter = typeConverter;
-            _typeResolver = typeResolver;
-            _logger = logger;
-        }
+        private readonly ILogger<CqlOperatorsBinder> _logger = logger;
+        private readonly TypeResolver _typeResolver = typeResolver;
+        private readonly TypeConverter _typeConverter = typeConverter;
 
         /// <summary>
         /// Facilitates binding to <see cref="ICqlOperators"/> methods,

Cql/Cql.Compiler/ExpressionBuilder.cs

@@ -8,9 +8,9 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq.Expressions;
 using System.Reflection;
 using Hl7.Cql.Abstractions;
-using Hl7.Cql.Conversion;
 using Hl7.Cql.Elm;
 using Microsoft.Extensions.Logging;
 
@@ -20,71 +20,60 @@ internal class ExpressionBuilder(
     ILogger<ExpressionBuilder> logger,
     ExpressionBuilderSettings expressionBuilderSettings,
     CqlOperatorsBinder cqlOperatorsBinder,
-    TypeManager typeManager,
-    TypeConverter typeConverter,
+    TupleBuilderCache tupleBuilderCache,
     TypeResolver typeResolver,
     CqlContextBinder cqlContextBinder)
 {
-    internal readonly CqlOperatorsBinder _cqlOperatorsBinder = cqlOperatorsBinder;
-    internal readonly CqlContextBinder _cqlContextBinder = cqlContextBinder;
-    internal readonly TypeManager _typeManager = typeManager;
-    internal readonly ILogger<ExpressionBuilder> _logger = logger;
-    internal readonly TypeConverter _typeConverter = typeConverter;
-    internal readonly TypeResolver _typeResolver = typeResolver;
-    internal readonly ExpressionBuilderSettings _expressionBuilderSettings = expressionBuilderSettings;
+    private readonly ILogger<ExpressionBuilder> _logger = logger;
+    private readonly ExpressionBuilderSettings _expressionBuilderSettings = expressionBuilderSettings;
+    private readonly CqlOperatorsBinder _cqlOperatorsBinder = cqlOperatorsBinder;
+    private readonly TupleBuilderCache _tupleBuilderCache = tupleBuilderCache;
+    private readonly TypeResolver _typeResolver = typeResolver;
+    private readonly CqlContextBinder _cqlContextBinder = cqlContextBinder;
 
     /*
      * The ExpressionBuilderContext is created anew for each of the ProcessXXX methods.
      * This works, because all but the ProcessExpressionDef methods only change state
-     * on the ILibraryExpressionBuilderContext.
+     * on the LibraryExpressionBuilderContext.
      *
      * Only ProcessExpressionDef changes state on the ExpressionBuilderContext.
      */
 
-    public void ProcessIncludes(ILibraryExpressionBuilderContext libCtx, IncludeDef includeDef)
-    {
-        ExpressionBuilderContext context = new ExpressionBuilderContext(this, libCtx);
-        context.ProcessIncludes(includeDef);
-    }
+    public void ProcessIncludes(LibraryExpressionBuilderContext libCtx, IncludeDef includeDef) =>
+        NewExpressionBuilderContext(libCtx)
+            .ProcessIncludes(includeDef);
 
-    public void ProcessValueSetDef(ILibraryExpressionBuilderContext libCtx, ValueSetDef valueSetDef)
-    {
-        ExpressionBuilderContext context = new ExpressionBuilderContext(this, libCtx);
-        context.ProcessValueSetDef(valueSetDef);
-    }
+    internal ExpressionBuilderContext NewExpressionBuilderContext(
+        LibraryExpressionBuilderContext libCtx,
+        Dictionary<string, ParameterExpression>? operands = null) =>
+        new(_logger, _expressionBuilderSettings, _cqlOperatorsBinder, _tupleBuilderCache, _typeResolver, _cqlContextBinder, libCtx, operands);
+
+    public void ProcessValueSetDef(LibraryExpressionBuilderContext libCtx, ValueSetDef valueSetDef) =>
+        NewExpressionBuilderContext(libCtx)
+            .ProcessValueSetDef(valueSetDef);
 
     public void ProcessCodeDef(
-        ILibraryExpressionBuilderContext libCtx,
+        LibraryExpressionBuilderContext libCtx,
         CodeDef codeDef,
-        HashSet<(string codeName, string codeSystemUrl)> foundCodeNameCodeSystemUrls)
-    {
-        ExpressionBuilderContext context = new ExpressionBuilderContext(this, libCtx);
-        context.ProcessCodeDef(codeDef, foundCodeNameCodeSystemUrls);
-    }
+        HashSet<(string codeName, string codeSystemUrl)> foundCodeNameCodeSystemUrls) =>
+        NewExpressionBuilderContext(libCtx)
+            .ProcessCodeDef(codeDef, foundCodeNameCodeSystemUrls);
 
-    public void ProcessCodeSystemDef(ILibraryExpressionBuilderContext libCtx, CodeSystemDef codeSystemDef)
-    {
-        ExpressionBuilderContext context = new ExpressionBuilderContext(this, libCtx);
-        context.ProcessCodeSystemDef(codeSystemDef);
-    }
+    public void ProcessCodeSystemDef(LibraryExpressionBuilderContext libCtx, CodeSystemDef codeSystemDef) =>
+        NewExpressionBuilderContext(libCtx)
+            .ProcessCodeSystemDef(codeSystemDef);
 
-    public void ProcessConceptDef(ILibraryExpressionBuilderContext libCtx, ConceptDef conceptDef)
-    {
-        ExpressionBuilderContext context = new ExpressionBuilderContext(this, libCtx);
-        context.ProcessConceptDef(conceptDef);
-    }
+    public void ProcessConceptDef(LibraryExpressionBuilderContext libCtx, ConceptDef conceptDef) =>
+        NewExpressionBuilderContext(libCtx)
+            .ProcessConceptDef(conceptDef);
 
-    public void ProcessParameterDef(ILibraryExpressionBuilderContext libCtx, ParameterDef parameterDef)
-    {
-        ExpressionBuilderContext context = new ExpressionBuilderContext(this, libCtx);
-        context.ProcessParameterDef(parameterDef);
-    }
+    public void ProcessParameterDef(LibraryExpressionBuilderContext libCtx, ParameterDef parameterDef) =>
+        NewExpressionBuilderContext(libCtx)
+            .ProcessParameterDef(parameterDef);
 
-    public void ProcessExpressionDef(ILibraryExpressionBuilderContext libCtx, ExpressionDef expressionDef)
-    {
-        ExpressionBuilderContext context = new ExpressionBuilderContext(this, libCtx, new());
-        context.ProcessExpressionDef(expressionDef);
-    }
+    public void ProcessExpressionDef(LibraryExpressionBuilderContext libCtx, ExpressionDef expressionDef) =>
+        NewExpressionBuilderContext(libCtx, new Dictionary<string, ParameterExpression>())
+            .ProcessExpressionDef(expressionDef);
 
     internal static PropertyInfo? GetProperty(Type type, string name, TypeResolver typeResolver)
     {

Cql/Cql.Compiler/ExpressionBuilderContext.DebuggerView.cs

@@ -52,7 +52,7 @@ private IPopToken PushElement(Elm.Element element)
 
     private readonly record struct ExpressionBuilderNode : IBuilderContext
     {
-        public ILibraryExpressionBuilderContext LibraryExpressionBuilder { get; init; }
+        public LibraryExpressionBuilderContext LibraryExpressionBuilder { get; init; }
         public IReadOnlyList<Elm.Element> ElementStackList { get; init; }
         public int ElementStackPosition { get; init; }
 

Cql/Cql.Compiler/ExpressionBuilderContext.LibraryDefs.cs

@@ -13,7 +13,6 @@
 using Hl7.Cql.Compiler.Infrastructure;
 using Hl7.Cql.Elm;
 using Hl7.Cql.Primitives;
-using Hl7.Cql.Runtime;
 using Microsoft.Extensions.Logging;
 using Expression = System.Linq.Expressions.Expression;
 
@@ -131,6 +130,9 @@ public void ProcessExpressionDef(
         ExpressionDef expressionDef) =>
         this.CatchRethrowExpressionBuildingException(_ =>
         {
+            if (_operands is null)
+                throw new InvalidOperationException("Operands dictionary is null.");
+
             using (PushElement(expressionDef))
             {
                 if (string.IsNullOrWhiteSpace(expressionDef.name))
@@ -260,7 +262,7 @@ public void ProcessParameterDef(
                     defaultValue = TranslateArg(parameter.@default).NewTypeAsExpression<object>();
                 else defaultValue = NullExpression.Object;
 
-                var resolveParam = _contextBinder.ResolveParameter(_libraryContext.LibraryKey, parameter.name, defaultValue);
+                var resolveParam = _cqlContextBinder.ResolveParameter(_libraryContext.LibraryKey, parameter.name, defaultValue);
 
                 var parameterType = TypeFor(parameter.parameterTypeSpecifier)!;
                 var cast = _cqlOperatorsBinder.CastToType(resolveParam, parameterType);