Initial code commit

8 files changed, 1395 insertions, 0 deletions

diff --git a/src/WixToolset.Core/Link/ConnectToFeature.cs b/src/WixToolset.Core/Link/ConnectToFeature.cs
new file mode 100644
index 00000000..6e046b89
--- /dev/null
+++ b/src/WixToolset.Core/Link/ConnectToFeature.cs
@@ -0,0 +1,95 @@
+// 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.Link
+{
+    using System.Collections.Specialized;
+    using WixToolset.Data;
+
+    /// <summary>
+    /// Object that connects things (components/modules) to features.
+    /// </summary>
+    public sealed class ConnectToFeature
+    {
+        private Section section;
+        private string childId;
+
+        private string primaryFeature;
+        private bool explicitPrimaryFeature;
+        private StringCollection connectFeatures;
+
+        /// <summary>
+        /// Creates a new connect to feature.
+        /// </summary>
+        /// <param name="section">Section this connect belongs to.</param>
+        /// <param name="childId">Id of the child.</param>
+        public ConnectToFeature(Section section, string childId) :
+            this(section, childId, null, false)
+        {
+        }
+
+        /// <summary>
+        /// Creates a new connect to feature.
+        /// </summary>
+        /// <param name="section">Section this connect belongs to.</param>
+        /// <param name="childId">Id of the child.</param>
+        /// <param name="primaryFeature">Sets the primary feature for the connection.</param>
+        /// <param name="explicitPrimaryFeature">Sets if this is explicit primary.</param>
+        public ConnectToFeature(Section section, string childId, string primaryFeature, bool explicitPrimaryFeature)
+        {
+            this.section = section;
+            this.childId = childId;
+
+            this.primaryFeature = primaryFeature;
+            this.explicitPrimaryFeature = explicitPrimaryFeature;
+
+            this.connectFeatures = new StringCollection();
+        }
+
+        /// <summary>
+        /// Gets the section.
+        /// </summary>
+        /// <value>Section.</value>
+        public Section Section
+        {
+            get { return this.section; }
+        }
+
+        /// <summary>
+        /// Gets the child identifier.
+        /// </summary>
+        /// <value>The child identifier.</value>
+        public string ChildId
+        {
+            get { return this.childId; }
+        }
+
+        /// <summary>
+        /// Gets or sets if the flag for if the primary feature was set explicitly.
+        /// </summary>
+        /// <value>The flag for if the primary feature was set explicitly.</value>
+        public bool IsExplicitPrimaryFeature
+        {
+            get { return this.explicitPrimaryFeature; }
+            set { this.explicitPrimaryFeature = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the primary feature.
+        /// </summary>
+        /// <value>The primary feature.</value>
+        public string PrimaryFeature
+        {
+            get { return this.primaryFeature; }
+            set { this.primaryFeature = value; }
+        }
+
+        /// <summary>
+        /// Gets the features connected to.
+        /// </summary>
+        /// <value>Features connected to.</value>
+        public StringCollection ConnectFeatures
+        {
+            get { return this.connectFeatures; }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Link/ConnectToFeatureCollection.cs b/src/WixToolset.Core/Link/ConnectToFeatureCollection.cs
new file mode 100644
index 00000000..8dd0d22c
--- /dev/null
+++ b/src/WixToolset.Core/Link/ConnectToFeatureCollection.cs
@@ -0,0 +1,92 @@
+// 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.Link
+{
+    using System;
+    using System.Collections;
+
+    /// <summary>
+    /// Hash collection of connect to feature objects.
+    /// </summary>
+    public sealed class ConnectToFeatureCollection : ICollection
+    {
+        private Hashtable collection;
+
+        /// <summary>
+        /// Instantiate a new ConnectToFeatureCollection class.
+        /// </summary>
+        public ConnectToFeatureCollection()
+        {
+            this.collection = new Hashtable();
+        }
+
+        /// <summary>
+        /// Gets the number of items in the collection.
+        /// </summary>
+        /// <value>Number of items in collection.</value>
+        public int Count
+        {
+            get { return this.collection.Count; }
+        }
+
+        /// <summary>
+        /// Gets if the collection has been synchronized.
+        /// </summary>
+        /// <value>True if the collection has been synchronized.</value>
+        public bool IsSynchronized
+        {
+            get { return this.collection.IsSynchronized; }
+        }
+
+        /// <summary>
+        /// Gets the object used to synchronize the collection.
+        /// </summary>
+        /// <value>Oject used the synchronize the collection.</value>
+        public object SyncRoot
+        {
+            get { return this.collection.SyncRoot; }
+        }
+
+        /// <summary>
+        /// Gets a feature connection by child id.
+        /// </summary>
+        /// <param name="childId">Identifier of child to locate.</param>
+        public ConnectToFeature this[string childId]
+        {
+            get { return (ConnectToFeature)this.collection[childId]; }
+        }
+
+        /// <summary>
+        /// Adds a feature connection to the collection.
+        /// </summary>
+        /// <param name="connection">Feature connection to add.</param>
+        public void Add(ConnectToFeature connection)
+        {
+            if (null == connection)
+            {
+                throw new ArgumentNullException("connection");
+            }
+
+            this.collection.Add(connection.ChildId, connection);
+        }
+
+        /// <summary>
+        /// Copies the collection into an array.
+        /// </summary>
+        /// <param name="array">Array to copy the collection into.</param>
+        /// <param name="index">Index to start copying from.</param>
+        public void CopyTo(System.Array array, int index)
+        {
+            this.collection.CopyTo(array, index);
+        }
+
+        /// <summary>
+        /// Gets enumerator for the collection.
+        /// </summary>
+        /// <returns>Enumerator for the collection.</returns>
+        public IEnumerator GetEnumerator()
+        {
+            return this.collection.Values.GetEnumerator();
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Link/ConnectToModule.cs b/src/WixToolset.Core/Link/ConnectToModule.cs
new file mode 100644
index 00000000..d6a8338e
--- /dev/null
+++ b/src/WixToolset.Core/Link/ConnectToModule.cs
@@ -0,0 +1,54 @@
+// 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.Link
+{
+    /// <summary>
+    /// Object that connects things to modules.
+    /// </summary>
+    public sealed class ConnectToModule
+    {
+        private string childId;
+        private string module;
+        private string moduleLanguage;
+
+        /// <summary>
+        /// Creates a new connect to module.
+        /// </summary>
+        /// <param name="childId">Id of the child.</param>
+        /// <param name="module">Id of the module.</param>
+        /// <param name="moduleLanguage">Language of the module.</param>
+        public ConnectToModule(string childId, string module, string moduleLanguage)
+        {
+            this.childId = childId;
+            this.module = module;
+            this.moduleLanguage = moduleLanguage;
+        }
+
+        /// <summary>
+        /// Gets the id of the child.
+        /// </summary>
+        /// <value>Child identifier.</value>
+        public string ChildId
+        {
+            get { return this.childId; }
+        }
+
+        /// <summary>
+        /// Gets the id of the module.
+        /// </summary>
+        /// <value>The id of the module.</value>
+        public string Module
+        {
+            get { return this.module; }
+        }
+
+        /// <summary>
+        /// Gets the language of the module.
+        /// </summary>
+        /// <value>The language of the module.</value>
+        public string ModuleLanguage
+        {
+            get { return this.moduleLanguage; }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Link/ConnectToModuleCollection.cs b/src/WixToolset.Core/Link/ConnectToModuleCollection.cs
new file mode 100644
index 00000000..6595487f
--- /dev/null
+++ b/src/WixToolset.Core/Link/ConnectToModuleCollection.cs
@@ -0,0 +1,92 @@
+// 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.Link
+{
+    using System;
+    using System.Collections;
+
+    /// <summary>
+    /// Hash collection of connect to module objects.
+    /// </summary>
+    public sealed class ConnectToModuleCollection : ICollection
+    {
+        private Hashtable collection;
+
+        /// <summary>
+        /// Instantiate a new ConnectToModuleCollection class.
+        /// </summary>
+        public ConnectToModuleCollection()
+        {
+            this.collection = new Hashtable();
+        }
+
+        /// <summary>
+        /// Gets the number of elements actually contained in the ConnectToModuleCollection.
+        /// </summary>
+        /// <value>The number of elements actually contained in the ConnectToModuleCollection.</value>
+        public int Count
+        {
+            get { return this.collection.Count; }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether access to the ConnectToModuleCollection is synchronized (thread-safe).
+        /// </summary>
+        /// <value>true if access to the ConnectToModuleCollection is synchronized (thread-safe); otherwise, false. The default is false.</value>
+        public bool IsSynchronized
+        {
+            get { return this.collection.IsSynchronized; }
+        }
+
+        /// <summary>
+        /// Gets an object that can be used to synchronize access to the ConnectToModuleCollection.
+        /// </summary>
+        /// <value>An object that can be used to synchronize access to the ConnectToModuleCollection.</value>
+        public object SyncRoot
+        {
+            get { return this.collection.SyncRoot; }
+        }
+
+        /// <summary>
+        /// Gets a module connection by child id.
+        /// </summary>
+        /// <param name="childId">Identifier of child to locate.</param>
+        public ConnectToModule this[string childId]
+        {
+            get { return (ConnectToModule)this.collection[childId]; }
+        }
+
+        /// <summary>
+        /// Adds a module connection to the collection.
+        /// </summary>
+        /// <param name="connection">Module connection to add.</param>
+        public void Add(ConnectToModule connection)
+        {
+            if (null == connection)
+            {
+                throw new ArgumentNullException("connection");
+            }
+
+            this.collection.Add(connection.ChildId, connection);
+        }
+
+        /// <summary>
+        /// Copies the entire ConnectToModuleCollection to a compatible one-dimensional Array, starting at the specified index of the target array.
+        /// </summary>
+        /// <param name="array">The one-dimensional Array that is the destination of the elements copied from this ConnectToModuleCollection. The Array must have zero-based indexing.</param>
+        /// <param name="index">The zero-based index in array at which copying begins.</param>
+        public void CopyTo(System.Array array, int index)
+        {
+            this.collection.Keys.CopyTo(array, index);
+        }
+
+        /// <summary>
+        /// Returns an enumerator for the entire ConnectToModuleCollection.
+        /// </summary>
+        /// <returns>An IEnumerator for the entire ConnectToModuleCollection.</returns>
+        public IEnumerator GetEnumerator()
+        {
+            return this.collection.Keys.GetEnumerator();
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Link/FindEntrySectionAndLoadSymbolsCommand.cs b/src/WixToolset.Core/Link/FindEntrySectionAndLoadSymbolsCommand.cs
new file mode 100644
index 00000000..effb06e4
--- /dev/null
+++ b/src/WixToolset.Core/Link/FindEntrySectionAndLoadSymbolsCommand.cs
@@ -0,0 +1,109 @@
+// 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.Link
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using WixToolset.Data;
+
+    internal class FindEntrySectionAndLoadSymbolsCommand : ICommand
+    {
+        private IEnumerable<Section> sections;
+
+        public FindEntrySectionAndLoadSymbolsCommand(IEnumerable<Section> sections)
+        {
+            this.sections = sections;
+        }
+
+        /// <summary>
+        /// Sets the expected entry output type, based on output file extension provided to the linker.
+        /// </summary>
+        public OutputType ExpectedOutputType { private get; set; }
+
+        /// <summary>
+        /// Gets the located entry section after the command is executed.
+        /// </summary>
+        public Section EntrySection { get; private set; }
+
+        /// <summary>
+        /// Gets the collection of loaded symbols.
+        /// </summary>
+        public IDictionary<string, Symbol> Symbols { get; private set; }
+
+        public IEnumerable<Symbol> PossiblyConflictingSymbols { get; private set; }
+
+        public void Execute()
+        {
+            Dictionary<string, Symbol> symbols = new Dictionary<string, Symbol>();
+            HashSet<Symbol> possibleConflicts = new HashSet<Symbol>();
+
+            SectionType expectedEntrySectionType;
+            if (!Enum.TryParse<SectionType>(this.ExpectedOutputType.ToString(), out expectedEntrySectionType))
+            {
+                expectedEntrySectionType = SectionType.Unknown;
+            }
+
+            foreach (Section section in this.sections)
+            {
+                // Try to find the one and only entry section.
+                if (SectionType.Product == section.Type || SectionType.Module == section.Type || SectionType.PatchCreation == section.Type || SectionType.Patch == section.Type || SectionType.Bundle == section.Type)
+                {
+                    if (SectionType.Unknown != expectedEntrySectionType && section.Type != expectedEntrySectionType)
+                    {
+                        string outputExtension = Output.GetExtension(this.ExpectedOutputType);
+                        Messaging.Instance.OnMessage(WixWarnings.UnexpectedEntrySection(section.SourceLineNumbers, section.Type.ToString(), expectedEntrySectionType.ToString(), outputExtension));
+                    }
+
+                    if (null == this.EntrySection)
+                    {
+                        this.EntrySection = section;
+                    }
+                    else
+                    {
+                        Messaging.Instance.OnMessage(WixErrors.MultipleEntrySections(this.EntrySection.SourceLineNumbers, this.EntrySection.Id, section.Id));
+                        Messaging.Instance.OnMessage(WixErrors.MultipleEntrySections2(section.SourceLineNumbers));
+                    }
+                }
+
+                // Load all the symbols from the section's tables that create symbols.
+                foreach (Table table in section.Tables.Where(t => t.Definition.CreateSymbols))
+                {
+                    foreach (Row row in table.Rows)
+                    {
+                        Symbol symbol = new Symbol(row);
+
+                        Symbol existingSymbol;
+                        if (!symbols.TryGetValue(symbol.Name, out existingSymbol))
+                        {
+                            symbols.Add(symbol.Name, symbol);
+                        }
+                        else // uh-oh, duplicate symbols.
+                        {
+                            // If the duplicate symbols are both private directories, there is a chance that they
+                            // point to identical rows. Identical directory rows are redundant and will not cause
+                            // conflicts.
+                            if (AccessModifier.Private == existingSymbol.Access && AccessModifier.Private == symbol.Access &&
+                                "Directory" == existingSymbol.Row.Table.Name && existingSymbol.Row.IsIdentical(symbol.Row))
+                            {
+                                // Ensure identical symbol's row is marked redundant to ensure (should the row be
+                                // referenced into the final output) it will not add duplicate primary keys during
+                                // the .IDT importing.
+                                symbol.Row.Redundant = true;
+                                existingSymbol.AddRedundant(symbol);
+                            }
+                            else
+                            {
+                                existingSymbol.AddPossibleConflict(symbol);
+                                possibleConflicts.Add(existingSymbol);
+                            }
+                        }
+                    }
+                }
+            }
+
+            this.Symbols = symbols;
+            this.PossiblyConflictingSymbols = possibleConflicts;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Link/ReportConflictingSymbolsCommand.cs b/src/WixToolset.Core/Link/ReportConflictingSymbolsCommand.cs
new file mode 100644
index 00000000..39c3a5c2
--- /dev/null
+++ b/src/WixToolset.Core/Link/ReportConflictingSymbolsCommand.cs
@@ -0,0 +1,49 @@
+// 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.Link
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using WixToolset.Data;
+
+    public class ReportConflictingSymbolsCommand : ICommand
+    {
+        private IEnumerable<Symbol> possibleConflicts;
+        private IEnumerable<Section> resolvedSections;
+
+        public ReportConflictingSymbolsCommand(IEnumerable<Symbol> possibleConflicts, IEnumerable<Section> resolvedSections)
+        {
+            this.possibleConflicts = possibleConflicts;
+            this.resolvedSections = resolvedSections;
+        }
+
+        public void Execute()
+        {
+            // Do a quick check if there are any possibly conflicting symbols that don't come from tables that allow
+            // overriding. Hopefully the symbols with possible conflicts list is usually very short list (empty should
+            // be the most common). If we find any matches, we'll do a more costly check to see if the possible conflicting
+            // symbols are in sections we actually referenced. From the resulting set, show an error for each duplicate
+            // (aka: conflicting) symbol. This should catch any rows with colliding primary keys (since symbols are based
+            // on the primary keys of rows).
+            List<Symbol> illegalDuplicates = possibleConflicts.Where(s => "WixAction" != s.Row.Table.Name && "WixVariable" != s.Row.Table.Name).ToList();
+            if (0 < illegalDuplicates.Count)
+            {
+                HashSet<Section> referencedSections = new HashSet<Section>(resolvedSections);
+                foreach (Symbol referencedDuplicateSymbol in illegalDuplicates.Where(s => referencedSections.Contains(s.Section)))
+                {
+                    List<Symbol> actuallyReferencedDuplicateSymbols = referencedDuplicateSymbol.PossiblyConflictingSymbols.Where(s => referencedSections.Contains(s.Section)).ToList();
+
+                    if (actuallyReferencedDuplicateSymbols.Any())
+                    {
+                        Messaging.Instance.OnMessage(WixErrors.DuplicateSymbol(referencedDuplicateSymbol.Row.SourceLineNumbers, referencedDuplicateSymbol.Name));
+
+                        foreach (Symbol duplicate in actuallyReferencedDuplicateSymbols)
+                        {
+                            Messaging.Instance.OnMessage(WixErrors.DuplicateSymbol2(duplicate.Row.SourceLineNumbers));
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Link/ResolveReferencesCommand.cs b/src/WixToolset.Core/Link/ResolveReferencesCommand.cs
new file mode 100644
index 00000000..5a985f3f
--- /dev/null
+++ b/src/WixToolset.Core/Link/ResolveReferencesCommand.cs
@@ -0,0 +1,178 @@
+// 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.Link
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Linq;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+
+    /// <summary>
+    /// Resolves all the simple references in a section.
+    /// </summary>
+    internal class ResolveReferencesCommand : ICommand
+    {
+        private Section entrySection;
+        private IDictionary<string, Symbol> symbols;
+        private HashSet<Symbol> referencedSymbols;
+        private HashSet<Section> resolvedSections;
+
+        public ResolveReferencesCommand(Section entrySection, IDictionary<string, Symbol> symbols)
+        {
+            this.entrySection = entrySection;
+            this.symbols = symbols;
+        }
+
+        public bool BuildingMergeModule { private get; set; }
+
+        public IEnumerable<Symbol> ReferencedSymbols { get { return this.referencedSymbols; } }
+
+        public IEnumerable<Section> ResolvedSections { get { return this.resolvedSections; } }
+
+        /// <summary>
+        /// Resolves all the simple references in a section.
+        /// </summary>
+        public void Execute()
+        {
+            this.resolvedSections = new HashSet<Section>();
+            this.referencedSymbols = new HashSet<Symbol>();
+
+            this.RecursivelyResolveReferences(this.entrySection);
+        }
+
+        /// <summary>
+        /// Recursive helper function to resolve all references of passed in section.
+        /// </summary>
+        /// <param name="section">Section with references to resolve.</param>
+        /// <remarks>Note: recursive function.</remarks>
+        private void RecursivelyResolveReferences(Section section)
+        {
+            // If we already resolved this section, move on to the next.
+            if (!this.resolvedSections.Add(section))
+            {
+                return;
+            }
+
+            // Process all of the references contained in this section using the collection of
+            // symbols provided.  Then recursively call this method to process the
+            // located symbol's section.  All in all this is a very simple depth-first
+            // search of the references per-section.
+            Table wixSimpleReferenceTable;
+            if (section.Tables.TryGetTable("WixSimpleReference", out wixSimpleReferenceTable))
+            {
+                foreach (WixSimpleReferenceRow wixSimpleReferenceRow in wixSimpleReferenceTable.Rows)
+                {
+                    Debug.Assert(wixSimpleReferenceRow.Section == section);
+
+                    // If we're building a Merge Module, ignore all references to the Media table
+                    // because Merge Modules don't have Media tables.
+                    if (this.BuildingMergeModule && "Media" == wixSimpleReferenceRow.TableName)
+                    {
+                        continue;
+                    }
+
+                    Symbol symbol;
+                    if (!this.symbols.TryGetValue(wixSimpleReferenceRow.SymbolicName, out symbol))
+                    {
+                        Messaging.Instance.OnMessage(WixErrors.UnresolvedReference(wixSimpleReferenceRow.SourceLineNumbers, wixSimpleReferenceRow.SymbolicName));
+                    }
+                    else // see if the symbol (and any of its duplicates) are appropriately accessible.
+                    {
+                        IList<Symbol> accessible = DetermineAccessibleSymbols(section, symbol);
+                        if (!accessible.Any())
+                        {
+                            Messaging.Instance.OnMessage(WixErrors.UnresolvedReference(wixSimpleReferenceRow.SourceLineNumbers, wixSimpleReferenceRow.SymbolicName, symbol.Access));
+                        }
+                        else if (1 == accessible.Count)
+                        {
+                            Symbol accessibleSymbol = accessible[0];
+                            this.referencedSymbols.Add(accessibleSymbol);
+
+                            if (null != accessibleSymbol.Section)
+                            {
+                                RecursivelyResolveReferences(accessibleSymbol.Section);
+                            }
+                        }
+                        else // display errors for the duplicate symbols.
+                        {
+                            Symbol accessibleSymbol = accessible[0];
+                            string referencingSourceLineNumber = wixSimpleReferenceRow.SourceLineNumbers.ToString();
+                            if (String.IsNullOrEmpty(referencingSourceLineNumber))
+                            {
+                                Messaging.Instance.OnMessage(WixErrors.DuplicateSymbol(accessibleSymbol.Row.SourceLineNumbers, accessibleSymbol.Name));
+                            }
+                            else
+                            {
+                                Messaging.Instance.OnMessage(WixErrors.DuplicateSymbol(accessibleSymbol.Row.SourceLineNumbers, accessibleSymbol.Name, referencingSourceLineNumber));
+                            }
+
+                            foreach (Symbol accessibleDuplicate in accessible.Skip(1))
+                            {
+                                Messaging.Instance.OnMessage(WixErrors.DuplicateSymbol2(accessibleDuplicate.Row.SourceLineNumbers));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Determine if the symbol and any of its duplicates are accessbile by referencing section.
+        /// </summary>
+        /// <param name="referencingSection">Section referencing the symbol.</param>
+        /// <param name="symbol">Symbol being referenced.</param>
+        /// <returns>List of symbols accessible by referencing section.</returns>
+        private IList<Symbol> DetermineAccessibleSymbols(Section referencingSection, Symbol symbol)
+        {
+            List<Symbol> symbols = new List<Symbol>();
+
+            if (AccessibleSymbol(referencingSection, symbol))
+            {
+                symbols.Add(symbol);
+            }
+
+            foreach (Symbol dupe in symbol.PossiblyConflictingSymbols)
+            {
+                if (AccessibleSymbol(referencingSection, dupe))
+                {
+                    symbols.Add(dupe);
+                }
+            }
+
+            foreach (Symbol dupe in symbol.RedundantSymbols)
+            {
+                if (AccessibleSymbol(referencingSection, dupe))
+                {
+                    symbols.Add(dupe);
+                }
+            }
+
+            return symbols;
+        }
+
+        /// <summary>
+        /// Determine if a single symbol is accessible by the referencing section.
+        /// </summary>
+        /// <param name="referencingSection">Section referencing the symbol.</param>
+        /// <param name="symbol">Symbol being referenced.</param>
+        /// <returns>True if symbol is accessible.</returns>
+        private bool AccessibleSymbol(Section referencingSection, Symbol symbol)
+        {
+            switch (symbol.Access)
+            {
+                case AccessModifier.Public:
+                    return true;
+                case AccessModifier.Internal:
+                    return symbol.Row.Section.IntermediateId.Equals(referencingSection.IntermediateId) || (null != symbol.Row.Section.LibraryId && symbol.Row.Section.LibraryId.Equals(referencingSection.LibraryId));
+                case AccessModifier.Protected:
+                    return symbol.Row.Section.IntermediateId.Equals(referencingSection.IntermediateId);
+                case AccessModifier.Private:
+                    return referencingSection == symbol.Section;
+                default:
+                    throw new InvalidOperationException();
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Link/WixGroupingOrdering.cs b/src/WixToolset.Core/Link/WixGroupingOrdering.cs
new file mode 100644
index 00000000..fc0ce43b
--- /dev/null
+++ b/src/WixToolset.Core/Link/WixGroupingOrdering.cs
@@ -0,0 +1,726 @@
+// 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.Link
+{
+    using System;
+    using System.Collections;
+    using System.Collections.ObjectModel;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Globalization;
+    using System.Linq;
+    using System.Text;
+    using WixToolset.Extensibility;
+    using WixToolset.Data;
+
+    /// <summary>
+    /// Grouping and Ordering class of the WiX toolset.
+    /// </summary>
+    internal sealed class WixGroupingOrdering : IMessageHandler
+    {
+        private Output output;
+        private IMessageHandler messageHandler;
+        private List<string> groupTypes;
+        private List<string> itemTypes;
+        private ItemCollection items;
+        private List<int> rowsUsed;
+        private bool loaded;
+        private bool encounteredError;
+
+        /// <summary>
+        /// Creates a WixGroupingOrdering object.
+        /// </summary>
+        /// <param name="output">Output from which to read the group and order information.</param>
+        /// <param name="messageHandler">Handler for any error messages.</param>
+        /// <param name="groupTypes">Group types to include.</param>
+        /// <param name="itemTypes">Item types to include.</param>
+        public WixGroupingOrdering(Output output, IMessageHandler messageHandler)
+        {
+            this.output = output;
+            this.messageHandler = messageHandler;
+
+            this.rowsUsed = new List<int>();
+            this.loaded = false;
+            this.encounteredError = false;
+        }
+
+        /// <summary>
+        /// Switches a WixGroupingOrdering object to operate on a new set of groups/items.
+        /// </summary>
+        /// <param name="groupTypes">Group types to include.</param>
+        /// <param name="itemTypes">Item types to include.</param>
+        public void UseTypes(IEnumerable<string> groupTypes, IEnumerable<string> itemTypes)
+        {
+            this.groupTypes = new List<string>(groupTypes);
+            this.itemTypes = new List<string>(itemTypes);
+
+            this.items = new ItemCollection();
+            this.loaded = false;
+        }
+
+        /// <summary>
+        /// Sends a message to the message handler if there is one.
+        /// </summary>
+        /// <param name="mea">Message event arguments.</param>
+        public void OnMessage(MessageEventArgs e)
+        {
+            WixErrorEventArgs errorEventArgs = e as WixErrorEventArgs;
+
+            if (null != errorEventArgs || MessageLevel.Error == e.Level)
+            {
+                this.encounteredError = true;
+            }
+
+            if (null != this.messageHandler)
+            {
+                this.messageHandler.OnMessage(e);
+            }
+            else if (null != errorEventArgs)
+            {
+                throw new WixException(errorEventArgs);
+            }
+        }
+
+        /// <summary>
+        /// Finds all nested items under a parent group and creates new WixGroup data for them.
+        /// </summary>
+        /// <param name="parentType">The group type for the parent group to flatten.</param>
+        /// <param name="parentId">The identifier of the parent group to flatten.</param>
+        /// <param name="removeUsedRows">Whether to remove used group rows before returning.</param>
+        public void FlattenAndRewriteRows(string parentType, string parentId, bool removeUsedRows)
+        {
+            Debug.Assert(this.groupTypes.Contains(parentType));
+
+            List<Item> orderedItems;
+            this.CreateOrderedList(parentType, parentId, out orderedItems);
+            if (this.encounteredError)
+            {
+                return;
+            }
+
+            this.CreateNewGroupRows(parentType, parentId, orderedItems);
+
+            if (removeUsedRows)
+            {
+                this.RemoveUsedGroupRows();
+            }
+        }
+
+        /// <summary>
+        /// Finds all items under a parent group type and creates new WixGroup data for them.
+        /// </summary>
+        /// <param name="parentType">The type of the parent group to flatten.</param>
+        /// <param name="removeUsedRows">Whether to remove used group rows before returning.</param>
+        public void FlattenAndRewriteGroups(string parentType, bool removeUsedRows)
+        {
+            Debug.Assert(this.groupTypes.Contains(parentType));
+
+            this.LoadFlattenOrderGroups();
+            if (this.encounteredError)
+            {
+                return;
+            }
+
+            foreach (Item item in this.items)
+            {
+                if (parentType == item.Type)
+                {
+                    List<Item> orderedItems;
+                    this.CreateOrderedList(item.Type, item.Id, out orderedItems);
+                    this.CreateNewGroupRows(item.Type, item.Id, orderedItems);
+                }
+            }
+
+            if (removeUsedRows)
+            {
+                this.RemoveUsedGroupRows();
+            }
+        }
+
+
+        /// <summary>
+        /// Creates a flattened and ordered list of items for the given parent group.
+        /// </summary>
+        /// <param name="parentType">The group type for the parent group to flatten.</param>
+        /// <param name="parentId">The identifier of the parent group to flatten.</param>
+        /// <param name="orderedItems">The returned list of ordered items.</param>
+        private void CreateOrderedList(string parentType, string parentId, out List<Item> orderedItems)
+        {
+            orderedItems = null;
+
+            this.LoadFlattenOrderGroups();
+            if (this.encounteredError)
+            {
+                return;
+            }
+
+            Item parentItem;
+            if (!this.items.TryGetValue(parentType, parentId, out parentItem))
+            {
+                this.OnMessage(WixErrors.IdentifierNotFound(parentType, parentId));
+                return;
+            }
+
+            orderedItems = new List<Item>(parentItem.ChildItems);
+            orderedItems.Sort(new Item.AfterItemComparer());
+        }
+
+        /// <summary>
+        /// Removes rows from WixGroup that have been used by this object.
+        /// </summary>
+        public void RemoveUsedGroupRows()
+        {
+            List<int> sortedIndexes = this.rowsUsed.Distinct().OrderByDescending(i => i).ToList();
+
+            Table wixGroupTable = this.output.Tables["WixGroup"];
+            Debug.Assert(null != wixGroupTable);
+            Debug.Assert(sortedIndexes[0] < wixGroupTable.Rows.Count);
+
+            foreach (int rowIndex in sortedIndexes)
+            {
+                wixGroupTable.Rows.RemoveAt(rowIndex);
+            }
+        }
+
+        /// <summary>
+        /// Creates new WixGroup rows for a list of items.
+        /// </summary>
+        /// <param name="parentType">The group type for the parent group in the new rows.</param>
+        /// <param name="parentId">The identifier of the parent group in the new rows.</param>
+        /// <param name="orderedItems">The list of new items.</param>
+        private void CreateNewGroupRows(string parentType, string parentId, List<Item> orderedItems)
+        {
+            // TODO: MSIs don't guarantee that rows stay in the same order, and technically, neither
+            // does WiX (although they do, currently). We probably want to "upgrade" this to a new
+            // table that includes a sequence number, and then change the code that uses ordered
+            // groups to read from that table instead.
+            Table wixGroupTable = this.output.Tables["WixGroup"];
+            Debug.Assert(null != wixGroupTable);
+
+            foreach (Item item in orderedItems)
+            {
+                Row row = wixGroupTable.CreateRow(item.Row.SourceLineNumbers);
+                row[0] = parentId;
+                row[1] = parentType;
+                row[2] = item.Id;
+                row[3] = item.Type;
+            }
+        }
+
+        // Group/Ordering Flattening Logic
+        //
+        // What follows is potentially convoluted logic. Two somewhat orthogonal concepts are in
+        // play: grouping (parent/child relationships) and ordering (before/after relationships).
+        // Dealing with just one or the other is straghtforward. Groups can be flattened
+        // recursively. Ordering can be propagated in either direction. When the ordering also
+        // participates in the grouping constructions, however, things get trickier.  For the
+        // purposes of this discussion, we're dealing with "items" and "groups", and an instance
+        // of either of them can be marked as coming "after" some other instance.
+        //
+        // For simple item-to-item ordering, the "after" values simply propagate: if A is after B,
+        // and B is after C, then we can say that A is after *both* B and C.  If a group is involved,
+        // it acts as a proxy for all of its included items and any sub-groups.
+
+        /// <summary>
+        /// Internal workhorse for ensuring that group and ordering information has
+        /// been loaded and applied.
+        /// </summary>
+        private void LoadFlattenOrderGroups()
+        {
+            if (!this.loaded)
+            {
+                this.LoadGroups();
+                this.LoadOrdering();
+
+                // It would be really nice to have a "find circular after dependencies"
+                // function, but it gets much more complicated because of the way that
+                // the dependencies are propagated across group boundaries. For now, we
+                // just live with the dependency loop detection as we flatten the
+                // dependencies. Group references, however, we can check directly.
+                this.FindCircularGroupReferences();
+
+                if (!this.encounteredError)
+                {
+                    this.FlattenGroups();
+                    this.FlattenOrdering();
+                }
+
+                this.loaded = true;
+            }
+        }
+
+        /// <summary>
+        /// Loads data from the WixGroup table.
+        /// </summary>
+        private void LoadGroups()
+        {
+            Table wixGroupTable = this.output.Tables["WixGroup"];
+            if (null == wixGroupTable || 0 == wixGroupTable.Rows.Count)
+            {
+                // TODO: Change message name to make it *not* Bundle specific?
+                this.OnMessage(WixErrors.MissingBundleInformation("WixGroup"));
+            }
+
+            // Collect all of the groups
+            for (int rowIndex = 0; rowIndex < wixGroupTable.Rows.Count; ++rowIndex)
+            {
+                Row row = wixGroupTable.Rows[rowIndex];
+                string rowParentName = (string)row[0];
+                string rowParentType = (string)row[1];
+                string rowChildName = (string)row[2];
+                string rowChildType = (string)row[3];
+
+                // If this row specifies a parent or child type that's not in our
+                // lists, we assume it's not a row that we're concerned about.
+                if (!this.groupTypes.Contains(rowParentType) ||
+                    !this.itemTypes.Contains(rowChildType))
+                {
+                    continue;
+                }
+
+                this.rowsUsed.Add(rowIndex);
+
+                Item parentItem;
+                if (!this.items.TryGetValue(rowParentType, rowParentName, out parentItem))
+                {
+                    parentItem = new Item(row, rowParentType, rowParentName);
+                    this.items.Add(parentItem);
+                }
+
+                Item childItem;
+                if (!this.items.TryGetValue(rowChildType, rowChildName, out childItem))
+                {
+                    childItem = new Item(row, rowChildType, rowChildName);
+                    this.items.Add(childItem);
+                }
+
+                parentItem.ChildItems.Add(childItem);
+            }
+        }
+
+        /// <summary>
+        /// Flattens group/item information.
+        /// </summary>
+        private void FlattenGroups()
+        {
+            foreach (Item item in this.items)
+            {
+                item.FlattenChildItems();
+            }
+        }
+
+        /// <summary>
+        /// Finds and reports circular references in the group/item data.
+        /// </summary>
+        private void FindCircularGroupReferences()
+        {
+            ItemCollection itemsInKnownLoops = new ItemCollection();
+            foreach (Item item in this.items)
+            {
+                if (itemsInKnownLoops.Contains(item))
+                {
+                    continue;
+                }
+
+                ItemCollection itemsSeen = new ItemCollection();
+                string circularReference;
+                if (this.FindCircularGroupReference(item, item, itemsSeen, out circularReference))
+                {
+                    itemsInKnownLoops.Add(itemsSeen);
+                    this.OnMessage(WixErrors.ReferenceLoopDetected(item.Row.SourceLineNumbers, circularReference));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Recursive worker to find and report circular references in group/item data.
+        /// </summary>
+        /// <param name="checkItem">The sentinal item being checked.</param>
+        /// <param name="currentItem">The current item in the recursion.</param>
+        /// <param name="itemsSeen">A list of all items already visited (for performance).</param>
+        /// <param name="circularReference">A list of items in the current circular reference, if one was found; null otherwise.</param>
+        /// <returns>True if a circular reference was found; false otherwise.</returns>
+        private bool FindCircularGroupReference(Item checkItem, Item currentItem, ItemCollection itemsSeen, out string circularReference)
+        {
+            circularReference = null;
+            foreach (Item subitem in currentItem.ChildItems)
+            {
+                if (checkItem == subitem)
+                {
+                    // TODO: Even better would be to include the source lines for each reference!
+                    circularReference = String.Format(CultureInfo.InvariantCulture, "{0}:{1} -> {2}:{3}",
+                        currentItem.Type, currentItem.Id, subitem.Type, subitem.Id);
+                    return true;
+                }
+
+                if (!itemsSeen.Contains(subitem))
+                {
+                    itemsSeen.Add(subitem);
+                    if (this.FindCircularGroupReference(checkItem, subitem, itemsSeen, out circularReference))
+                    {
+                        // TODO: Even better would be to include the source lines for each reference!
+                        circularReference = String.Format(CultureInfo.InvariantCulture, "{0}:{1} -> {2}",
+                            currentItem.Type, currentItem.Id, circularReference);
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Loads ordering dependency data from the WixOrdering table.
+        /// </summary>
+        private void LoadOrdering()
+        {
+            Table wixOrderingTable = output.Tables["WixOrdering"];
+            if (null == wixOrderingTable || 0 == wixOrderingTable.Rows.Count)
+            {
+                // TODO: Do we need a message here?
+                return;
+            }
+
+            foreach (Row row in wixOrderingTable.Rows)
+            {
+                string rowItemType = (string)row[0];
+                string rowItemName = (string)row[1];
+                string rowDependsOnType = (string)row[2];
+                string rowDependsOnName = (string)row[3];
+
+                // If this row specifies some other (unknown) type in either
+                // position, we assume it's not a row that we're concerned about.
+                // For ordering, we allow group and item in either position.
+                if (!(this.groupTypes.Contains(rowItemType) || this.itemTypes.Contains(rowItemType)) ||
+                    !(this.groupTypes.Contains(rowDependsOnType) || this.itemTypes.Contains(rowDependsOnType)))
+                {
+                    continue;
+                }
+
+                Item item = null;
+                Item dependsOn = null;
+
+                if (!this.items.TryGetValue(rowItemType, rowItemName, out item))
+                {
+                    this.OnMessage(WixErrors.IdentifierNotFound(rowItemType, rowItemName));
+                }
+
+                if (!this.items.TryGetValue(rowDependsOnType, rowDependsOnName, out dependsOn))
+                {
+                    this.OnMessage(WixErrors.IdentifierNotFound(rowDependsOnType, rowDependsOnName));
+                }
+
+                if (null == item || null == dependsOn)
+                {
+                    continue;
+                }
+
+                item.AddAfter(dependsOn, this);
+            }
+        }
+
+        /// <summary>
+        /// Flattens the ordering dependencies in the groups/items.
+        /// </summary>
+        private void FlattenOrdering()
+        {
+            // Because items don't know about their parent groups (and can, in fact, be
+            // in more than one group at a time), we need to pre-propagate the 'afters'
+            // from each parent item to its children before we attempt to flatten the
+            // ordering.
+            foreach (Item item in this.items)
+            {
+                item.PropagateAfterToChildItems(this);
+            }
+
+            foreach (Item item in this.items)
+            {
+                item.FlattenAfters(this);
+            }
+        }
+
+        /// <summary>
+        /// A variant of KeyedCollection that doesn't throw when an item is re-added.
+        /// </summary>
+        /// <typeparam name="TKey">Key type for the collection.</typeparam>
+        /// <typeparam name="TItem">Item type for the colelction.</typeparam>
+        internal abstract class EnhancedKeyCollection<TKey, TItem> : KeyedCollection<TKey, TItem>
+        {
+            new public void Add(TItem item)
+            {
+                if (!this.Contains(item))
+                {
+                    base.Add(item);
+                }
+            }
+
+            public void Add(Collection<TItem> list)
+            {
+                foreach (TItem item in list)
+                {
+                    this.Add(item);
+                }
+            }
+
+            public void Remove(Collection<TItem> list)
+            {
+                foreach (TItem item in list)
+                {
+                    this.Remove(item);
+                }
+            }
+
+            public bool TryGetValue(TKey key, out TItem item)
+            {
+                // KeyedCollection doesn't implement the TryGetValue() method, but it's
+                // a useful concept.  We can't just always pass this to the enclosed
+                // Dictionary, however, because it doesn't always exist! If it does, we
+                // can delegate to it as one would expect. If it doesn't, we have to
+                // implement everything ourselves in terms of Contains().
+
+                if (null != this.Dictionary)
+                {
+                    return this.Dictionary.TryGetValue(key, out item);
+                }
+
+                if (this.Contains(key))
+                {
+                    item = this[key];
+                    return true;
+                }
+
+                item = default(TItem);
+                return false;
+            }
+
+#if DEBUG
+            // This just makes debugging easier...
+            public override string ToString()
+            {
+                StringBuilder sb = new StringBuilder();
+                foreach (TItem item in this)
+                {
+                    sb.AppendFormat("{0}, ", item);
+                }
+                sb.Length -= 2;
+                return sb.ToString();
+            }
+#endif // DEBUG
+        }
+
+        /// <summary>
+        /// A specialized EnhancedKeyCollection, typed to Items.
+        /// </summary>
+        internal class ItemCollection : EnhancedKeyCollection<string, Item>
+        {
+            protected override string GetKeyForItem(Item item)
+            {
+                return item.Key;
+            }
+
+            public bool TryGetValue(string type, string id, out Item item)
+            {
+                return this.TryGetValue(CreateKeyFromTypeId(type, id), out item);
+            }
+
+            public static string CreateKeyFromTypeId(string type, string id)
+            {
+                return String.Format(CultureInfo.InvariantCulture, "{0}_{1}", type, id);
+            }
+        }
+
+        /// <summary>
+        /// An item (or group) in the grouping/ordering engine.
+        /// </summary>
+        /// <remarks>Encapsulates nested group membership and also before/after
+        /// ordering dependencies.</remarks>
+        internal class Item
+        {
+            private ItemCollection afterItems;
+            private ItemCollection beforeItems; // for checking for circular references
+            private bool flattenedAfterItems;
+
+            public Item(Row row, string type, string id)
+            {
+                this.Row = row;
+                this.Type = type;
+                this.Id = id;
+
+                this.Key = ItemCollection.CreateKeyFromTypeId(type, id);
+
+                afterItems = new ItemCollection();
+                beforeItems = new ItemCollection();
+                flattenedAfterItems = false;
+            }
+
+            public Row Row { get; private set; }
+            public string Type { get; private set; }
+            public string Id { get; private set; }
+            public string Key { get; private set; }
+
+#if DEBUG
+            // Makes debugging easier...
+            public override string ToString()
+            {
+                return this.Key;
+            }
+#endif // DEBUG
+
+            private ItemCollection childItems = new ItemCollection();
+            public ItemCollection ChildItems { get { return childItems; } }
+
+            /// <summary>
+            /// Removes any nested groups under this item and replaces
+            /// them with their child items.
+            /// </summary>
+            public void FlattenChildItems()
+            {
+                ItemCollection flattenedChildItems = new ItemCollection();
+
+                foreach (Item childItem in this.ChildItems)
+                {
+                    if (0 == childItem.ChildItems.Count)
+                    {
+                        flattenedChildItems.Add(childItem);
+                    }
+                    else
+                    {
+                        childItem.FlattenChildItems();
+                        flattenedChildItems.Add(childItem.ChildItems);
+                    }
+                }
+
+                this.ChildItems.Clear();
+                this.ChildItems.Add(flattenedChildItems);
+            }
+
+            /// <summary>
+            /// Adds a list of items to the 'after' ordering collection.
+            /// </summary>
+            /// <param name="items">List of items to add.</param>
+            /// <param name="messageHandler">Message handler in case a circular ordering reference is found.</param>
+            public void AddAfter(ItemCollection items, IMessageHandler messageHandler)
+            {
+                foreach (Item item in items)
+                {
+                    this.AddAfter(item, messageHandler);
+                }
+            }
+
+            /// <summary>
+            /// Adds an item to the 'after' ordering collection.
+            /// </summary>
+            /// <param name="item">Items to add.</param>
+            /// <param name="messageHandler">Message handler in case a circular ordering reference is found.</param>
+            public void AddAfter(Item after, IMessageHandler messageHandler)
+            {
+                if (this.beforeItems.Contains(after))
+                {
+                    // We could try to chain this up (the way that group circular dependencies
+                    // are reported), but since we're in the process of flattening, we may already
+                    // have lost some distinction between authored and propagated ordering.
+                    string circularReference = String.Format(CultureInfo.InvariantCulture, "{0}:{1} -> {2}:{3} -> {0}:{1}",
+                        this.Type, this.Id, after.Type, after.Id);
+                    messageHandler.OnMessage(WixErrors.OrderingReferenceLoopDetected(after.Row.SourceLineNumbers, circularReference));
+                    return;
+                }
+
+                this.afterItems.Add(after);
+                after.beforeItems.Add(this);
+            }
+
+            /// <summary>
+            /// Propagates 'after' dependencies from an item to its child items.
+            /// </summary>
+            /// <param name="messageHandler">Message handler in case a circular ordering reference is found.</param>
+            /// <remarks>Because items don't know about their parent groups (and can, in fact, be in more
+            /// than one group at a time), we need to propagate the 'afters' from each parent item to its children
+            /// before we attempt to flatten the ordering.</remarks>
+            public void PropagateAfterToChildItems(IMessageHandler messageHandler)
+            {
+                if (this.ShouldItemPropagateChildOrdering())
+                {
+                    foreach (Item childItem in this.childItems)
+                    {
+                        childItem.AddAfter(this.afterItems, messageHandler);
+                    }
+                }
+            }
+
+            /// <summary>
+            /// Flattens the ordering dependency for this item.
+            /// </summary>
+            /// <param name="messageHandler">Message handler in case a circular ordering reference is found.</param>
+            public void FlattenAfters(IMessageHandler messageHandler)
+            {
+                if (this.flattenedAfterItems)
+                {
+                    return;
+                }
+
+                this.flattenedAfterItems = true;
+
+                // Ensure that if we're after something (A), and *it's* after something (B),
+                // that we list ourselved as after both (A) *and* (B).
+                ItemCollection nestedAfterItems = new ItemCollection();
+
+                foreach (Item afterItem in this.afterItems)
+                {
+                    afterItem.FlattenAfters(messageHandler);
+                    nestedAfterItems.Add(afterItem.afterItems);
+
+                    if (afterItem.ShouldItemPropagateChildOrdering())
+                    {
+                        // If we are after a group, it really means
+                        // we are after all of the group's children.
+                        foreach (Item childItem in afterItem.ChildItems)
+                        {
+                            childItem.FlattenAfters(messageHandler);
+                            nestedAfterItems.Add(childItem.afterItems);
+                            nestedAfterItems.Add(childItem);
+                        }
+                    }
+                }
+
+                this.AddAfter(nestedAfterItems, messageHandler);
+            }
+
+            // We *don't* propagate ordering information from Packages or
+            // Containers to their children, because ordering doesn't matter
+            // for them, and a Payload in two Packages (or Containers) can
+            // cause a circular reference to occur.  We do, however, need to
+            // track the ordering in the UX Container, because we need the
+            // first payload to be the entrypoint.
+            private bool ShouldItemPropagateChildOrdering()
+            {
+                if (String.Equals("Package", this.Type, StringComparison.Ordinal) ||
+                    (String.Equals("Container", this.Type, StringComparison.Ordinal) &&
+                    !String.Equals(Compiler.BurnUXContainerId, this.Id, StringComparison.Ordinal)))
+                {
+                    return false;
+                }
+                return true;
+            }
+
+            /// <summary>
+            /// Helper IComparer class to make ordering easier.
+            /// </summary>
+            internal sealed class AfterItemComparer : IComparer<Item>
+            {
+                public int Compare(Item x, Item y)
+                {
+                    if (x.afterItems.Contains(y))
+                    {
+                        return 1;
+                    }
+                    else if (y.afterItems.Contains(x))
+                    {
+                        return -1;
+                    }
+
+                    return string.CompareOrdinal(x.Id, y.Id);
+                }
+            }
+        }
+    }
+}