Add support for BindPaths and building .wixlibs

5 files changed, 363 insertions, 138 deletions

diff --git a/src/WixToolset.Core/CommandLine/BuildCommand.cs b/src/WixToolset.Core/CommandLine/BuildCommand.cs
index ffb48305..d8954cb7 100644
--- a/src/WixToolset.Core/CommandLine/BuildCommand.cs
+++ b/src/WixToolset.Core/CommandLine/BuildCommand.cs
@@ -7,17 +7,24 @@ namespace WixToolset.Core
     using System.IO;
     using System.Linq;
     using WixToolset.Data;
+    using WixToolset.Extensibility;
 
     internal class BuildCommand : ICommand
     {
-        public BuildCommand(IEnumerable<SourceFile> sources, IDictionary<string, string> preprocessorVariables, IEnumerable<string> locFiles, string outputPath, IEnumerable<string> cultures, string contentsFile, string outputsFile, string builtOutputsFile, string wixProjectFile)
+        public BuildCommand(IEnumerable<SourceFile> sources, IDictionary<string, string> preprocessorVariables, IEnumerable<string> locFiles, IEnumerable<string> libraryFiles, string outputPath, OutputType outputType, IEnumerable<string> cultures, bool bindFiles, IEnumerable<BindPath> bindPaths, string intermediateFolder, string contentsFile, string outputsFile, string builtOutputsFile, string wixProjectFile)
         {
             this.LocFiles = locFiles;
+            this.LibraryFiles = libraryFiles;
             this.PreprocessorVariables = preprocessorVariables;
             this.SourceFiles = sources;
             this.OutputPath = outputPath;
+            this.OutputType = outputType;
 
             this.Cultures = cultures;
+            this.BindFiles = bindFiles;
+            this.BindPaths = bindPaths;
+
+            this.IntermediateFolder = intermediateFolder ?? Path.GetTempPath();
             this.ContentsFile = contentsFile;
             this.OutputsFile = outputsFile;
             this.BuiltOutputsFile = builtOutputsFile;
@@ -26,14 +33,24 @@ namespace WixToolset.Core
 
         public IEnumerable<string> LocFiles { get; }
 
+        public IEnumerable<string> LibraryFiles { get; }
+
         private IEnumerable<SourceFile> SourceFiles { get; }
 
         private IDictionary<string, string> PreprocessorVariables { get; }
 
         private string OutputPath { get; }
 
+        private OutputType OutputType { get; }
+
         public IEnumerable<string> Cultures { get; }
 
+        public bool BindFiles { get; }
+
+        public IEnumerable<BindPath> BindPaths { get; }
+
+        public string IntermediateFolder { get; }
+
         public string ContentsFile { get; }
 
         public string OutputsFile { get; }
@@ -44,21 +61,135 @@ namespace WixToolset.Core
 
         public int Execute()
         {
-            var intermediates = CompilePhase();
+            var intermediates = this.CompilePhase();
+
+            var tableDefinitions = new TableDefinitionCollection(WindowsInstallerStandard.GetTableDefinitions());
+
+            if (this.OutputType == OutputType.Library)
+            {
+                this.LibraryPhase(intermediates, tableDefinitions);
+            }
+            else
+            {
+                var output = this.LinkPhase(intermediates, tableDefinitions);
+
+                if (!Messaging.Instance.EncounteredError)
+                {
+                    this.BindPhase(output, tableDefinitions);
+                }
+            }
+
+            return Messaging.Instance.LastErrorNumber;
+        }
+
+        private IEnumerable<Intermediate> CompilePhase()
+        {
+            var intermediates = new List<Intermediate>();
+
+            var preprocessor = new Preprocessor();
+
+            var compiler = new Compiler();
+
+            foreach (var sourceFile in this.SourceFiles)
+            {
+                var document = preprocessor.Process(sourceFile.SourcePath, this.PreprocessorVariables);
+
+                var intermediate = compiler.Compile(document);
+
+                intermediates.Add(intermediate);
+            }
+
+            return intermediates;
+        }
+
+        private void LibraryPhase(IEnumerable<Intermediate> intermediates, TableDefinitionCollection tableDefinitions)
+        {
+            var localizations = this.LoadLocalizationFiles(tableDefinitions).ToList();
+
+            // If there was an error adding localization files, then bail.
+            if (Messaging.Instance.EncounteredError)
+            {
+                return;
+            }
 
             var sections = intermediates.SelectMany(i => i.Sections).ToList();
 
+            LibraryBinaryFileResolver resolver = null;
+
+            if (this.BindFiles)
+            {
+                resolver = new LibraryBinaryFileResolver();
+                resolver.FileManagers = new List<IBinderFileManager> { new BinderFileManager() }; ;
+                resolver.VariableResolver = new WixVariableResolver();
+
+                BinderFileManagerCore core = new BinderFileManagerCore();
+                core.AddBindPaths(this.BindPaths, BindStage.Normal);
+
+                foreach (var fileManager in resolver.FileManagers)
+                {
+                    fileManager.Core = core;
+                }
+            }
+
+            var librarian = new Librarian();
+
+            var library = librarian.Combine(sections, localizations, resolver);
+
+            library?.Save(this.OutputPath);
+        }
+
+        private Output LinkPhase(IEnumerable<Intermediate> intermediates, TableDefinitionCollection tableDefinitions)
+        {
+            var sections = intermediates.SelectMany(i => i.Sections).ToList();
+
+            sections.AddRange(SectionsFromLibraries(tableDefinitions));
+
             var linker = new Linker();
 
-            var output = linker.Link(sections, OutputType.Product);
+            var output = linker.Link(sections, this.OutputType);
+
+            return output;
+        }
+
+        private IEnumerable<Section> SectionsFromLibraries(TableDefinitionCollection tableDefinitions)
+        {
+            var sections = new List<Section>();
+
+            if (this.LibraryFiles != null)
+            {
+                foreach (var libraryFile in this.LibraryFiles)
+                {
+                    try
+                    {
+                        var library = Library.Load(libraryFile, tableDefinitions, false);
+
+                        sections.AddRange(library.Sections);
+                    }
+                    catch (WixCorruptFileException e)
+                    {
+                        Messaging.Instance.OnMessage(e.Error);
+                    }
+                    catch (WixUnexpectedFileFormatException e)
+                    {
+                        Messaging.Instance.OnMessage(e.Error);
+                    }
+                }
+            }
 
-            var localizer = new Localizer();
+            return sections;
+        }
+
+        private void BindPhase(Output output, TableDefinitionCollection tableDefinitions)
+        {
+            var localizations = this.LoadLocalizationFiles(tableDefinitions).ToList();
+
+            var localizer = new Localizer(localizations);
+
+            var resolver = new WixVariableResolver(localizer);
 
             var binder = new Binder();
-            binder.TempFilesLocation = Path.GetTempPath();
-            binder.WixVariableResolver = new WixVariableResolver();
-            binder.WixVariableResolver.Localizer = localizer;
-            binder.AddExtension(new BinderFileManager());
+            binder.TempFilesLocation = this.IntermediateFolder;
+            binder.WixVariableResolver = resolver;
             binder.SuppressValidation = true;
 
             binder.ContentsFile = this.ContentsFile;
@@ -66,35 +197,50 @@ namespace WixToolset.Core
             binder.BuiltOutputsFile = this.BuiltOutputsFile;
             binder.WixprojectFile = this.WixProjectFile;
 
-            foreach (var loc in this.LocFiles)
+            if (this.BindPaths != null)
             {
-                var localization = Localizer.ParseLocalizationFile(loc, linker.TableDefinitions);
-                binder.WixVariableResolver.Localizer.AddLocalization(localization);
+                binder.BindPaths.AddRange(this.BindPaths);
             }
 
-            binder.Bind(output, this.OutputPath);
+            binder.AddExtension(new BinderFileManager());
 
-            return 0;
+            binder.Bind(output, this.OutputPath);
         }
 
-        private IEnumerable<Intermediate> CompilePhase()
+        private IEnumerable<Localization> LoadLocalizationFiles(TableDefinitionCollection tableDefinitions)
         {
-            var intermediates = new List<Intermediate>();
-
-            var preprocessor = new Preprocessor();
+            foreach (var loc in this.LocFiles)
+            {
+                var localization = Localizer.ParseLocalizationFile(loc, tableDefinitions);
 
-            var compiler = new Compiler();
+                yield return localization;
+            }
+        }
 
-            foreach (var sourceFile in this.SourceFiles)
-            {
-                var document = preprocessor.Process(sourceFile.SourcePath, this.PreprocessorVariables);
+        /// <summary>
+        /// File resolution mechanism to create binary library.
+        /// </summary>
+        private class LibraryBinaryFileResolver : ILibraryBinaryFileResolver
+        {
+            public IEnumerable<IBinderFileManager> FileManagers { get; set; }
 
-                var intermediate = compiler.Compile(document);
+            public WixVariableResolver VariableResolver { get; set; }
 
-                intermediates.Add(intermediate);
+            public string Resolve(SourceLineNumber sourceLineNumber, string table, string path)
+            {
+                string resolvedPath = this.VariableResolver.ResolveVariables(sourceLineNumber, path, false);
+
+                foreach (IBinderFileManager fileManager in this.FileManagers)
+                {
+                    string finalPath = fileManager.ResolveFile(resolvedPath, table, sourceLineNumber, BindStage.Normal);
+                    if (!String.IsNullOrEmpty(finalPath))
+                    {
+                        return finalPath;
+                    }
+                }
+
+                return null;
             }
-
-            return intermediates;
         }
     }
 }
diff --git a/src/WixToolset.Core/CommandLine/CommandLine.cs b/src/WixToolset.Core/CommandLine/CommandLine.cs
index 440ae9ef..cac54091 100644
--- a/src/WixToolset.Core/CommandLine/CommandLine.cs
+++ b/src/WixToolset.Core/CommandLine/CommandLine.cs
@@ -57,14 +57,20 @@ namespace WixToolset.Core
             var showVersion = false;
             var outputFolder = String.Empty;
             var outputFile = String.Empty;
-            var sourceFile = String.Empty;
+            var outputType = String.Empty;
             var verbose = false;
             var files = new List<string>();
             var defines = new List<string>();
             var includePaths = new List<string>();
             var locFiles = new List<string>();
+            var libraryFiles = new List<string>();
             var suppressedWarnings = new List<int>();
 
+            var bindFiles = false;
+            var bindPaths = new List<string>();
+
+            var intermediateFolder = String.Empty;
+
             var cultures = new List<string>();
             var contentsFile = String.Empty;
             var outputsFile = String.Empty;
@@ -84,6 +90,14 @@ namespace WixToolset.Core
                             cmdline.ShowHelp = true;
                             return true;
 
+                        case "bindfiles":
+                            bindFiles = true;
+                            return true;
+
+                        case "bindpath":
+                            cmdline.GetNextArgumentOrError(bindPaths);
+                            return true;
+
                         case "cultures":
                             cmdline.GetNextArgumentOrError(cultures);
                             return true;
@@ -110,15 +124,27 @@ namespace WixToolset.Core
                             cmdline.GetNextArgumentOrError(includePaths);
                             return true;
 
+                        case "intermediatefolder":
+                            cmdline.GetNextArgumentOrError(ref intermediateFolder);
+                            return true;
+
                         case "loc":
                             cmdline.GetNextArgumentAsFilePathOrError(locFiles, "localization files");
                             return true;
 
+                        case "lib":
+                            cmdline.GetNextArgumentAsFilePathOrError(libraryFiles, "library files");
+                            return true;
+
                         case "o":
                         case "out":
                             cmdline.GetNextArgumentOrError(ref outputFile);
                             return true;
 
+                        case "outputtype":
+                            cmdline.GetNextArgumentOrError(ref outputType);
+                            return true;
+
                         case "nologo":
                             showLogo = false;
                             return true;
@@ -143,6 +169,8 @@ namespace WixToolset.Core
                 }
             });
 
