Update to WiX Intermediate Representation

1 files changed, 40 insertions, 41 deletions

diff --git a/src/WixToolset.Core/Link/FindEntrySectionAndLoadSymbolsCommand.cs b/src/WixToolset.Core/Link/FindEntrySectionAndLoadSymbolsCommand.cs
index effb06e4..00613ca1 100644
--- a/src/WixToolset.Core/Link/FindEntrySectionAndLoadSymbolsCommand.cs
+++ b/src/WixToolset.Core/Link/FindEntrySectionAndLoadSymbolsCommand.cs
@@ -1,6 +1,6 @@
 // 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
+namespace WixToolset.Core.Link
 {
     using System;
     using System.Collections.Generic;
@@ -9,13 +9,13 @@ namespace WixToolset.Link
 
     internal class FindEntrySectionAndLoadSymbolsCommand : ICommand
     {
-        private IEnumerable<Section> sections;
-
-        public FindEntrySectionAndLoadSymbolsCommand(IEnumerable<Section> sections)
+        public FindEntrySectionAndLoadSymbolsCommand(IEnumerable<IntermediateSection> sections)
         {
-            this.sections = sections;
+            this.Sections = sections;
         }
 
+        private IEnumerable<IntermediateSection> Sections { get; }
+
         /// <summary>
         /// Sets the expected entry output type, based on output file extension provided to the linker.
         /// </summary>
@@ -24,13 +24,16 @@ namespace WixToolset.Link
         /// <summary>
         /// Gets the located entry section after the command is executed.
         /// </summary>
-        public Section EntrySection { get; private set; }
+        public IntermediateSection EntrySection { get; private set; }
 
         /// <summary>
         /// Gets the collection of loaded symbols.
         /// </summary>
         public IDictionary<string, Symbol> Symbols { get; private set; }
 
+        /// <summary>
+        /// Gets the collection of possibly conflicting symbols.
+        /// </summary>
         public IEnumerable<Symbol> PossiblyConflictingSymbols { get; private set; }
 
         public void Execute()
@@ -38,22 +41,22 @@ namespace WixToolset.Link
             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))
+            if (!Enum.TryParse(this.ExpectedOutputType.ToString(), out SectionType expectedEntrySectionType))
             {
                 expectedEntrySectionType = SectionType.Unknown;
             }
 
-            foreach (Section section in this.sections)
+            foreach (var 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));
-                    }
+                    // TODO: remove this?
+                    //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)
                     {
@@ -61,42 +64,38 @@ namespace WixToolset.Link
                     }
                     else
                     {
-                        Messaging.Instance.OnMessage(WixErrors.MultipleEntrySections(this.EntrySection.SourceLineNumbers, this.EntrySection.Id, section.Id));
-                        Messaging.Instance.OnMessage(WixErrors.MultipleEntrySections2(section.SourceLineNumbers));
+                        Messaging.Instance.OnMessage(WixErrors.MultipleEntrySections(this.EntrySection.Tuples.FirstOrDefault()?.SourceLineNumbers, this.EntrySection.Id, section.Id));
+                        Messaging.Instance.OnMessage(WixErrors.MultipleEntrySections2(section.Tuples.FirstOrDefault()?.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 (var row in section.Tuples.Where(t => t.Id != null))
                 {
-                    foreach (Row row in table.Rows)
-                    {
-                        Symbol symbol = new Symbol(row);
+                    var symbol = new Symbol(section, row);
 
-                        Symbol existingSymbol;
-                        if (!symbols.TryGetValue(symbol.Name, out existingSymbol))
+                    if (!symbols.TryGetValue(symbol.Name, out var 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 tuples. Identical directory tuples are redundant and will not cause
+                        // conflicts.
+                        if (AccessModifier.Private == existingSymbol.Access && AccessModifier.Private == symbol.Access &&
+                            TupleDefinitionType.Directory == existingSymbol.Row.Definition.Type && existingSymbol.Row.IsIdentical(symbol.Row))
                         {
-                            symbols.Add(symbol.Name, symbol);
+                            // Ensure identical symbol's tuple is marked redundant to ensure (should the tuple be
+                            // referenced into the final output) it will not add duplicate primary keys during
+                            // the .IDT importing.
+                            //symbol.Row.Redundant = true; - TODO: remove this
+                            existingSymbol.AddRedundant(symbol);
                         }
-                        else // uh-oh, duplicate symbols.
+                        else
                         {
-                            // 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);
-                            }
+                            existingSymbol.AddPossibleConflict(symbol);
+                            possibleConflicts.Add(existingSymbol);
                         }
                     }
                 }