Fix resolution of localizations that are embedded in intermediates

12 files changed, 505 insertions, 480 deletions

diff --git a/src/WixToolset.Core.Burn/Bind/BindBundleCommand.cs b/src/WixToolset.Core.Burn/Bind/BindBundleCommand.cs
index c1c12ac4..cf4504b2 100644
--- a/src/WixToolset.Core.Burn/Bind/BindBundleCommand.cs
+++ b/src/WixToolset.Core.Burn/Bind/BindBundleCommand.cs
@@ -96,7 +96,7 @@ namespace WixToolset.Core.Burn
 
         public string IntermediateFolder { private get; set; }
 
-        public IBindVariableResolver WixVariableResolver { private get; set; }
+        public IVariableResolver VariableResolver { private get; set; }
 
         public IEnumerable<FileTransfer> FileTransfers { get; private set; }
 
diff --git a/src/WixToolset.Core/Bind/ResolveDelayedFieldsCommand.cs b/src/WixToolset.Core/Bind/ResolveDelayedFieldsCommand.cs
index 3ded9a87..6f8da9ec 100644
--- a/src/WixToolset.Core/Bind/ResolveDelayedFieldsCommand.cs
+++ b/src/WixToolset.Core/Bind/ResolveDelayedFieldsCommand.cs
@@ -5,6 +5,7 @@ namespace WixToolset.Core.Bind
     using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Text;
     using WixToolset.Data;
     using WixToolset.Extensibility;
     using WixToolset.Extensibility.Services;
@@ -46,7 +47,7 @@ namespace WixToolset.Core.Bind
                     // process properties first in case they refer to other binder variables
                     if (delayedField.Row.Definition.Type == TupleDefinitionType.Property)
                     {
-                        var value = WixVariableResolver.ResolveDelayedVariables(propertyRow.SourceLineNumbers, delayedField.Field.AsString(), this.VariableCache);
+                        var value = ResolveDelayedVariables(propertyRow.SourceLineNumbers, delayedField.Field.AsString(), this.VariableCache);
 
                         // update the variable cache with the new value
                         var key = String.Concat("property.", propertyRow.AsString(0));
@@ -102,7 +103,7 @@ namespace WixToolset.Core.Bind
             {
                 try
                 {
-                    var value = WixVariableResolver.ResolveDelayedVariables(delayedField.Row.SourceLineNumbers, delayedField.Field.AsString(), this.VariableCache);
+                    var value = ResolveDelayedVariables(delayedField.Row.SourceLineNumbers, delayedField.Field.AsString(), this.VariableCache);
                     delayedField.Field.Set(value);
                 }
                 catch (WixException we)
@@ -111,5 +112,75 @@ namespace WixToolset.Core.Bind
                 }
             }
         }
+
+        public static string ResolveDelayedVariables(SourceLineNumber sourceLineNumbers, string value, IDictionary<string, string> resolutionData)
+        {
+            var matches = Common.WixVariableRegex.Matches(value);
+
+            if (0 < matches.Count)
+            {
+                var sb = new StringBuilder(value);
+
+                // notice how this code walks backward through the list
+                // because it modifies the string as we go through it
+                for (int i = matches.Count - 1; 0 <= i; i--)
+                {
+                    string variableNamespace = matches[i].Groups["namespace"].Value;
+                    string variableId = matches[i].Groups["fullname"].Value;
+                    string variableDefaultValue = null;
+                    string variableScope = null;
+
+                    // get the default value if one was specified
+                    if (matches[i].Groups["value"].Success)
+                    {
+                        variableDefaultValue = matches[i].Groups["value"].Value;
+                    }
+
+                    // get the scope if one was specified
+                    if (matches[i].Groups["scope"].Success)
+                    {
+                        variableScope = matches[i].Groups["scope"].Value;
+                        if ("bind" == variableNamespace)
+                        {
+                            variableId = matches[i].Groups["name"].Value;
+                        }
+                    }
+
+                    // check for an escape sequence of !! indicating the match is not a variable expression
+                    if (0 < matches[i].Index && '!' == sb[matches[i].Index - 1])
+                    {
+                        sb.Remove(matches[i].Index - 1, 1);
+                    }
+                    else
+                    {
+                        string key = String.Format(CultureInfo.InvariantCulture, "{0}.{1}", variableId, variableScope).ToLower(CultureInfo.InvariantCulture);
+                        string resolvedValue = variableDefaultValue;
+
+                        if (resolutionData.ContainsKey(key))
+                        {
+                            resolvedValue = resolutionData[key];
+                        }
+
+                        if ("bind" == variableNamespace)
+                        {
+                            // insert the resolved value if it was found or display an error
+                            if (null != resolvedValue)
+                            {
+                                sb.Remove(matches[i].Index, matches[i].Length);
+                                sb.Insert(matches[i].Index, resolvedValue);
+                            }
+                            else
+                            {
+                                throw new WixException(ErrorMessages.UnresolvedBindReference(sourceLineNumbers, value));
+                            }
+                        }
+                    }
+                }
+
+                value = sb.ToString();
+            }
+
+            return value;
+        }
     }
 }
diff --git a/src/WixToolset.Core/Bind/ResolveFieldsCommand.cs b/src/WixToolset.Core/Bind/ResolveFieldsCommand.cs
index 824eb9a5..744f022c 100644
--- a/src/WixToolset.Core/Bind/ResolveFieldsCommand.cs
+++ b/src/WixToolset.Core/Bind/ResolveFieldsCommand.cs
@@ -18,7 +18,7 @@ namespace WixToolset.Core.Bind
 
         public bool BuildingPatch { private get; set; }
 
-        public IBindVariableResolver BindVariableResolver { private get; set; }
+        public IVariableResolver VariableResolver { private get; set; }
 
         public IEnumerable<BindPath> BindPaths { private get; set; }
 
