Support implicit standard directory reference and "3264" platform folders

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

5 files changed, 159 insertions, 33 deletions

diff --git a/src/WixToolset.Core/Compiler.cs b/src/WixToolset.Core/Compiler.cs
index c504e96f..c641bceb 100644
--- a/src/WixToolset.Core/Compiler.cs
+++ b/src/WixToolset.Core/Compiler.cs
@@ -4279,8 +4279,7 @@ namespace WixToolset.Core
                     this.Core.AddInlineDirectoryId(inlineSyntax, id.Id);
                 }
             }
-
-            if ("TARGETDIR".Equals(id.Id, StringComparison.Ordinal) && !("SourceDir".Equals(name, StringComparison.Ordinal) && shortName == null && shortSourceName == null && sourceName == null))
+            else if ("TARGETDIR".Equals(id.Id, StringComparison.Ordinal) && !("SourceDir".Equals(name, StringComparison.Ordinal) && shortName == null && shortSourceName == null && sourceName == null))
             {
                 this.Core.Write(ErrorMessages.IllegalTargetDirDefaultDir(sourceLineNumbers, name));
             }
diff --git a/src/WixToolset.Core/ExtensibilityServices/PathResolver.cs b/src/WixToolset.Core/ExtensibilityServices/PathResolver.cs
index 15cd4fc9..72be2bcb 100644
--- a/src/WixToolset.Core/ExtensibilityServices/PathResolver.cs
+++ b/src/WixToolset.Core/ExtensibilityServices/PathResolver.cs
@@ -12,7 +12,7 @@ namespace WixToolset.Core.ExtensibilityServices
 
     internal class PathResolver : IPathResolver
     {
-        public string GetDirectoryPath(Dictionary<string, IResolvedDirectory> directories, Dictionary<string, string> componentIdGenSeeds, string directory, bool canonicalize)
+        public string GetCanonicalDirectoryPath(Dictionary<string, IResolvedDirectory> directories, Dictionary<string, string> componentIdGenSeeds, string directory, Platform platform)
         {
             if (!directories.TryGetValue(directory, out var resolvedDirectory))
             {
@@ -25,19 +25,13 @@ namespace WixToolset.Core.ExtensibilityServices
                 {
                     resolvedDirectory.Path = componentIdGenSeeds[directory];
                 }
-                else if (canonicalize && WindowsInstallerStandard.IsStandardDirectory(directory))
+                else if (WindowsInstallerStandard.IsStandardDirectory(directory))
                 {
-                    // when canonicalization is on, standard directories are treated equally
-                    resolvedDirectory.Path = directory;
+                    resolvedDirectory.Path = WindowsInstallerStandard.GetPlatformSpecificDirectoryId(directory, platform);
                 }
                 else
                 {
-                    string name = resolvedDirectory.Name;
-
-                    if (canonicalize)
-                    {
-                        name = name?.ToLowerInvariant();
-                    }
+                    var name = resolvedDirectory.Name?.ToLowerInvariant();
 
                     if (String.IsNullOrEmpty(resolvedDirectory.DirectoryParent))
                     {
@@ -45,7 +39,7 @@ namespace WixToolset.Core.ExtensibilityServices
                     }
                     else
                     {
-                        var parentPath = this.GetDirectoryPath(directories, componentIdGenSeeds, resolvedDirectory.DirectoryParent, canonicalize);
+                        var parentPath = this.GetCanonicalDirectoryPath(directories, componentIdGenSeeds, resolvedDirectory.DirectoryParent, platform);
 
                         if (null != resolvedDirectory.Name)
                         {
@@ -62,6 +56,39 @@ namespace WixToolset.Core.ExtensibilityServices
             return resolvedDirectory.Path;
         }
 
+        public string GetDirectoryPath(Dictionary<string, IResolvedDirectory> directories, string directory)
+        {
+            if (!directories.TryGetValue(directory, out var resolvedDirectory))
+            {
+                throw new WixException(ErrorMessages.ExpectedDirectory(directory));
+            }
+
+            if (null == resolvedDirectory.Path)
+            {
+                var name = resolvedDirectory.Name;
+
+                if (String.IsNullOrEmpty(resolvedDirectory.DirectoryParent))
+                {
+                    resolvedDirectory.Path = name;
+                }
+                else
+                {
+                    var parentPath = this.GetDirectoryPath(directories, resolvedDirectory.DirectoryParent);
+
+                    if (null != resolvedDirectory.Name)
+                    {
+                        resolvedDirectory.Path = Path.Combine(parentPath, name);
+                    }
+                    else
+                    {
+                        resolvedDirectory.Path = parentPath;
+                    }
+                }
+            }
+
+            return resolvedDirectory.Path;
+        }
+
         public string GetFileSourcePath(Dictionary<string, IResolvedDirectory> directories, string directoryId, string fileName, bool compressed, bool useLongName)
         {
             var fileSourcePath = Common.GetName(fileName, true, useLongName);
@@ -75,7 +102,7 @@ namespace WixToolset.Core.ExtensibilityServices
             {
                 // Get the relative path of where we want the file to be layed out as specified
                 // in the Directory table.
-                var directoryPath = this.GetDirectoryPath(directories, null, directoryId, false);
+                var directoryPath = this.GetDirectoryPath(directories, directoryId);
                 fileSourcePath = Path.Combine(directoryPath, fileSourcePath);
             }
 
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);
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Linker.cs b/src/WixToolset.Core/Linker.cs
index cdefa5c7..1cfd085d 100644
--- a/src/WixToolset.Core/Linker.cs
+++ b/src/WixToolset.Core/Linker.cs
@@ -149,13 +149,12 @@ namespace WixToolset.Core
                     throw new WixException(ErrorMessages.MissingEntrySection(this.Context.ExpectedOutputType.ToString()));
                 }
 
-                // Add the missing standard action symbols.
-                this.LoadStandardActions(find.EntrySection, find.SymbolsByName);
+                // Add the missing standard action and directory symbols.
+                this.LoadStandardSymbols(find.SymbolsByName);
 
                 // 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.Messaging, find.EntrySection, find.SymbolsByName);
-
                 resolve.Execute();
 
                 if (this.Messaging.EncounteredError)
@@ -732,14 +731,14 @@ namespace WixToolset.Core
 #endif
 
         /// <summary>
-        /// Load the standard action symbols.
+        /// Load the standard action and directory symbols.
         /// </summary>
         /// <param name="symbolsByName">Collection of symbols.</param>
-        private void LoadStandardActions(IntermediateSection section, IDictionary<string, SymbolWithSection> symbolsByName)
+        private void LoadStandardSymbols(IDictionary<string, SymbolWithSection> symbolsByName)
         {
             foreach (var actionSymbol in WindowsInstallerStandard.StandardActions())
             {
-                var symbolWithSection = new SymbolWithSection(section, actionSymbol);
+                var symbolWithSection = new SymbolWithSection(null, actionSymbol);
 
                 // If the action's symbol has not already been defined (i.e. overriden by the user), add it now.
                 if (!symbolsByName.ContainsKey(symbolWithSection.Name))
@@ -747,6 +746,17 @@ namespace WixToolset.Core
                     symbolsByName.Add(symbolWithSection.Name, symbolWithSection);
                 }
             }
+
+            foreach (var directorySymbol in WindowsInstallerStandard.StandardDirectories())
+            {
+                var symbolWithSection = new SymbolWithSection(null, directorySymbol);
+
+                // If the directory's symbol has not already been defined (i.e. overriden by the user), add it now.
+                if (!symbolsByName.ContainsKey(symbolWithSection.Name))
+                {
+                    symbolsByName.Add(symbolWithSection.Name, symbolWithSection);
+                }
+            }
         }
 
         /// <summary>