+            Messaging.Instance.ShowVerboseMessages = verbose;
+
             if (showVersion)
             {
                 return new VersionCommand();
@@ -164,8 +192,10 @@ namespace WixToolset.Core
                     {
                         var sourceFiles = GatherSourceFiles(files, outputFolder);
                         var variables = GatherPreprocessorVariables(defines);
+                        var bindPathList = GatherBindPaths(bindPaths);
                         var extensions = cli.ExtensionManager;
-                        return new BuildCommand(sourceFiles, variables, locFiles, outputFile, cultures, contentsFile, outputsFile, builtOutputsFile, wixProjectFile);
+                        var type = CalculateOutputType(outputType, outputFile);
+                        return new BuildCommand(sourceFiles, variables, locFiles, libraryFiles, outputFile, type, cultures, bindFiles, bindPathList, intermediateFolder, contentsFile, outputsFile, builtOutputsFile, wixProjectFile);
                     }
 
                 case Commands.Compile:
@@ -179,6 +209,46 @@ namespace WixToolset.Core
             return null;
         }
 
+        private static OutputType CalculateOutputType(string outputType, string outputFile)
+        {
+            if (String.IsNullOrEmpty(outputType))
+            {
+                outputType = Path.GetExtension(outputFile);
+            }
+
+            switch (outputType.ToLowerInvariant())
+            {
+                case "bundle":
+                case ".exe":
+                    return OutputType.Bundle;
+
+                case "library":
+                case ".wixlib":
+                    return OutputType.Library;
+
+                case "module":
+                case ".msm":
+                    return OutputType.Module;
+
+                case "patch":
+                case ".msp":
+                    return OutputType.Patch;
+
+                case ".pcp":
+                    return OutputType.PatchCreation;
+
+                case "product":
+                case ".msi":
+                    return OutputType.Product;
+
+                case "transform":
+                case ".mst":
+                    return OutputType.Transform;
+            }
+
+            return OutputType.Unknown;
+        }
+
         private static CommandLine Parse(string commandLineString, Func<CommandLine, string, bool> parseArgument)
         {
             var arguments = CommandLine.ParseArgumentsToArray(commandLineString).ToArray();
@@ -239,6 +309,26 @@ namespace WixToolset.Core
             return variables;
         }
 