@@ -62,7 +62,7 @@ namespace WixToolset.Core.Bind
                                 var original = field.AsString();
                                 if (!String.IsNullOrEmpty(original))
                                 {
-                                    var resolution = this.BindVariableResolver.ResolveVariables(row.SourceLineNumbers, original, false);
+                                    var resolution = this.VariableResolver.ResolveVariables(row.SourceLineNumbers, original, false);
                                     if (resolution.UpdatedValue)
                                     {
                                         field.Set(resolution.Value);
diff --git a/src/WixToolset.Core/CommandLine/BuildCommand.cs b/src/WixToolset.Core/CommandLine/BuildCommand.cs
index fb258179..e11cd15a 100644
--- a/src/WixToolset.Core/CommandLine/BuildCommand.cs
+++ b/src/WixToolset.Core/CommandLine/BuildCommand.cs
@@ -186,7 +186,9 @@ namespace WixToolset.Core.CommandLine
 
         private void BindPhase(Intermediate output)
         {
-            var localizations = this.LoadLocalizationFiles().ToList();
+            var localizations = new List<Localization>(output.Localizations);
+
+            localizations.AddRange(this.LoadLocalizationFiles());
 
             // If there was an error loading localization files, then bail.
             if (this.Messaging.EncounteredError)
diff --git a/src/WixToolset.Core/Compiler.cs b/src/WixToolset.Core/Compiler.cs
index 8819721b..c71a8ba4 100644
--- a/src/WixToolset.Core/Compiler.cs
+++ b/src/WixToolset.Core/Compiler.cs
@@ -2446,7 +2446,7 @@ namespace WixToolset.Core
             {
                 if (isGeneratableGuidOk || keyFound && !String.IsNullOrEmpty(keyPath))
                 {
-                    this.componentIdPlaceholdersResolver.AddVariable(componentIdPlaceholder, keyPath, false);
+                    this.componentIdPlaceholdersResolver.AddVariable(sourceLineNumbers, componentIdPlaceholder, keyPath, false);
 
                     id = new Identifier(keyPath, AccessModifier.Private);
                 }
diff --git a/src/WixToolset.Core/Librarian.cs b/src/WixToolset.Core/Librarian.cs
index f4191e86..c42356ac 100644
--- a/src/WixToolset.Core/Librarian.cs
+++ b/src/WixToolset.Core/Librarian.cs
@@ -54,39 +54,46 @@ namespace WixToolset.Core
                 extension.PreCombine(this.Context);
             }
 
-            var sections = this.Context.Intermediates.SelectMany(i => i.Sections).ToList();
-
-            var embedFilePaths = this.ResolveFilePathsToEmbed(sections);
+            Intermediate library = null;
+            try
+            {
+                var sections = this.Context.Intermediates.SelectMany(i => i.Sections).ToList();
 
-            var localizationsByCulture = this.CollateLocalizations(this.Context.Localizations);
+                var collate = new CollateLocalizationsCommand(this.Context.Messaging, this.Context.Localizations);
+                var localizationsByCulture = collate.Execute();
 
-            if (this.Context.Messaging.EncounteredError)
-            {
-                return null;
-            }
+                if (this.Context.Messaging.EncounteredError)
+                {
+                    return null;
+                }
 
-            foreach (var section in sections)
-            {
-                section.LibraryId = this.Context.LibraryId;
-            }
+                var embedFilePaths = this.ResolveFilePathsToEmbed(sections);
 
-            var library = new Intermediate(this.Context.LibraryId, sections, localizationsByCulture, embedFilePaths);
+                foreach (var section in sections)
+                {
+                    section.LibraryId = this.Context.LibraryId;
+                }
 
-            this.Validate(library);
+                library = new Intermediate(this.Context.LibraryId, sections, localizationsByCulture, embedFilePaths);
 
-            foreach (var extension in this.Context.Extensions)
+                this.Validate(library);
+            }
+            finally
             {
-                extension.PostCombine(library);
+                foreach (var extension in this.Context.Extensions)
+                {
+                    extension.PostCombine(library);
+                }
             }
 
-            return library;
+            return this.Context.Messaging.EncounteredError ? null : library;
         }
 
         /// <summary>
         /// Validate that a library contains one entry section and no duplicate symbols.
         /// </summary>
         /// <param name="library">Library to validate.</param>
-        private Intermediate Validate(Intermediate library)
+        private void Validate(Intermediate library)
         {
             FindEntrySectionAndLoadSymbolsCommand find = new FindEntrySectionAndLoadSymbolsCommand(this.Context.Messaging, library.Sections);
             find.Execute();
@@ -100,34 +107,6 @@ namespace WixToolset.Core
             //     ReportDuplicateResolvedSymbolErrorsCommand reportDupes = new ReportDuplicateResolvedSymbolErrorsCommand(find.SymbolsWithDuplicates, resolve.ResolvedSections);
             //     reportDupes.Execute();
             // }
-
-            return (this.Context.Messaging.EncounteredError ? null : library);
-        }
-
-        private 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))
-                {
-                    try
-                    {
-                        existingCulture.Merge(localization);
-                    }
-                    catch (WixException e)
-                    {
-                        this.Context.Messaging.Write(e.Error);
-                    }
-                }
-                else
-                {
-                    localizationsByCulture.Add(localization.Culture, localization);
-                }
-            }
-
-            return localizationsByCulture;
         }
 
         private List<string> ResolveFilePathsToEmbed(IEnumerable<IntermediateSection> sections)
