Support implicit standard directory reference and "3264" platform folders

Completes wixtoolset/issues#5798 and wixtoolset/issues#5835

2 files changed, 103 insertions, 13 deletions

diff --git a/src/WixToolset.Core/Link/ResolveReferencesCommand.cs b/src/WixToolset.Core/Link/ResolveReferencesCommand.cs
index d2be0699..90b61e8b 100644
--- a/src/WixToolset.Core/Link/ResolveReferencesCommand.cs
+++ b/src/WixToolset.Core/Link/ResolveReferencesCommand.cs
@@ -72,27 +72,22 @@ namespace WixToolset.Core.Link
                     continue;
                 }
 
-                if (!this.symbolsWithSections.TryGetValue(wixSimpleReferenceRow.SymbolicName, out var symbolWithSection))
-                {
-                    this.Messaging.Write(ErrorMessages.UnresolvedReference(wixSimpleReferenceRow.SourceLineNumbers, wixSimpleReferenceRow.SymbolicName));
-                }
-                else // see if the symbol (and any of its duplicates) are appropriately accessible.
+                // See if the symbol (and any of its duplicates) are appropriately accessible.
+                if (this.symbolsWithSections.TryGetValue(wixSimpleReferenceRow.SymbolicName, out var symbolWithSection))
                 {
                     var accessible = this.DetermineAccessibleSymbols(section, symbolWithSection);
-                    if (!accessible.Any())
-                    {
-                        this.Messaging.Write(ErrorMessages.UnresolvedReference(wixSimpleReferenceRow.SourceLineNumbers, wixSimpleReferenceRow.SymbolicName, symbolWithSection.Access));
-                    }
-                    else if (1 == accessible.Count)
+                    if (accessible.Count == 1)
                     {
                         var accessibleSymbol = accessible[0];
-                        this.referencedSymbols.Add(accessibleSymbol);
-
-                        if (null != accessibleSymbol.Section)
+                        if (this.referencedSymbols.Add(accessibleSymbol) && null != accessibleSymbol.Section)
                         {
                             this.RecursivelyResolveReferences(accessibleSymbol.Section);
                         }
                     }
+                    else if (accessible.Count == 0)
+                    {
+                        this.Messaging.Write(ErrorMessages.UnresolvedReference(wixSimpleReferenceRow.SourceLineNumbers, wixSimpleReferenceRow.SymbolicName, symbolWithSection.Access));
+                    }
                     else // display errors for the duplicate symbols.
                     {
                         var accessibleSymbol = accessible[0];
@@ -113,6 +108,10 @@ namespace WixToolset.Core.Link
                         }
                     }
                 }
+                else
+                {
+                    this.Messaging.Write(ErrorMessages.UnresolvedReference(wixSimpleReferenceRow.SourceLineNumbers, wixSimpleReferenceRow.SymbolicName));
+                }
             }
         }
 
diff --git a/src/WixToolset.Core/Link/SymbolWithSection.cs b/src/WixToolset.Core/Link/SymbolWithSection.cs
new file mode 100644
index 00000000..c8934d0f
--- /dev/null
+++ b/src/WixToolset.Core/Link/SymbolWithSection.cs
@@ -0,0 +1,91 @@
+// 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;
+
+    /// <summary>
+    /// Symbol with section representing a single unique symbol.
+    /// </summary>
+    internal class SymbolWithSection
+    {
+        private HashSet<SymbolWithSection> possibleConflicts;
+        private HashSet<SymbolWithSection> redundants;
+
+        /// <summary>
+        /// Creates a symbol for a symbol.
+        /// </summary>
+        /// <param name="symbol">Symbol for the symbol</param>
+        public SymbolWithSection(IntermediateSection section, IntermediateSymbol symbol)
+        {
+            this.Symbol = symbol;
+            this.Section = section;
+            this.Name = String.Concat(this.Symbol.Definition.Name, ":", this.Symbol.Id.Id);
+        }
+
+        /// <summary>
+        /// Gets the accessibility of the symbol which is a direct reflection of the accessibility of the row's accessibility.
+        /// </summary>
+        /// <value>Accessbility of the symbol.</value>
+        public AccessModifier Access => this.Symbol.Id.Access;
+
+        /// <summary>
+        /// Gets the name of the symbol.
+        /// </summary>
+        /// <value>Name of the symbol.</value>
+        public string Name { get; }
+
+        /// <summary>
+        /// Gets the symbol for this symbol.
+        /// </summary>
+        /// <value>Symbol for this symbol.</value>
+        public IntermediateSymbol Symbol { get; }
+
+        /// <summary>
+        /// Gets the section for the symbol.
+        /// </summary>
+        /// <value>Section for the symbol.</value>
+        public IntermediateSection Section { get; }
+
+        /// <summary>
+        /// Gets any duplicates of this symbol with sections that are possible conflicts.
+        /// </summary>
+        public IEnumerable<SymbolWithSection> PossiblyConflicts => this.possibleConflicts ?? Enumerable.Empty<SymbolWithSection>();
+
+        /// <summary>
+        /// Gets any duplicates of this symbol with sections that are redundant.
+        /// </summary>
+        public IEnumerable<SymbolWithSection> Redundants => this.redundants ?? Enumerable.Empty<SymbolWithSection>();
+
+        /// <summary>
+        /// Adds a duplicate symbol with sections that is a possible conflict.
+        /// </summary>
+        /// <param name="symbolWithSection">Symbol with section that is a possible conflict of this symbol.</param>
+        public void AddPossibleConflict(SymbolWithSection symbolWithSection)
+        {
+            if (null == this.possibleConflicts)
+            {
+                this.possibleConflicts = new HashSet<SymbolWithSection>();
+            }
+
+            this.possibleConflicts.Add(symbolWithSection);
+        }
+
+        /// <summary>
+        /// Adds a duplicate symbol that is redundant.
+        /// </summary>
+        /// <param name="symbolWithSection">Symbol with section that is redundant of this symbol.</param>
+        public void AddRedundant(SymbolWithSection symbolWithSection)
+        {
+            if (null == this.redundants)
+            {
+                this.redundants = new HashSet<SymbolWithSection>();
+            }
+
+            this.redundants.Add(symbolWithSection);
+        }
+    }
+}