+        private static IEnumerable<BindPath> GatherBindPaths(IEnumerable<string> bindPaths)
+        {
+            var result = new List<BindPath>();
+
+            foreach (var bindPath in bindPaths)
+            {
+                BindPath bp = BindPath.Parse(bindPath);
+
+                if (Directory.Exists(bp.Path))
+                {
+                    result.Add(bp);
+                }
+                else if (File.Exists(bp.Path))
+                {
+                    Messaging.Instance.OnMessage(WixErrors.ExpectedDirectoryGotFile("-bindpath", bp.Path));
+                }
+            }
+
+            return result;
+        }
 
         /// <summary>
         /// Get a set of files that possibly have a search pattern in the path (such as '*').
@@ -361,7 +451,7 @@ namespace WixToolset.Core
 
         private static bool TryDequeue(Queue<string> q, out string arg)
         {
-            if (q.Count> 0)
+            if (q.Count > 0)
             {
                 arg = q.Dequeue();
                 return true;
@@ -469,11 +559,6 @@ namespace WixToolset.Core
             return false;
         }
 
-        /// <summary>
-        /// Parses a response file.
-        /// </summary>
-        /// <param name="responseFile">The file to parse.</param>
-        /// <returns>The array of arguments.</returns>
         private static List<string> ParseResponseFile(string responseFile)
         {
             string arguments;
@@ -486,11 +571,6 @@ namespace WixToolset.Core
             return CommandLine.ParseArgumentsToArray(arguments);
         }
 
-        /// <summary>
-        /// Parses an argument string into an argument array based on whitespace and quoting.
-        /// </summary>
-        /// <param name="arguments">Argument string.</param>
-        /// <returns>Argument array.</returns>
         private static List<string> ParseArgumentsToArray(string arguments)
         {
             // Scan and parse the arguments string, dividing up the arguments based on whitespace.
@@ -526,7 +606,7 @@ namespace WixToolset.Core
                     // Add the argument to the list if it's not empty.
                     if (arg.Length > 0)
                     {
-                        argsList.Add(CommandLine.ExpandEnvVars(arg.ToString()));
+                        argsList.Add(CommandLine.ExpandEnvironmentVariables(arg.ToString()));
                         arg.Length = 0;
                     }
                 }
@@ -557,12 +637,7 @@ namespace WixToolset.Core
             return argsList;
         }
 