diff --git a/src/WixToolset.Core/Link/CollateLocalizationsCommand.cs b/src/WixToolset.Core/Link/CollateLocalizationsCommand.cs
new file mode 100644
index 00000000..ffa66210
--- /dev/null
+++ b/src/WixToolset.Core/Link/CollateLocalizationsCommand.cs
@@ -0,0 +1,71 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Core.Link
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using WixToolset.Data;
+    using WixToolset.Extensibility.Services;
+
+    internal class CollateLocalizationsCommand
+    {
+        public CollateLocalizationsCommand(IMessaging messaging, IEnumerable<Localization> localizations)
+        {
+            this.Messaging = messaging;
+            this.Localizations = localizations;
+        }
+
+        private IMessaging Messaging { get; }
+
+        private IEnumerable<Localization> Localizations { get; }
+
+        public Dictionary<string, Localization> Execute()
+        {
+            var localizationsByCulture = new Dictionary<string, Localization>(StringComparer.OrdinalIgnoreCase);
+
+            foreach (var localization in this.Localizations)
+            {
+                if (localizationsByCulture.TryGetValue(localization.Culture, out var existingCulture))
+                {
+                    var merged = this.Merge(existingCulture, localization);
+                    localizationsByCulture[localization.Culture] = merged;
+                }
+                else
+                {
+                    localizationsByCulture.Add(localization.Culture, localization);
+                }
+            }
+
+            return localizationsByCulture;
+        }
+
+        private Localization Merge(Localization existingLocalization, Localization localization)
+        {
+            var variables = existingLocalization.Variables.ToDictionary(v => v.Id);
+            var controls = existingLocalization.LocalizedControls.ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
+
+            foreach (var newVariable in localization.Variables)
+            {
+                if (!variables.TryGetValue(newVariable.Id, out var existingVariable) || (existingVariable.Overridable && !newVariable.Overridable))
+                {
+                    variables[newVariable.Id] = newVariable;
+                }
+                else if (!newVariable.Overridable)
+                {
+                    this.Messaging.Write(ErrorMessages.DuplicateLocalizationIdentifier(newVariable.SourceLineNumbers, newVariable.Id));
+                }
+            }
+
+            foreach (var localizedControl in localization.LocalizedControls)
+            {
+                if (!controls.ContainsKey(localizedControl.Key))
+                {
+                    controls.Add(localizedControl.Key, localizedControl.Value);
+                }
+            }
+
+            return new Localization(existingLocalization.Codepage, existingLocalization.Culture, variables, controls);
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Linker.cs b/src/WixToolset.Core/Linker.cs
index 79ddd30a..db2514fb 100644
--- a/src/WixToolset.Core/Linker.cs
+++ b/src/WixToolset.Core/Linker.cs
@@ -32,9 +32,6 @@ namespace WixToolset.Core
         {
             this.ServiceProvider = serviceProvider;
             this.sectionIdOnRows = true; // TODO: what is the correct value for this?
-
-            //this.extensionData = new List<IExtensionData>();
-            //this.inspectorExtensions = new List<InspectorExtension>();
         }
 
         private IServiceProvider ServiceProvider { get; }
@@ -78,40 +75,49 @@ namespace WixToolset.Core
             this.Context.Extensions = extensionManager.Create<ILinkerExtension>();
             this.Context.ExtensionData = extensionManager.Create<IExtensionData>();
             this.Context.ExpectedOutputType = this.OutputType;
-            this.Context.Intermediates = this.Intermediates.Union(this.Libraries).ToList();
+            this.Context.Intermediates = this.Intermediates.Concat(this.Libraries).ToList();
             this.Context.TupleDefinitionCreator = creator;
 
-            var sections = this.Context.Intermediates.SelectMany(i => i.Sections).ToList();
+            foreach (var extension in this.Context.Extensions)
+            {
+                extension.PreLink(this.Context);
+            }
 
-            // Add sections from the extensions with data.
-            foreach (var data in this.Context.ExtensionData)
+            Intermediate intermediate = null;
+            try
             {
-                var library = data.GetLibrary(this.Context.TupleDefinitionCreator);
+                var sections = this.Context.Intermediates.SelectMany(i => i.Sections).ToList();
+                var localizations = this.Context.Intermediates.SelectMany(i => i.Localizations).ToList();
 
-                if (library != null)
+                // Add sections from the extensions with data.
+                foreach (var data in this.Context.ExtensionData)
                 {
-                    sections.AddRange(library.Sections);
+                    var library = data.GetLibrary(this.Context.TupleDefinitionCreator);
+
+                    if (library != null)
+                    {
+                        sections.AddRange(library.Sections);
+                    }
                 }
-            }
 
 #if MOVE_TO_BACKEND
                 bool containsModuleSubstitution = false;
                 bool containsModuleConfiguration = false;
 #endif
 
-            //this.activeOutput = null;
+                //this.activeOutput = null;
 
-            //TableDefinitionCollection customTableDefinitions = new TableDefinitionCollection();
-            //IntermediateTuple customRows = new List<IntermediateTuple>();
+                //TableDefinitionCollection customTableDefinitions = new TableDefinitionCollection();
+                //IntermediateTuple customRows = new List<IntermediateTuple>();
 
 #if MOVE_TO_BACKEND
                 StringCollection generatedShortFileNameIdentifiers = new StringCollection();
                 Hashtable generatedShortFileNames = new Hashtable();
 #endif
 
-            Hashtable multipleFeatureComponents = new Hashtable();
+                Hashtable multipleFeatureComponents = new Hashtable();
 
-            var wixVariables = new Dictionary<string, WixVariableTuple>();
+                var wixVariables = new Dictionary<string, WixVariableTuple>();
 
 #if MOVE_TO_BACKEND
                 // verify that modularization types match for foreign key relationships
@@ -143,114 +149,117 @@ namespace WixToolset.Core
                 }
 #endif
 
-            // First find the entry section and while processing all sections load all the symbols from all of the sections.
-            // sections.FindEntrySectionAndLoadSymbols(false, this, expectedOutputType, out entrySection, out allSymbols);
-            var find = new FindEntrySectionAndLoadSymbolsCommand(this.Context.Messaging, sections);
-            find.ExpectedOutputType = this.Context.ExpectedOutputType;
-            find.Execute();
+                // First find the entry section and while processing all sections load all the symbols from all of the sections.
+                // sections.FindEntrySectionAndLoadSymbols(false, this, expectedOutputType, out entrySection, out allSymbols);
+                var find = new FindEntrySectionAndLoadSymbolsCommand(this.Context.Messaging, sections);
+                find.ExpectedOutputType = this.Context.ExpectedOutputType;
+                find.Execute();
 
-            // Must have found the entry section by now.
-            if (null == find.EntrySection)
-            {
-                throw new WixException(ErrorMessages.MissingEntrySection(this.Context.ExpectedOutputType.ToString()));
-            }
+                // Must have found the entry section by now.
+                if (null == find.EntrySection)
+                {
+                    throw new WixException(ErrorMessages.MissingEntrySection(this.Context.ExpectedOutputType.ToString()));
+                }
 
-            // Add the missing standard action symbols.
-            this.LoadStandardActionSymbols(find.EntrySection, find.Symbols);
+                // Add the missing standard action symbols.
+                this.LoadStandardActionSymbols(find.EntrySection, find.Symbols);
 
-            // Resolve the symbol references to find the set of sections we care about for linking.
-            // Of course, we start with the entry section (that's how it got its name after all).
-            var resolve = new ResolveReferencesCommand(this.Context.Messaging, find.EntrySection, find.Symbols);
-            resolve.BuildingMergeModule = (SectionType.Module == find.EntrySection.Type);
+                // Resolve the symbol references to find the set of sections we care about for linking.
+                // Of course, we start with the entry section (that's how it got its name after all).
+                var resolve = new ResolveReferencesCommand(this.Context.Messaging, find.EntrySection, find.Symbols);
+                resolve.BuildingMergeModule = (SectionType.Module == find.EntrySection.Type);
 
-            resolve.Execute();
+                resolve.Execute();
 
-            if (this.Context.Messaging.EncounteredError)
-            {
-                return null;
-            }
+                if (this.Context.Messaging.EncounteredError)
+                {
+                    return null;
+                }
 
-            // Reset the sections to only those that were resolved then flatten the complex
-            // references that particpate in groups.
-            sections = resolve.ResolvedSections.ToList();
+                // Reset the sections to only those that were resolved then flatten the complex
+                // references that particpate in groups.
+                sections = resolve.ResolvedSections.ToList();
 
-            this.FlattenSectionsComplexReferences(sections);
+                // TODO: consider filtering "localizations" down to only those localizations from 
+                //       intermediates in the sections.
 
-            if (this.Context.Messaging.EncounteredError)
-            {
-                return null;
-            }
+                this.FlattenSectionsComplexReferences(sections);
 
-            // The hard part in linking is processing the complex references.
-            var referencedComponents = new HashSet<string>();
-            var componentsToFeatures = new ConnectToFeatureCollection();
-            var featuresToFeatures = new ConnectToFeatureCollection();
-            var modulesToFeatures = new ConnectToFeatureCollection();
-            this.ProcessComplexReferences(find.EntrySection, sections, referencedComponents, componentsToFeatures, featuresToFeatures, modulesToFeatures);
+                if (this.Context.Messaging.EncounteredError)
+                {
+                    return null;
+                }
 
-            if (this.Context.Messaging.EncounteredError)
-            {
-                return null;
-            }
+                // The hard part in linking is processing the complex references.
+                var referencedComponents = new HashSet<string>();
+                var componentsToFeatures = new ConnectToFeatureCollection();
+                var featuresToFeatures = new ConnectToFeatureCollection();
+                var modulesToFeatures = new ConnectToFeatureCollection();
+                this.ProcessComplexReferences(find.EntrySection, sections, referencedComponents, componentsToFeatures, featuresToFeatures, modulesToFeatures);
 
-            // Display an error message for Components that were not referenced by a Feature.
-            foreach (var symbol in resolve.ReferencedSymbols.Where(s => s.Row.Definition.Type == TupleDefinitionType.Component))
-            {
-                if (!referencedComponents.Contains(symbol.Name))
+                if (this.Context.Messaging.EncounteredError)
                 {
-                    this.OnMessage(ErrorMessages.OrphanedComponent(symbol.Row.SourceLineNumbers, symbol.Row.Id.Id));
+                    return null;
                 }
-            }
 
-            // Report duplicates that would ultimately end up being primary key collisions.
-            var reportDupes = new ReportConflictingSymbolsCommand(this.Context.Messaging, find.PossiblyConflictingSymbols, resolve.ResolvedSections);
-            reportDupes.Execute();
+                // Display an error message for Components that were not referenced by a Feature.
+                foreach (var symbol in resolve.ReferencedSymbols.Where(s => s.Row.Definition.Type == TupleDefinitionType.Component))
+                {
+                    if (!referencedComponents.Contains(symbol.Name))
+                    {
+                        this.OnMessage(ErrorMessages.OrphanedComponent(symbol.Row.SourceLineNumbers, symbol.Row.Id.Id));
+                    }
+                }
 
-            if (this.Context.Messaging.EncounteredError)
-            {
-                return null;
-            }
+                // Report duplicates that would ultimately end up being primary key collisions.
+                var reportDupes = new ReportConflictingSymbolsCommand(this.Context.Messaging, find.PossiblyConflictingSymbols, resolve.ResolvedSections);
+                reportDupes.Execute();
 
-            // resolve the feature to feature connects
-            this.ResolveFeatureToFeatureConnects(featuresToFeatures, find.Symbols);
+                if (this.Context.Messaging.EncounteredError)
+                {
+                    return null;
+                }
 
-            // start generating OutputTables and OutputRows for all the sections in the output
-            var ensureTableRows = new List<IntermediateTuple>();
+                // resolve the feature to feature connects
+                this.ResolveFeatureToFeatureConnects(featuresToFeatures, find.Symbols);
 
-            // Create the section to hold the linked content.
-            var resolvedSection = new IntermediateSection(find.EntrySection.Id, find.EntrySection.Type, find.EntrySection.Codepage);
+                // start generating OutputTables and OutputRows for all the sections in the output
+                var ensureTableRows = new List<IntermediateTuple>();
 
-            var sectionCount = 0;
+                // Create the section to hold the linked content.
+                var resolvedSection = new IntermediateSection(find.EntrySection.Id, find.EntrySection.Type, find.EntrySection.Codepage);
 
-            foreach (var section in sections)
-            {
-                sectionCount++;
+                var sectionCount = 0;
 
-                var sectionId = section.Id;
-                if (null == sectionId && this.sectionIdOnRows)
+                foreach (var section in sections)
                 {
-                    sectionId = "wix.section." + sectionCount.ToString(CultureInfo.InvariantCulture);
-                }
+                    sectionCount++;
 
-                foreach (var tuple in section.Tuples)
-                {
-                    var copyTuple = true; // by default, copy tuples.
+                    var sectionId = section.Id;
+                    if (null == sectionId && this.sectionIdOnRows)
+                    {
+                        sectionId = "wix.section." + sectionCount.ToString(CultureInfo.InvariantCulture);
+                    }
 
-                    // handle special tables
-                    switch (tuple.Definition.Type)
+                    foreach (var tuple in section.Tuples)
                     {
+                        var copyTuple = true; // by default, copy tuples.
+
+                        // handle special tables
+                        switch (tuple.Definition.Type)
+                        {
 #if MOVE_TO_BACKEND
                             case "AppSearch":
                                 this.activeOutput.EnsureTable(this.tableDefinitions["Signature"]);
                                 break;
 #endif
 
-                        case TupleDefinitionType.Class:
-                            if (SectionType.Product == resolvedSection.Type)
-                            {
-                                this.ResolveFeatures(tuple, 2, 11, componentsToFeatures, multipleFeatureComponents);
-                            }
-                            break;
+                            case TupleDefinitionType.Class:
+                                if (SectionType.Product == resolvedSection.Type)
+                                {
+                                    this.ResolveFeatures(tuple, 2, 11, componentsToFeatures, multipleFeatureComponents);
+                                }
+                                break;
 
 #if MOVE_TO_BACKEND
                             case "CustomAction":
@@ -304,12 +313,12 @@ namespace WixToolset.Core
                                 }
                                 break;
 #endif
-                        case TupleDefinitionType.Extension:
-                            if (SectionType.Product == resolvedSection.Type)
-                            {
-                                this.ResolveFeatures(tuple, 1, 4, componentsToFeatures, multipleFeatureComponents);
-                            }
-                            break;
+                            case TupleDefinitionType.Extension:
+                                if (SectionType.Product == resolvedSection.Type)
+                                {
+                                    this.ResolveFeatures(tuple, 1, 4, componentsToFeatures, multipleFeatureComponents);
+                                }
+                                break;
 
 #if MOVE_TO_BACKEND
                             case TupleDefinitionType.ModuleSubstitution:
@@ -321,12 +330,12 @@ namespace WixToolset.Core
                                 break;
 #endif
 
-                        case TupleDefinitionType.MsiAssembly:
-                            if (SectionType.Product == resolvedSection.Type)
-                            {
-                                this.ResolveFeatures(tuple, 0, 1, componentsToFeatures, multipleFeatureComponents);
-                            }
-                            break;
+                            case TupleDefinitionType.MsiAssembly:
+                                if (SectionType.Product == resolvedSection.Type)
+                                {
+                                    this.ResolveFeatures(tuple, 0, 1, componentsToFeatures, multipleFeatureComponents);
+                                }
+                                break;
 
 #if MOVE_TO_BACKEND
                             case "ProgId":
@@ -348,26 +357,26 @@ namespace WixToolset.Core
                                 break;
 #endif
 
-                        case TupleDefinitionType.PublishComponent:
-                            if (SectionType.Product == resolvedSection.Type)
-                            {
-                                this.ResolveFeatures(tuple, 2, 4, componentsToFeatures, multipleFeatureComponents);
-                            }
-                            break;
+                            case TupleDefinitionType.PublishComponent:
+                                if (SectionType.Product == resolvedSection.Type)
+                                {
+                                    this.ResolveFeatures(tuple, 2, 4, componentsToFeatures, multipleFeatureComponents);
+                                }
+                                break;
 
-                        case TupleDefinitionType.Shortcut:
-                            if (SectionType.Product == resolvedSection.Type)
-                            {
-                                this.ResolveFeatures(tuple, 3, 4, componentsToFeatures, multipleFeatureComponents);
-                            }
-                            break;
+                            case TupleDefinitionType.Shortcut:
+                                if (SectionType.Product == resolvedSection.Type)
+                                {
+                                    this.ResolveFeatures(tuple, 3, 4, componentsToFeatures, multipleFeatureComponents);
+                                }
+                                break;
 
-                        case TupleDefinitionType.TypeLib:
-                            if (SectionType.Product == resolvedSection.Type)
-                            {
-                                this.ResolveFeatures(tuple, 2, 6, componentsToFeatures, multipleFeatureComponents);
-                            }
-                            break;
+                            case TupleDefinitionType.TypeLib:
+                                if (SectionType.Product == resolvedSection.Type)
+                                {
+                                    this.ResolveFeatures(tuple, 2, 6, componentsToFeatures, multipleFeatureComponents);
+                                }
+                                break;
 
 #if SOLVE_CUSTOM_TABLE
                             case "WixCustomTable":
@@ -385,9 +394,9 @@ namespace WixToolset.Core
                                 break;
 #endif
 
-                        case TupleDefinitionType.WixEnsureTable:
-                            ensureTableRows.Add(tuple);
-                            break;
+                            case TupleDefinitionType.WixEnsureTable:
+                                ensureTableRows.Add(tuple);
+                                break;
 
 
 #if MOVE_TO_BACKEND
@@ -410,66 +419,66 @@ namespace WixToolset.Core
                                 break;
 #endif
 
-                        case TupleDefinitionType.WixMerge:
-                            if (SectionType.Product == resolvedSection.Type)
-                            {
-                                this.ResolveFeatures(tuple, 0, 7, modulesToFeatures, null);
-                            }
-                            break;
-
-                        case TupleDefinitionType.WixComplexReference:
-                            copyTuple = false;
-                            break;
+                            case TupleDefinitionType.WixMerge:
+                                if (SectionType.Product == resolvedSection.Type)
+                                {
+                                    this.ResolveFeatures(tuple, 0, 7, modulesToFeatures, null);
+                                }
+                                break;
 
-                        case TupleDefinitionType.WixSimpleReference:
-                            copyTuple = false;
-                            break;
+                            case TupleDefinitionType.WixComplexReference:
+                                copyTuple = false;
+                                break;
 
-                        case TupleDefinitionType.WixVariable:
-                            // check for colliding values and collect the wix variable rows
-                            {
-                                var row = (WixVariableTuple)tuple;
+                            case TupleDefinitionType.WixSimpleReference:
+                                copyTuple = false;
+                                break;
 
-                                if (wixVariables.TryGetValue(row.WixVariable, out var collidingRow))
+                            case TupleDefinitionType.WixVariable:
+                                // check for colliding values and collect the wix variable rows
                                 {
-                                    if (collidingRow.Overridable && !row.Overridable)
+                                    var row = (WixVariableTuple)tuple;
+
+                                    if (wixVariables.TryGetValue(row.WixVariable, out var collidingRow))
                                     {
-                                        wixVariables[row.WixVariable] = row;
+                                        if (collidingRow.Overridable && !row.Overridable)
+                                        {
+                                            wixVariables[row.WixVariable] = row;
+                                        }
+                                        else if (!row.Overridable || (collidingRow.Overridable && row.Overridable))
+                                        {
+                                            this.OnMessage(ErrorMessages.WixVariableCollision(row.SourceLineNumbers, row.WixVariable));
+                                        }
                                     }
-                                    else if (!row.Overridable || (collidingRow.Overridable && row.Overridable))
+                                    else
                                     {
-                                        this.OnMessage(ErrorMessages.WixVariableCollision(row.SourceLineNumbers, row.WixVariable));
+                                        wixVariables.Add(row.WixVariable, row);
                                     }
                                 }
-                                else
-                                {
-                                    wixVariables.Add(row.WixVariable, row);
-                                }
-                            }
 
-                            copyTuple = false;
-                            break;
-                    }
+                                copyTuple = false;
+                                break;
+                        }
 
-                    if (copyTuple)
-                    {
-                        resolvedSection.Tuples.Add(tuple);
+                        if (copyTuple)
+                        {
+                            resolvedSection.Tuples.Add(tuple);
+                        }
                     }
                 }
-            }
 
-            // copy the module to feature connections into the output
-            foreach (ConnectToFeature connectToFeature in modulesToFeatures)
-            {
-                foreach (var feature in connectToFeature.ConnectFeatures)
+                // copy the module to feature connections into the output
+                foreach (ConnectToFeature connectToFeature in modulesToFeatures)
                 {
-                    var row = new WixFeatureModulesTuple();
-                    row.Feature_ = feature;
-                    row.WixMerge_ = connectToFeature.ChildId;
+                    foreach (var feature in connectToFeature.ConnectFeatures)
+                    {
+                        var row = new WixFeatureModulesTuple();
+                        row.Feature_ = feature;
+                        row.WixMerge_ = connectToFeature.ChildId;
 
-                    resolvedSection.Tuples.Add(row);
+                        resolvedSection.Tuples.Add(row);
+                    }
                 }
-            }
 
 #if MOVE_TO_BACKEND
                 // ensure the creation of tables that need to exist
@@ -612,24 +621,24 @@ namespace WixToolset.Core
                 }
 #endif
 
-            //correct the section Id in FeatureComponents table
-            if (this.sectionIdOnRows)
-            {
-                //var componentSectionIds = new Dictionary<string, string>();
-
-                //foreach (var componentTuple in entrySection.Tuples.OfType<ComponentTuple>())
-                //{
-                //    componentSectionIds.Add(componentTuple.Id.Id, componentTuple.SectionId);
-                //}
-
-                //foreach (var featureComponentTuple in entrySection.Tuples.OfType<FeatureComponentsTuple>())
-                //{
-                //    if (componentSectionIds.TryGetValue(featureComponentTuple.Component_, out var componentSectionId))
-                //    {
-                //        featureComponentTuple.SectionId = componentSectionId;
-                //    }
-                //}
-            }
+                //correct the section Id in FeatureComponents table
+                if (this.sectionIdOnRows)
+                {
+                    //var componentSectionIds = new Dictionary<string, string>();
+
+                    //foreach (var componentTuple in entrySection.Tuples.OfType<ComponentTuple>())
+                    //{
+                    //    componentSectionIds.Add(componentTuple.Id.Id, componentTuple.SectionId);
+                    //}
+
+                    //foreach (var featureComponentTuple in entrySection.Tuples.OfType<FeatureComponentsTuple>())
+                    //{
+                    //    if (componentSectionIds.TryGetValue(featureComponentTuple.Component_, out var componentSectionId))
+                    //    {
+                    //        featureComponentTuple.SectionId = componentSectionId;
+                    //    }
+                    //}
+                }
 
 #if MOVE_TO_BACKEND
                 // add the ModuleSubstitution table to the ModuleIgnoreTable