-        /// <summary>
-        /// Expand enxironment variables contained in the passed string
-        /// </summary>
-        /// <param name="arguments"></param>
-        /// <returns></returns>
-        private static string ExpandEnvVars(string arguments)
+        private static string ExpandEnvironmentVariables(string arguments)
         {
             var id = Environment.GetEnvironmentVariables();
 
diff --git a/src/WixToolset.Core/Librarian.cs b/src/WixToolset.Core/Librarian.cs
index daf53478..66a8c32d 100644
--- a/src/WixToolset.Core/Librarian.cs
+++ b/src/WixToolset.Core/Librarian.cs
@@ -4,8 +4,8 @@ namespace WixToolset
 {
     using System;
     using System.Collections.Generic;
+    using System.Linq;
     using WixToolset.Data;
-    using WixToolset.Extensibility;
     using WixToolset.Link;
 
     /// <summary>
@@ -14,69 +14,26 @@ namespace WixToolset
     public sealed class Librarian
     {
         /// <summary>
-        /// Instantiate a new Librarian class.
-        /// </summary>
-        public Librarian()
-        {
-            this.TableDefinitions = new TableDefinitionCollection(WindowsInstallerStandard.GetTableDefinitions());
-        }
-
-        /// <summary>
-        /// Gets table definitions used by this librarian.
-        /// </summary>
-        /// <value>Table definitions.</value>
-        public TableDefinitionCollection TableDefinitions { get; private set; }
-
-        /// <summary>
-        /// Adds an extension's data.
-        /// </summary>
-        /// <param name="extension">The extension data to add.</param>
-        public void AddExtensionData(IExtensionData extension)
-        {
-            if (null != extension.TableDefinitions)
-            {
-                foreach (TableDefinition tableDefinition in extension.TableDefinitions)
-                {
-                    try
-                    {
-                        this.TableDefinitions.Add(tableDefinition);
-                    }
-                    catch (ArgumentException)
-                    {
-                        Messaging.Instance.OnMessage(WixErrors.DuplicateExtensionTable(extension.GetType().ToString(), tableDefinition.Name));
-                    }
-                }
-            }
-        }
-
-        /// <summary>
         /// Create a library by combining several intermediates (objects).
         /// </summary>
         /// <param name="sections">The sections to combine into a library.</param>
         /// <returns>Returns the new library.</returns>
-        public Library Combine(IEnumerable<Section> sections)
+        public Library Combine(IEnumerable<Section> sections, IEnumerable<Localization> localizations, ILibraryBinaryFileResolver resolver)
         {
-            Library library = new Library(sections);
+            var localizationsByCulture = CollateLocalizations(localizations);
 
-            this.Validate(library);
+            var embedFilePaths = ResolveFilePathsToEmbed(sections, resolver);
 
-            return (Messaging.Instance.EncounteredError ? null : library);
-        }
+            var library = new Library(sections, localizationsByCulture, embedFilePaths);
 
-        /// <summary>
-        /// Sends a message to the message delegate if there is one.
-        /// </summary>
-        /// <param name="mea">Message event arguments.</param>
-        public void OnMessage(MessageEventArgs e)
-        {
-            Messaging.Instance.OnMessage(e);
+            return this.Validate(library);
         }
 
         /// <summary>
         /// Validate that a library contains one entry section and no duplicate symbols.
         /// </summary>
         /// <param name="library">Library to validate.</param>
-        private void Validate(Library library)
+        private Library Validate(Library library)
         {
             FindEntrySectionAndLoadSymbolsCommand find = new FindEntrySectionAndLoadSymbolsCommand(library.Sections);
             find.Execute();
@@ -90,6 +47,66 @@ namespace WixToolset
             //     ReportDuplicateResolvedSymbolErrorsCommand reportDupes = new ReportDuplicateResolvedSymbolErrorsCommand(find.SymbolsWithDuplicates, resolve.ResolvedSections);
             //     reportDupes.Execute();
             // }
+
+            return (Messaging.Instance.EncounteredError ? null : library);
+        }
+
+        private static Dictionary<string, Localization> CollateLocalizations(IEnumerable<Localization> localizations)
+        {
+            var localizationsByCulture = new Dictionary<string, Localization>(StringComparer.OrdinalIgnoreCase);
+
+            foreach (var localization in localizations)
+            {
+                if (localizationsByCulture.TryGetValue(localization.Culture, out var existingCulture))
+                {
+                    existingCulture.Merge(localization);
+                }
+                else
+                {
+                    localizationsByCulture.Add(localization.Culture, localization);
+                }
+            }
+
+            return localizationsByCulture;
+        }
+
+        private static List<string> ResolveFilePathsToEmbed(IEnumerable<Section> sections, ILibraryBinaryFileResolver resolver)
+        {
+            var embedFilePaths = new List<string>();
+
+            // Resolve paths to files that are to be embedded in the library.
+            if (null != resolver)
+            {
+                foreach (Table table in sections.SelectMany(s => s.Tables))
+                {
+                    foreach (Row row in table.Rows)
+                    {
+                        foreach (ObjectField objectField in row.Fields.OfType<ObjectField>())
+                        {
+                            if (null != objectField.Data)
+                            {
+                                string file = resolver.Resolve(row.SourceLineNumbers, table.Name, (string)objectField.Data);
+                                if (!String.IsNullOrEmpty(file))
+                                {
+                                    // File was successfully resolved so track the embedded index as the embedded file index.
+                                    objectField.EmbeddedFileIndex = embedFilePaths.Count;
+                                    embedFilePaths.Add(file);
+                                }
+                                else
+                                {
+                                    Messaging.Instance.OnMessage(WixDataErrors.FileNotFound(row.SourceLineNumbers, (string)objectField.Data, table.Name));
+                                }
+                            }
+                            else // clear out embedded file id in case there was one there before.
+                            {
+                                objectField.EmbeddedFileIndex = null;
+                            }
+                        }
+                    }
+                }
+            }
+
+            return embedFilePaths;
         }
     }
 }
diff --git a/src/WixToolset.Core/Localizer.cs b/src/WixToolset.Core/Localizer.cs
index 3c299896..63ead24a 100644
--- a/src/WixToolset.Core/Localizer.cs
+++ b/src/WixToolset.Core/Localizer.cs
@@ -23,11 +23,32 @@ namespace WixToolset
         /// <summary>
         /// Instantiate a new Localizer.
         /// </summary>
-        public Localizer()
+        public Localizer(IEnumerable<Localization> localizations)
         {
             this.Codepage = -1;
-            this.variables = new Dictionary<string,WixVariableRow>();
+            this.variables = new Dictionary<string, WixVariableRow>();
             this.localizedControls = new Dictionary<string, LocalizedControl>();
+
+            foreach (var localization in localizations)
+            {
+                if (-1 == this.Codepage)
+                {
+                    this.Codepage = localization.Codepage;
+                }
+
+                foreach (WixVariableRow wixVariableRow in localization.Variables)
+                {
+                    Localizer.AddWixVariable(this.variables, wixVariableRow);
+                }
+
+                foreach (KeyValuePair<string, LocalizedControl> localizedControl in localization.LocalizedControls)
+                {
+                    if (!this.localizedControls.ContainsKey(localizedControl.Key))
+                    {
+                        this.localizedControls.Add(localizedControl.Key, localizedControl.Value);
+                    }
+                }
+            }
         }
 
         /// <summary>
@@ -76,39 +97,13 @@ namespace WixToolset
         }
 
         /// <summary>
-        /// Add a localization file.
-        /// </summary>
-        /// <param name="localization">The localization file to add.</param>
-        public void AddLocalization(Localization localization)
-        {
-            if (-1 == this.Codepage)
-            {
-                this.Codepage = localization.Codepage;
-            }
-
-            foreach (WixVariableRow wixVariableRow in localization.Variables)
-            {
-                Localizer.AddWixVariable(this.variables, wixVariableRow);
-            }
-
-            foreach (KeyValuePair<string, LocalizedControl> localizedControl in localization.LocalizedControls)
-            {
-                if (!this.localizedControls.ContainsKey(localizedControl.Key))
-                {
-                    this.localizedControls.Add(localizedControl.Key, localizedControl.Value);
-                }
-            }
-        }
-
-        /// <summary>
         /// Get a localized data value.
         /// </summary>
         /// <param name="id">The name of the localization variable.</param>
         /// <returns>The localized data value or null if it wasn't found.</returns>
         public string GetLocalizedValue(string id)
         {
-            WixVariableRow wixVariableRow;
-            return this.variables.TryGetValue(id, out wixVariableRow) ? wixVariableRow.Value : null;
+            return this.variables.TryGetValue(id, out var wixVariableRow) ? wixVariableRow.Value : null;
         }
 
         /// <summary>