@@ -698,27 +707,38 @@ namespace WixToolset.Core
                 }
 #endif
 
-            // copy the wix variable rows to the output after all overriding has been accounted for.
-            foreach (var row in wixVariables.Values)
-            {
-                resolvedSection.Tuples.Add(row);
-            }
+                // copy the wix variable rows to the output after all overriding has been accounted for.
+                foreach (var row in wixVariables.Values)
+                {
+                    resolvedSection.Tuples.Add(row);
+                }
 
-            // Bundles have groups of data that must be flattened in a way different from other types.
-            this.FlattenBundleTables(resolvedSection);
+                // Bundles have groups of data that must be flattened in a way different from other types.
+                this.FlattenBundleTables(resolvedSection);
 
-            if (this.Context.Messaging.EncounteredError)
-            {
-                return null;
-            }
+                if (this.Context.Messaging.EncounteredError)
+                {
+                    return null;
+                }
 
-            var output = new Intermediate(resolvedSection.Id, new[] { resolvedSection }, null, null);
+                var collate = new CollateLocalizationsCommand(this.Context.Messaging, localizations);
+                var localizationsByCulture = collate.Execute();
+
+                intermediate = new Intermediate(resolvedSection.Id, new[] { resolvedSection }, localizationsByCulture, null);
 
 #if MOVE_TO_BACKEND
                 this.CheckOutputConsistency(output);
 #endif
+            }
+            finally
+            {
+                foreach (var extension in this.Context.Extensions)
+                {
+                    extension.PostLink(intermediate);
+                }
+            }
 
-            return this.Context.Messaging.EncounteredError ? null : output;
+            return this.Context.Messaging.EncounteredError ? null : intermediate;
         }
 
 #if SOLVE_CUSTOM_TABLE
diff --git a/src/WixToolset.Core/Localizer.cs b/src/WixToolset.Core/Localizer.cs
index 2e7b19b6..38d8864e 100644
--- a/src/WixToolset.Core/Localizer.cs
+++ b/src/WixToolset.Core/Localizer.cs
@@ -14,72 +14,11 @@ namespace WixToolset.Core
     /// <summary>
     /// Parses localization files and localizes database values.
     /// </summary>
-    public sealed class Localizer : ILocalizer
+    public sealed class Localizer
     {
         public static readonly XNamespace WxlNamespace = "http://wixtoolset.org/schemas/v4/wxl";
         private static string XmlElementName = "WixLocalization";
 
-        private Dictionary<string, BindVariable> variables;
-        private Dictionary<string, LocalizedControl> localizedControls;
-
-        /// <summary>
-        /// Instantiate a new Localizer.
-        /// </summary>
-        public Localizer(IMessaging messaging, IEnumerable<Localization> localizations)
-        {
-            this.Codepage = -1;
-            this.variables = new Dictionary<string, BindVariable>();
-            this.localizedControls = new Dictionary<string, LocalizedControl>();
-
-            foreach (var localization in localizations)
-            {
-                if (-1 == this.Codepage)
-                {
-                    this.Codepage = localization.Codepage;
-                }
-
-                foreach (var variable in localization.Variables)
-                {
-                    Localizer.AddWixVariable(messaging, this.variables, variable);
-                }
-
-                foreach (KeyValuePair<string, LocalizedControl> localizedControl in localization.LocalizedControls)
-                {
-                    if (!this.localizedControls.ContainsKey(localizedControl.Key))
-                    {
-                        this.localizedControls.Add(localizedControl.Key, localizedControl.Value);
-                    }
-                }
-            }
-        }
-
-        /// <summary>
-        /// Gets the codepage.
-        /// </summary>
-        /// <value>The codepage.</value>
-        public int Codepage { get; }
-
-        /// <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)
-        {
-            return this.variables.TryGetValue(id, out var wixVariableRow) ? wixVariableRow.Value : null;
-        }
-
-        /// <summary>
-        /// Get a localized control.
-        /// </summary>
-        /// <param name="dialog">The optional id of the control's dialog.</param>
-        /// <param name="control">The id of the control.</param>
-        /// <returns>The localized control or null if it wasn't found.</returns>
-        public LocalizedControl GetLocalizedControl(string dialog, string control)
-        {
-            return this.localizedControls.TryGetValue(LocalizedControl.GetKey(dialog, control), out var localizedControl) ? localizedControl : null;
-        }
-
         /// <summary>
         /// Loads a localization file from a path on disk.
         /// </summary>
diff --git a/src/WixToolset.Core/ResolveContext.cs b/src/WixToolset.Core/ResolveContext.cs
index 6d7b9df1..ca80d99c 100644
--- a/src/WixToolset.Core/ResolveContext.cs
+++ b/src/WixToolset.Core/ResolveContext.cs
@@ -23,10 +23,14 @@ namespace WixToolset.Core
 
         public IEnumerable<IResolverExtension> Extensions { get; set; }
 
+        public IEnumerable<IExtensionData> ExtensionData { get; set; }
+
         public string IntermediateFolder { get; set; }
 
         public Intermediate IntermediateRepresentation { get; set; }
 
-        public IBindVariableResolver WixVariableResolver { get; set; }
+        public IEnumerable<Localization> Localizations { get; set; }
+
+        public IVariableResolver VariableResolver { get; set; }
     }
 }
diff --git a/src/WixToolset.Core/Resolver.cs b/src/WixToolset.Core/Resolver.cs
index 1b72e3d0..c2d5cc87 100644
--- a/src/WixToolset.Core/Resolver.cs
+++ b/src/WixToolset.Core/Resolver.cs
@@ -25,48 +25,42 @@ namespace WixToolset.Core
 
         public IEnumerable<BindPath> BindPaths { get; set; }
 
-        public Intermediate IntermediateRepresentation { get; set; }
-
         public string IntermediateFolder { get; set; }
 
-        public IEnumerable<Localization> Localizations { get; set; }
+        public Intermediate IntermediateRepresentation { get; set; }
 