diff --git a/src/WixToolset.Core/WixVariableResolver.cs b/src/WixToolset.Core/WixVariableResolver.cs
index 921ff1e3..d437423c 100644
--- a/src/WixToolset.Core/WixVariableResolver.cs
+++ b/src/WixToolset.Core/WixVariableResolver.cs
@@ -3,7 +3,6 @@
 namespace WixToolset
 {
     using System;
-    using System.Collections;
     using System.Collections.Generic;
     using System.Diagnostics.CodeAnalysis;
     using System.Globalization;
@@ -17,34 +16,27 @@ namespace WixToolset
     /// </summary>
     public sealed class WixVariableResolver
     {
-        private Localizer localizer;
         private Dictionary<string, string> wixVariables;
 
         /// <summary>
         /// Instantiate a new WixVariableResolver.
         /// </summary>
-        public WixVariableResolver()
+        public WixVariableResolver(Localizer localizer = null)
         {
             this.wixVariables = new Dictionary<string, string>();
+            this.Localizer = localizer;
         }
 
         /// <summary>
         /// Gets or sets the localizer.
         /// </summary>
         /// <value>The localizer.</value>
-        public Localizer Localizer
-        {
-            get { return this.localizer; }
-            set { this.localizer = value; }
-        }
+        public Localizer Localizer { get; private set; }
 
         /// <summary>
         /// Gets the count of variables added to the resolver.
         /// </summary>
-        public int VariableCount
-        {
-            get { return this.wixVariables.Count; }
-        }
+        public int VariableCount => this.wixVariables.Count;
 
         /// <summary>
         /// Add a variable.
@@ -198,9 +190,9 @@ namespace WixToolset
                                 Messaging.Instance.OnMessage(WixWarnings.DeprecatedLocalizationVariablePrefix(sourceLineNumbers, variableId));
                             }
 
-                            if (null != this.localizer)
+                            if (null != this.Localizer)
                             {
-                                resolvedValue = this.localizer.GetLocalizedValue(variableId);
+                                resolvedValue = this.Localizer.GetLocalizedValue(variableId);
                             }
                         }
                         else if (!localizationOnly && "wix" == variableNamespace)