-        private IMessaging Messaging { get; set; }
+        public IEnumerable<Localization> Localizations { get; set; }
 
         public ResolveResult Execute()
         {
-            this.Messaging = this.ServiceProvider.GetService<IMessaging>();
-
-            var localizer = new Localizer(this.Messaging, this.Localizations);
-
-            var variableResolver = new WixVariableResolver(this.Messaging, localizer);
-            this.PopulateVariableResolver(variableResolver);
+            var extensionManager = this.ServiceProvider.GetService<IExtensionManager>();
 
             var context = this.ServiceProvider.GetService<IResolveContext>();
-            context.Messaging = this.Messaging;
+            context.Messaging = this.ServiceProvider.GetService<IMessaging>();
             context.BindPaths = this.BindPaths;
-            context.Extensions = this.ServiceProvider.GetService<IExtensionManager>().Create<IResolverExtension>();
+            context.Extensions = extensionManager.Create<IResolverExtension>();
+            context.ExtensionData = extensionManager.Create<IExtensionData>();
             context.IntermediateFolder = this.IntermediateFolder;
             context.IntermediateRepresentation = this.IntermediateRepresentation;
-            context.WixVariableResolver = variableResolver;
+            context.Localizations = this.Localizations;
+            context.VariableResolver = new WixVariableResolver(context.Messaging);
 
-            // Preresolve.
-            //
             foreach (IResolverExtension extension in context.Extensions)
             {
                 extension.PreResolve(context);
             }
 
-            // Resolve.
-            //
-            this.LocalizeUI(context);
+            ResolveResult resolveResult = null;
+            try
+            {
+                PopulateVariableResolver(context);
 
-            var resolveResult = this.Resolve(localizer.Codepage, context);
+                this.LocalizeUI(context);
 
-            if (resolveResult != null)
+                resolveResult = this.Resolve(context);
+            }
+            finally
             {
-                // Postresolve.
-                //
                 foreach (IResolverExtension extension in context.Extensions)
                 {
                     extension.PostResolve(resolveResult);
@@ -76,7 +70,7 @@ namespace WixToolset.Core
             return resolveResult;
         }
 
-        private ResolveResult Resolve(int codepage, IResolveContext context)
+        private ResolveResult Resolve(IResolveContext context)
         {
             var buildingPatch = context.IntermediateRepresentation.Sections.Any(s => s.Type == SectionType.Patch);
 
@@ -87,7 +81,7 @@ namespace WixToolset.Core
                 var command = new ResolveFieldsCommand();
                 command.Messaging = context.Messaging;
                 command.BuildingPatch = buildingPatch;
-                command.BindVariableResolver = context.WixVariableResolver;
+                command.VariableResolver = context.VariableResolver;
                 command.BindPaths = context.BindPaths;
                 command.Extensions = context.Extensions;
                 command.FilesWithEmbeddedFiles = filesWithEmbeddedFiles;
@@ -122,7 +116,7 @@ namespace WixToolset.Core
 
             return new ResolveResult
             {
-                Codepage = codepage,
+                Codepage = context.VariableResolver.Codepage,
                 ExpectedEmbeddedFiles = expectedEmbeddedFiles,
                 DelayedFields = delayedFields,
                 IntermediateRepresentation = context.IntermediateRepresentation
@@ -140,7 +134,7 @@ namespace WixToolset.Core
                 {
                     string dialog = row.Dialog;
 
-                    if (context.WixVariableResolver.TryGetLocalizedControl(dialog, null, out LocalizedControl localizedControl))
+                    if (context.VariableResolver.TryGetLocalizedControl(dialog, null, out LocalizedControl localizedControl))
                     {
                         if (CompilerConstants.IntegerNotSet != localizedControl.X)
                         {
@@ -176,7 +170,7 @@ namespace WixToolset.Core
                     string dialog = row.Dialog_;
                     string control = row.Control;
 
-                    if (context.WixVariableResolver.TryGetLocalizedControl(dialog, control, out LocalizedControl localizedControl))
+                    if (context.VariableResolver.TryGetLocalizedControl(dialog, control, out LocalizedControl localizedControl))
                     {
                         if (CompilerConstants.IntegerNotSet != localizedControl.X)
                         {
@@ -209,21 +203,34 @@ namespace WixToolset.Core
             }
         }
 
-        private void PopulateVariableResolver(WixVariableResolver resolver)
+        private static void PopulateVariableResolver(IResolveContext context)
         {
-            // Gather all the wix variables.
-            var wixVariableTuples = this.IntermediateRepresentation.Sections.SelectMany(s => s.Tuples).OfType<WixVariableTuple>();
-            foreach (var tuple in wixVariableTuples)
+            var creator = context.ServiceProvider.GetService<ITupleDefinitionCreator>();
+
+            var localizations = context.Localizations.Concat(context.IntermediateRepresentation.Localizations).ToList();
+
+            // Add localizations from the extensions with data.
+            foreach (var data in context.ExtensionData)
             {
-                try
-                {
-                    resolver.AddVariable(tuple.WixVariable, tuple.Value, tuple.Overridable);
-                }
-                catch (ArgumentException)
+                var library = data.GetLibrary(creator);
+
+                if (library?.Localizations != null)
                 {
-                    this.Messaging.Write(ErrorMessages.WixVariableCollision(tuple.SourceLineNumbers, tuple.WixVariable));
+                    localizations.AddRange(library.Localizations);
                 }
             }
+
+            foreach (var localization in localizations)
+            {
+                context.VariableResolver.AddLocalization(localization);
+            }
+
+            // Gather all the wix variables.
+            var wixVariableTuples = context.IntermediateRepresentation.Sections.SelectMany(s => s.Tuples).OfType<WixVariableTuple>();
+            foreach (var tuple in wixVariableTuples)
+            {
+                context.VariableResolver.AddVariable(tuple.SourceLineNumbers, tuple.WixVariable, tuple.Value, tuple.Overridable);
+            }
         }
     }
 }
diff --git a/src/WixToolset.Core/WixVariableResolver.cs b/src/WixToolset.Core/WixVariableResolver.cs
index 7339840e..7fe77077 100644
--- a/src/WixToolset.Core/WixVariableResolver.cs
+++ b/src/WixToolset.Core/WixVariableResolver.cs
@@ -4,72 +4,82 @@ namespace WixToolset.Core
 {
     using System;
     using System.Collections.Generic;
-    using System.Diagnostics.CodeAnalysis;
-    using System.Globalization;
     using System.Text;
-    using System.Text.RegularExpressions;
     using WixToolset.Data;
+    using WixToolset.Data.Bind;
     using WixToolset.Extensibility.Services;
 
     /// <summary>
     /// WiX variable resolver.
     /// </summary>
-    internal sealed class WixVariableResolver : IBindVariableResolver
+    internal sealed class WixVariableResolver : IVariableResolver
     {
-        private Dictionary<string, string> wixVariables;
+        private Dictionary<string, BindVariable> locVariables;
+        private Dictionary<string, BindVariable> wixVariables;
+        private Dictionary<string, LocalizedControl> localizedControls;
 
         /// <summary>
         /// Instantiate a new WixVariableResolver.
         /// </summary>
-        public WixVariableResolver(IMessaging messaging, Localizer localizer = null)
+        public WixVariableResolver(IMessaging messaging)
         {
-            this.wixVariables = new Dictionary<string, string>();
+            this.locVariables = new Dictionary<string, BindVariable>();
+            this.wixVariables = new Dictionary<string, BindVariable>();
+            this.Codepage = -1;
             this.Messaging = messaging;
-            this.Localizer = localizer;
         }
 
         private IMessaging Messaging { get; }
 
-        private Localizer Localizer { get; }
+        public int Codepage { get; private set; }
 
-        /// <summary>
-        /// Gets the count of variables added to the resolver.
-        /// </summary>
         public int VariableCount  => this.wixVariables.Count;
 
-        /// <summary>
-        /// Add a variable.
-        /// </summary>
-        /// <param name="name">The name of the variable.</param>
-        /// <param name="value">The value of the variable.</param>
-        /// <param name="overridable">Indicates whether the variable can be overridden by an existing variable.</param>
-        public void AddVariable(string name, string value, bool overridable)
+        public void AddLocalization(Localization localization)
         {
-            try
+            if (-1 == this.Codepage)
             {
-                this.wixVariables.Add(name, value);
+                this.Codepage = localization.Codepage;
             }
-            catch (ArgumentException)
+
+            foreach (var variable in localization.Variables)
             {
-                if (!overridable)
+                if (!TryAddWixVariable(this.locVariables, variable))
                 {
-                    throw;
+                    this.Messaging.Write(ErrorMessages.DuplicateLocalizationIdentifier(variable.SourceLineNumbers, variable.Id));
+                }
+            }
+
+            foreach (KeyValuePair<string, LocalizedControl> localizedControl in localization.LocalizedControls)
+            {
+                if (!this.localizedControls.ContainsKey(localizedControl.Key))
+                {
+                    this.localizedControls.Add(localizedControl.Key, localizedControl.Value);
                 }
             }
         }
 
-        /// <summary>
-        /// Resolve the wix variables in a value.
-        /// </summary>
-        /// <param name="sourceLineNumbers">The source line information for the value.</param>
-        /// <param name="value">The value to resolve.</param>
-        /// <param name="localizationOnly">true to only resolve localization variables; false otherwise.</param>
-        /// <returns>The resolved value.</returns>
-        public BindVariableResolution ResolveVariables(SourceLineNumber sourceLineNumbers, string value, bool localizationOnly)
+        public void AddVariable(SourceLineNumber sourceLineNumber, string name, string value, bool overridable)
+        {
+            var bindVariable = new BindVariable { Id = name, Value = value, Overridable = overridable, SourceLineNumbers = sourceLineNumber };
+
+            if (!TryAddWixVariable(this.wixVariables, bindVariable))
+            {
+                this.Messaging.Write(ErrorMessages.WixVariableCollision(sourceLineNumber, name));
+            }
+        }
+
+        public VariableResolution ResolveVariables(SourceLineNumber sourceLineNumbers, string value, bool localizationOnly)
         {
             return this.ResolveVariables(sourceLineNumbers, value, localizationOnly, true);
         }
 
+        public bool TryGetLocalizedControl(string dialog, string control, out LocalizedControl localizedControl)
+        {
+            var key = LocalizedControl.GetKey(dialog, control);
+            return this.localizedControls.TryGetValue(key, out localizedControl);
+        }
+
         /// <summary>
         /// Resolve the wix variables in a value.
         /// </summary>
@@ -80,23 +90,23 @@ namespace WixToolset.Core
         /// <param name="isDefault">true if the resolved value was the default.</param>
         /// <param name="delayedResolve">true if the value has variables that cannot yet be resolved.</param>
         /// <returns>The resolved value.</returns>
-        internal BindVariableResolution ResolveVariables(SourceLineNumber sourceLineNumbers, string value, bool localizationOnly, bool errorOnUnknown)
+        internal VariableResolution ResolveVariables(SourceLineNumber sourceLineNumbers, string value, bool localizationOnly, bool errorOnUnknown)
         {
-            MatchCollection matches = Common.WixVariableRegex.Matches(value);
+            var matches = Common.WixVariableRegex.Matches(value);
 
             // the value is the default unless its substituted further down
-            var result = new BindVariableResolution { IsDefault = true, Value = value };
+            var result = new VariableResolution { IsDefault = true, Value = value };
 
             if (0 < matches.Count)
             {
-                StringBuilder sb = new StringBuilder(value);
+                var sb = new StringBuilder(value);
 
                 // notice how this code walks backward through the list
                 // because it modifies the string as we through it
                 for (int i = matches.Count - 1; 0 <= i; i--)
                 {
-                    string variableNamespace = matches[i].Groups["namespace"].Value;
-                    string variableId = matches[i].Groups["fullname"].Value;
+                    var variableNamespace = matches[i].Groups["namespace"].Value;
+                    var variableId = matches[i].Groups["fullname"].Value;
                     string variableDefaultValue = null;
 
                     // get the default value if one was specified
@@ -142,7 +152,10 @@ namespace WixToolset.Core
                                 this.Messaging.Write(WarningMessages.DeprecatedLocalizationVariablePrefix(sourceLineNumbers, variableId));
                             }
 
-                            resolvedValue = this.Localizer?.GetLocalizedValue(variableId);
+                            if (this.locVariables.TryGetValue(variableId, out var bindVariable))
+                            {
+                                resolvedValue = bindVariable.Value;
+                            }
                         }
                         else if (!localizationOnly && "wix" == variableNamespace)
                         {
@@ -153,9 +166,9 @@ namespace WixToolset.Core
                             }
                             else
                             {
-                                if (this.wixVariables.TryGetValue(variableId, out resolvedValue))
+                                if (this.wixVariables.TryGetValue(variableId, out var bindVariable))
                                 {
-                                    resolvedValue = resolvedValue ?? String.Empty;
+                                    resolvedValue = bindVariable.Value ?? String.Empty;
                                     result.IsDefault = false;
                                 }
                                 else if (null != variableDefaultValue) // default the resolved value to the inline value if one was specified
@@ -198,96 +211,15 @@ namespace WixToolset.Core
             return result;
         }
 
-        /// <summary>
-        /// Try to find localization information for dialog and (optional) control.
-        /// </summary>
-        /// <param name="dialog">Dialog identifier.</param>
-        /// <param name="control">Optional control identifier.</param>
-        /// <param name="localizedControl">Found localization information.</param>
-        /// <returns>True if localized control was found, otherwise false.</returns>
-        public bool TryGetLocalizedControl(string dialog, string control, out LocalizedControl localizedControl)
-        {
-            localizedControl = this.Localizer?.GetLocalizedControl(dialog, control);
-            return localizedControl != null;
-        }
-
-        /// <summary>
-        /// Resolve the delay variables in a value.
-        /// </summary>
-        /// <param name="sourceLineNumbers">The source line information for the value.</param>
-        /// <param name="value">The value to resolve.</param>
-        /// <param name="resolutionData"></param>
-        /// <returns>The resolved value.</returns>
-        [SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "sourceLineNumbers")]
-        [SuppressMessage("Microsoft.Globalization", "CA1308:NormalizeStringsToUppercase", Justification = "This string is not round tripped, and not used for any security decisions")]
-        public static string ResolveDelayedVariables(SourceLineNumber sourceLineNumbers, string value, IDictionary<string, string> resolutionData)
+        private static bool TryAddWixVariable(IDictionary<string, BindVariable> variables, BindVariable variable)
         {
-            MatchCollection matches = Common.WixVariableRegex.Matches(value);
-
-            if (0 < matches.Count)
+            if (!variables.TryGetValue(variable.Id, out var existingWixVariableRow) || (existingWixVariableRow.Overridable && !variable.Overridable))
             {
-                StringBuilder sb = new StringBuilder(value);
-
-                // notice how this code walks backward through the list
-                // because it modifies the string as we go through it
-                for (int i = matches.Count - 1; 0 <= i; i--)
-                {
-                    string variableNamespace = matches[i].Groups["namespace"].Value;
-                    string variableId = matches[i].Groups["fullname"].Value;
-                    string variableDefaultValue = null;
-                    string variableScope = null;
-
-                    // get the default value if one was specified
-                    if (matches[i].Groups["value"].Success)
-                    {
-                        variableDefaultValue = matches[i].Groups["value"].Value;
-                    }
-
-                    // get the scope if one was specified
-                    if (matches[i].Groups["scope"].Success)
-                    {
-                        variableScope = matches[i].Groups["scope"].Value;
-                        if ("bind" == variableNamespace)
-                        {
-                            variableId = matches[i].Groups["name"].Value;
-                        }
-                    }
-
-                    // check for an escape sequence of !! indicating the match is not a variable expression
-                    if (0 < matches[i].Index && '!' == sb[matches[i].Index - 1])
-                    {
-                        sb.Remove(matches[i].Index - 1, 1);
-                    }
-                    else
-                    {
-                        string key = String.Format(CultureInfo.InvariantCulture, "{0}.{1}", variableId, variableScope).ToLower(CultureInfo.InvariantCulture);
-                        string resolvedValue = variableDefaultValue;
-
-                        if (resolutionData.ContainsKey(key))
-                        {
-                            resolvedValue = resolutionData[key];
-                        }
-
-                        if ("bind" == variableNamespace)
-                        {
-                            // insert the resolved value if it was found or display an error
-                            if (null != resolvedValue)
-                            {
-                                sb.Remove(matches[i].Index, matches[i].Length);
-                                sb.Insert(matches[i].Index, resolvedValue);
-                            }
-                            else
-                            {
-                                throw new WixException(ErrorMessages.UnresolvedBindReference(sourceLineNumbers, value));
-                            }
-                        }
-                    }
-                }
-
-                value = sb.ToString();
+                variables[variable.Id] = variable;
+                return true;
             }
 
-            return value;
+            return variable.Overridable;
         }
     }
 }