Absorb Dependency.wixext into Core

Partly resolves wixtoolset/issues#5949

14 files changed, 668 insertions, 0 deletions

diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/BindDatabaseCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/BindDatabaseCommand.cs
index 25a093fd..a3f2da94 100644
--- a/src/WixToolset.Core.WindowsInstaller/Bind/BindDatabaseCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/BindDatabaseCommand.cs
@@ -325,6 +325,18 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 command.Execute();
             }
 
+            // Process dependency references.
+            if (SectionType.Product == section.Type || SectionType.Module == section.Type)
+            {
+                var dependencyRefs = section.Symbols.OfType<WixDependencyRefSymbol>().ToList();
+
+                if (dependencyRefs.Any())
+                {
+                    var command = new ProcessDependencyReferencesCommand(this.WindowsInstallerBackendHelper, section, dependencyRefs);
+                    command.Execute();
+                }
+            }
+
             // If there are any backend extensions, give them the opportunity to process
             // the section now that the fields have all be resolved.
             //
diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/ProcessDependencyReferencesCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/ProcessDependencyReferencesCommand.cs
new file mode 100644
index 00000000..899d06e1
--- /dev/null
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/ProcessDependencyReferencesCommand.cs
@@ -0,0 +1,111 @@
+// 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.WindowsInstaller.Bind
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using WixToolset.Data;
+    using WixToolset.Data.Symbols;
+    using WixToolset.Extensibility.Services;
+
+    internal class ProcessDependencyReferencesCommand
+    {
+        // The root registry key for the dependency extension. We write to Software\Classes explicitly
+        // based on the current security context instead of HKCR. See
+        // http://msdn.microsoft.com/en-us/library/ms724475(VS.85).aspx for more information.
+        private const string DependencyRegistryRoot = @"Software\Classes\Installer\Dependencies\";
+        private const string RegistryDependents = "Dependents";
+
+        public ProcessDependencyReferencesCommand(IWindowsInstallerBackendHelper backendHelper, IntermediateSection section, IEnumerable<WixDependencyRefSymbol> dependencyRefSymbols)
+        {
+            this.Section = section;
+            this.DependencyRefSymbols = dependencyRefSymbols;
+        }
+
+        private IntermediateSection Section { get; }
+
+        private IEnumerable<WixDependencyRefSymbol> DependencyRefSymbols { get; }
+
+        public void Execute()
+        {
+            var wixDependencyRows = this.Section.Symbols.OfType<WixDependencySymbol>().ToDictionary(d => d.Id.Id);
+            var wixDependencyProviderRows = this.Section.Symbols.OfType<WixDependencyProviderSymbol>().ToDictionary(d => d.Id.Id);
+
+            // For each relationship, get the provides and requires rows to generate registry values.
+            foreach (var wixDependencyRefRow in this.DependencyRefSymbols)
+            {
+                var providesId = wixDependencyRefRow.WixDependencyProviderRef;
+                var requiresId = wixDependencyRefRow.WixDependencyRef;
+
+                // If we do not find both symbols, skip the registry key generation.
+                if (!wixDependencyRows.TryGetValue(requiresId, out var wixDependencyRow))
+                {
+                    continue;
+                }
+
+                if (!wixDependencyProviderRows.TryGetValue(providesId, out var wixDependencyProviderRow))
+                {
+                    continue;
+                }
+
+                // Format the root registry key using the required provider key and the current provider key.
+                var requiresKey = wixDependencyRow.Id.Id;
+                var providesKey = wixDependencyRow.ProviderKey;
+                var keyRequires = String.Format(@"{0}{1}\{2}\{3}", DependencyRegistryRoot, requiresKey, RegistryDependents, providesKey);
+
+                // Get the component ID from the provider.
+                var componentId = wixDependencyProviderRow.ComponentRef;
+
+                var id = Common.GenerateIdentifier("reg", providesId, requiresId, "(Default)");
+                this.Section.AddSymbol(new RegistrySymbol(wixDependencyRefRow.SourceLineNumbers, new Identifier(AccessModifier.Private, id))
+                {
+                    ComponentRef = componentId,
+                    Root = RegistryRootType.MachineUser,
+                    Key = keyRequires,
+                    Name = "*",
+                });
+
+                if (!String.IsNullOrEmpty(wixDependencyRow.MinVersion))
+                {
+                    id = Common.GenerateIdentifier("reg", providesId, requiresId, "MinVersion");
+                    this.Section.AddSymbol(new RegistrySymbol(wixDependencyRefRow.SourceLineNumbers, new Identifier(AccessModifier.Private, id))
+                    {
+                        ComponentRef = componentId,
+                        Root = RegistryRootType.MachineUser,
+                        Key = keyRequires,
+                        Name = "MinVersion",
+                        Value = wixDependencyRow.MinVersion
+                    });
+                }
+
+                string maxVersion = (string)wixDependencyRow[3];
+                if (!String.IsNullOrEmpty(wixDependencyRow.MaxVersion))
+                {
+                    id = Common.GenerateIdentifier("reg", providesId, requiresId, "MaxVersion");
+                    this.Section.AddSymbol(new RegistrySymbol(wixDependencyRefRow.SourceLineNumbers, new Identifier(AccessModifier.Private, id))
+                    {
+                        ComponentRef = componentId,
+                        Root = RegistryRootType.MachineUser,
+                        Key = keyRequires,
+                        Name = "MaxVersion",
+                        Value = wixDependencyRow.MaxVersion
+                    });
+                }
+
+                if (wixDependencyRow.Attributes != WixDependencySymbolAttributes.None)
+                {
+                    id = Common.GenerateIdentifier("reg", providesId, requiresId, "Attributes");
+                    this.Section.AddSymbol(new RegistrySymbol(wixDependencyRefRow.SourceLineNumbers, new Identifier(AccessModifier.Private, id))
+                    {
+                        ComponentRef = componentId,
+                        Root = RegistryRootType.MachineUser,
+                        Key = keyRequires,
+                        Name = "Attributes",
+                        Value = String.Concat("#", (int)wixDependencyRow.Attributes)
+                    });
+                }
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Compiler.cs b/src/WixToolset.Core/Compiler.cs
index 85261cce..ac99a8a1 100644
--- a/src/WixToolset.Core/Compiler.cs
+++ b/src/WixToolset.Core/Compiler.cs
@@ -2366,6 +2366,16 @@ namespace WixToolset.Core
                         var foundExtension = false;
                         this.ParseProgIdElement(child, id.Id, YesNoType.NotSet, null, null, null, ref foundExtension, YesNoType.NotSet);
                         break;
+                    case "Provides":
+                        if (win64)
+                        {
+                            this.Messaging.Write(CompilerWarnings.Win64Component(sourceLineNumbers, id.Id));
+                        }
+
+                        keyPathSet = this.ParseProvidesElement(child, null, id.Id, out keyPossible);
+                        keyBit = ComponentKeyPathType.Registry;
+                        break;
+
                     case "RegistryKey":
                         keyPathSet = this.ParseRegistryKeyElement(child, id.Id, null, null, win64, out keyPossible);
                         keyBit = ComponentKeyPathType.Registry;
@@ -6290,6 +6300,9 @@ namespace WixToolset.Core
                     case "RelatedBundle":
                         this.ParseRelatedBundleElement(child);
                         break;
+                    case "Requires":
+                        this.ParseRequiresElement(child, null, false);
+                        break;
                     case "SetDirectory":
                         this.ParseSetDirectoryElement(child);
                         break;
diff --git a/src/WixToolset.Core/CompilerErrors.cs b/src/WixToolset.Core/CompilerErrors.cs
index da64c376..9b3d85b9 100644
--- a/src/WixToolset.Core/CompilerErrors.cs
+++ b/src/WixToolset.Core/CompilerErrors.cs
@@ -6,6 +6,16 @@ namespace WixToolset.Core
 
     internal static class CompilerErrors
     {
+        public static Message IllegalCharactersInProvider(SourceLineNumber sourceLineNumbers, string attributeName, char illegalChar, string illegalChars)
+        {
+            return Message(sourceLineNumbers, Ids.IllegalCharactersInProvider, "The provider key authored into the {0} attribute contains an illegal character, '{1}'. Please author the provider key without any of the following characters: {2}", attributeName, illegalChar, illegalChars);
+        }
+
+        public static Message ReservedValue(SourceLineNumber sourceLineNumbers, string elementName, string attributeName, string attributeValue)
+        {
+            return Message(sourceLineNumbers, Ids.ReservedValue, "The {0}/@{1} attribute value '{2}' is reserved and cannot be used here. Please choose a different value.", elementName, attributeName, attributeValue);
+        }
+
         public static Message IllegalName(SourceLineNumber sourceLineNumbers, string parentElement, string name)
         {
             return Message(sourceLineNumbers, Ids.IllegalName, "The Tag/@Name attribute value, '{1}', contains invalid filename identifiers. The Tag/@Name may have defaulted from the {0}/@Name attrbute. If so, use the Tag/@Name attribute to provide a valid filename. Any character except for the follow may be used: \\ ? | > < : / * \".", parentElement, name);
@@ -23,6 +33,9 @@ namespace WixToolset.Core
 
         public enum Ids
         {
+            IllegalCharactersInProvider = 5400,
+            ReservedValue = 5401,
+
             IllegalName = 6601,
             ExampleRegid = 6602,
         }
diff --git a/src/WixToolset.Core/CompilerWarnings.cs b/src/WixToolset.Core/CompilerWarnings.cs
new file mode 100644
index 00000000..3b9666dd
--- /dev/null
+++ b/src/WixToolset.Core/CompilerWarnings.cs
@@ -0,0 +1,53 @@
+// 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
+{
+    using WixToolset.Data;
+
+    internal static class CompilerWarnings
+    {
+        public static Message DiscouragedVersionAttribute(SourceLineNumber sourceLineNumbers)
+        {
+            return Message(sourceLineNumbers, Ids.DiscouragedVersionAttribute, "The Provides/@Version attribute should not be specified in an MSI package. The ProductVersion will be used by default.");
+        }
+
+        public static Message DiscouragedVersionAttribute(SourceLineNumber sourceLineNumbers, string id)
+        {
+            return Message(sourceLineNumbers, Ids.DiscouragedVersionAttribute, "The Provides/@Version attribute should not be specified for MSI package {0}. The ProductVersion will be used by default.", id);
+        }
+
+        public static Message PropertyRemoved(string name)
+        {
+            return Message(null, Ids.PropertyRemoved, "The property {0} was authored in the package with a value and will be removed. The property should not be authored.", name);
+        }
+
+        public static Message ProvidesKeyNotFound(SourceLineNumber sourceLineNumbers, string id)
+        {
+            return Message(sourceLineNumbers, Ids.ProvidesKeyNotFound, "The provider key with identifier {0} was not found in the WixDependencyProvider table. Related registry rows will not be removed from authoring.", id);
+        }
+
+        public static Message RequiresKeyNotFound(SourceLineNumber sourceLineNumbers, string id)
+        {
+            return Message(sourceLineNumbers, Ids.RequiresKeyNotFound, "The dependency key with identifier {0} was not found in the WixDependency table. Related registry rows will not be removed from authoring.", id);
+        }
+
+        public static Message Win64Component(SourceLineNumber sourceLineNumbers, string componentId)
+        {
+            return Message(sourceLineNumbers, Ids.Win64Component, "The Provides element should not be authored in the 64-bit component with identifier {0}. The dependency feature may not work if installing this package on 64-bit Windows operating systems prior to Windows 7 and Windows Server 2008 R2. Set the Component/@Bitness attribute to \"always32\" to ensure the dependency feature works correctly on legacy operating systems.", componentId);
+        }
+
+        private static Message Message(SourceLineNumber sourceLineNumber, Ids id, string format, params object[] args)
+        {
+            return new Message(sourceLineNumber, MessageLevel.Warning, (int)id, format, args);
+        }
+
+        public enum Ids
+        {
+            ProvidesKeyNotFound = 5431,
+            RequiresKeyNotFound = 5432,
+            PropertyRemoved = 5433,
+            DiscouragedVersionAttribute = 5434,
+            Win64Component = 5435,
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Compiler_Bundle.cs b/src/WixToolset.Core/Compiler_Bundle.cs
index 1ee09166..b8c7b7b1 100644
--- a/src/WixToolset.Core/Compiler_Bundle.cs
+++ b/src/WixToolset.Core/Compiler_Bundle.cs
@@ -196,6 +196,9 @@ namespace WixToolset.Core
                     case "ParentName":
                         parentName = this.Core.GetAttributeValue(sourceLineNumbers, attrib);
                         break;
+                    case "ProviderKey":
+                        this.ParseBundleProviderKeyAttribute(sourceLineNumbers, node, attrib);
+                        break;
                     case "SplashScreenSourceFile":
                         splashScreenSourceFile = this.Core.GetAttributeValue(sourceLineNumbers, attrib);
                         break;
@@ -340,6 +343,9 @@ namespace WixToolset.Core
                     case "RelatedBundle":
                         this.ParseRelatedBundleElement(child);
                         break;
+                    case "Requires":
+                        this.ParseRequiresElement(child, null, false);
+                        break;
                     case "SetVariable":
                         this.ParseSetVariableElement(child);
                         break;
@@ -2386,6 +2392,9 @@ namespace WixToolset.Core
                     case "PayloadGroupRef":
                         this.ParsePayloadGroupRefElement(child, ComplexReferenceParentType.Package, id, ComplexReferenceChildType.Unknown, null);
                         break;
+                    case "Provides":
+                        this.ParseProvidesElement(child, packageType, id.Id, out _);
+                        break;
                     case "ExitCode":
                         allowed = (packageType == WixBundlePackageType.Exe);
                         if (allowed)
diff --git a/src/WixToolset.Core/Compiler_Dependency.cs b/src/WixToolset.Core/Compiler_Dependency.cs
new file mode 100644
index 00000000..74982fba
--- /dev/null
+++ b/src/WixToolset.Core/Compiler_Dependency.cs
@@ -0,0 +1,385 @@
+// 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
+{
+    using System;
+    using System.Xml.Linq;
+    using WixToolset.Data;
+    using WixToolset.Data.Symbols;
+
+    /// <summary>
+    /// Compiler of the WiX toolset.
+    /// </summary>
+    internal partial class Compiler : ICompiler
+    {
+        // The root registry key for the dependency extension. We write to Software\Classes explicitly
+        // based on the current security context instead of HKCR. See
+        // http://msdn.microsoft.com/en-us/library/ms724475(VS.85).aspx for more information.
+        private const string DependencyRegistryRoot = @"Software\Classes\Installer\Dependencies\";
+
+        private static readonly char[] InvalidDependencyCharacters = new char[] { ' ', '\"', ';', '\\' };
+
+        /// <summary>
+        /// Processes the ProviderKey bundle attribute.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line number for the parent element.</param>
+        /// <param name="parentElement">Parent element of attribute.</param>
+        /// <param name="attribute">The XML attribute for the ProviderKey attribute.</param>
+        private void ParseBundleProviderKeyAttribute(SourceLineNumber sourceLineNumbers, XElement parentElement, XAttribute attribute)
+        {
+            var providerKey = this.Core.GetAttributeValue(sourceLineNumbers, attribute);
+            int illegalChar;
+
+            // Make sure the key does not contain any illegal characters or values.
+            if (String.IsNullOrEmpty(providerKey))
+            {
+                this.Messaging.Write(ErrorMessages.IllegalEmptyAttributeValue(sourceLineNumbers, parentElement.Name.LocalName, attribute.Name.LocalName));
+            }
+            else if (0 <= (illegalChar = providerKey.IndexOfAny(InvalidDependencyCharacters)))
+            {
+                this.Messaging.Write(CompilerErrors.IllegalCharactersInProvider(sourceLineNumbers, "ProviderKey", providerKey[illegalChar], String.Join(" ", InvalidDependencyCharacters)));
+            }
+            else if ("ALL" == providerKey)
+            {
+                this.Messaging.Write(CompilerErrors.ReservedValue(sourceLineNumbers, parentElement.Name.LocalName, "ProviderKey", providerKey));
+            }
+
+            if (!this.Messaging.EncounteredError)
+            {
+                // Generate the primary key for the row.
+                var id = this.Core.CreateIdentifier("dep", attribute.Name.LocalName, providerKey);
+
+                // Create the provider symbol for the bundle. The Component_ field is required
+                // in the table definition but unused for bundles, so just set it to the valid ID.
+                this.Core.AddSymbol(new WixDependencyProviderSymbol(sourceLineNumbers, id)
+                {
+                    ComponentRef = id.Id,
+                    ProviderKey = providerKey,
+                    Attributes = WixDependencyProviderAttributes.ProvidesAttributesBundle,
+                });
+            }
+        }
+
+        /// <summary>
+        /// Processes the Provides element.
+        /// </summary>
+        /// <param name="node">The XML node for the Provides element.</param>
+        /// <param name="packageType">The type of the package being chained into a bundle, or null if building an MSI package.</param>
+        /// <param name="parentId">The identifier of the parent component or package.</param>
+        /// <param name="possibleKeyPath">Possible KeyPath identifier.</param>
+        /// <returns>Yes if this is the keypath.</returns>
+        private YesNoType ParseProvidesElement(XElement node, WixBundlePackageType? packageType, string parentId, out string possibleKeyPath)
+        {
+            possibleKeyPath = null;
+
+            var sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            string key = null;
+            string version = null;
+            string displayName = null;
+
+            foreach (var attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.Core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Key":
+                            key = this.Core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Version":
+                            version = this.Core.GetAttributeVersionValue(sourceLineNumbers, attrib);
+                            break;
+                        case "DisplayName":
+                            displayName = this.Core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.Core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.Core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            // Make sure the key is valid. The key will default to the ProductCode for MSI packages
+            // and the package code for MSP packages in the binder if not specified.
+            if (!String.IsNullOrEmpty(key))
+            {
+                int illegalChar;
+
+                // Make sure the key does not contain any illegal characters or values.
+                if (0 <= (illegalChar = key.IndexOfAny(InvalidDependencyCharacters)))
+                {
+                    this.Messaging.Write(CompilerErrors.IllegalCharactersInProvider(sourceLineNumbers, "Key", key[illegalChar], String.Join(" ", InvalidDependencyCharacters)));
+                }
+                else if ("ALL" == key)
+                {
+                    this.Messaging.Write(CompilerErrors.ReservedValue(sourceLineNumbers, node.Name.LocalName, "Key", key));
+                }
+            }
+            else if (!packageType.HasValue)
+            {
+                // Make sure the ProductCode is authored and set the key.
+                this.Core.CreateSimpleReference(sourceLineNumbers, SymbolDefinitions.Property, "ProductCode");
+                key = "!(bind.property.ProductCode)";
+            }
+            else if (WixBundlePackageType.Exe == packageType || WixBundlePackageType.Msu == packageType)
+            {
+                // Must specify the provider key when authored for a package.
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Key"));
+            }
+
+            // The Version attribute should not be authored in or for an MSI package.
+            if (!String.IsNullOrEmpty(version))
+            {
+                switch (packageType)
+                {
+                    case null:
+                        this.Messaging.Write(CompilerWarnings.DiscouragedVersionAttribute(sourceLineNumbers));
+                        break;
+                    case WixBundlePackageType.Msi:
+                        this.Messaging.Write(CompilerWarnings.DiscouragedVersionAttribute(sourceLineNumbers, parentId));
+                        break;
+                }
+            }
+            else if (WixBundlePackageType.Msp == packageType || WixBundlePackageType.Msu == packageType)
+            {
+                // Must specify the Version when authored for packages that do not contain a version.
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Version"));
+            }
+
+            // Need the element ID for child element processing, so generate now if not authored.
+            if (null == id)
+            {
+                id = this.Core.CreateIdentifier("dep", node.Name.LocalName, parentId, key);
+            }
+
+            foreach (var child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "Requires":
+                            this.ParseRequiresElement(child, id.Id, requiresAction: !packageType.HasValue);
+                            break;
+                        case "RequiresRef":
+                            this.ParseRequiresRefElement(child, id.Id, requiresAction: !packageType.HasValue);
+                            break;
+                        default:
+                            this.Core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.Core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (!this.Messaging.EncounteredError)
+            {
+                var symbol = this.Core.AddSymbol(new WixDependencyProviderSymbol(sourceLineNumbers, id)
+                {
+                    ComponentRef = parentId,
+                    ProviderKey = key,
+                });
+
+                if (!String.IsNullOrEmpty(version))
+                {
+                    symbol.Version = version;
+                }
+
+                if (!String.IsNullOrEmpty(displayName))
+                {
+                    symbol.DisplayName = displayName;
+                }
+
+                if (!packageType.HasValue)
+                {
+                    // Generate registry rows for the provider using binder properties.
+                    var keyProvides = String.Concat(DependencyRegistryRoot, key);
+                    var root = RegistryRootType.MachineUser;
+
+                    var value = "[ProductCode]";
+                    this.Core.CreateRegistryRow(sourceLineNumbers, root, keyProvides, null, value, parentId);
+
+                    value = !String.IsNullOrEmpty(version) ? version : "[ProductVersion]";
+                    var versionRegistrySymbol = this.Core.CreateRegistryRow(sourceLineNumbers, root, keyProvides, "Version", value, parentId);
+
+                    value = !String.IsNullOrEmpty(displayName) ? displayName : "[ProductName]";
+                    this.Core.CreateRegistryRow(sourceLineNumbers, root, keyProvides, "DisplayName", value, parentId);
+
+                    // Use the Version registry value and use that as a potential key path.
+                    possibleKeyPath = versionRegistrySymbol.Id;
+                }
+            }
+
+            return YesNoType.NotSet;
+        }
+
+        /// <summary>
+        /// Processes the Requires element.
+        /// </summary>
+        /// <param name="node">The XML node for the Requires element.</param>
+        /// <param name="providerId">The parent provider identifier.</param>
+        /// <param name="requiresAction">Whether the Requires custom action should be referenced.</param>
+        private void ParseRequiresElement(XElement node, string providerId, bool requiresAction)
+        {
+            var sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            string providerKey = null;
+            string minVersion = null;
+            string maxVersion = null;
+            var attributes = WixDependencySymbolAttributes.None;
+            var illegalChar = -1;
+
+            foreach (var attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.Core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "ProviderKey":
+                            providerKey = this.Core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Minimum":
+                            minVersion = this.Core.GetAttributeVersionValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Maximum":
+                            maxVersion = this.Core.GetAttributeVersionValue(sourceLineNumbers, attrib);
+                            break;
+                        case "IncludeMinimum":
+                            if (YesNoType.Yes == this.Core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= WixDependencySymbolAttributes.RequiresAttributesMinVersionInclusive;
+                            }
+                            break;
+                        case "IncludeMaximum":
+                            if (YesNoType.Yes == this.Core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= WixDependencySymbolAttributes.RequiresAttributesMaxVersionInclusive;
+                            }
+                            break;
+                        default:
+                            this.Core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.Core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            this.Core.ParseForExtensionElements(node);
+
+            if (null == id)
+            {
+                // Generate an ID only if this element is authored under a Provides element; otherwise, a RequiresRef
+                // element will be necessary and the Id attribute will be required.
+                if (!String.IsNullOrEmpty(providerId))
+                {
+                    id = this.Core.CreateIdentifier("dep", node.Name.LocalName, providerKey);
+                }
+                else
+                {
+                    this.Messaging.Write(ErrorMessages.ExpectedAttributeWhenElementNotUnderElement(sourceLineNumbers, node.Name.LocalName, "Id", "Provides"));
+                    id = Identifier.Invalid;
+                }
+            }
+
+            if (String.IsNullOrEmpty(providerKey))
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "ProviderKey"));
+            }
+            // Make sure the key does not contain any illegal characters.
+            else if (0 <= (illegalChar = providerKey.IndexOfAny(InvalidDependencyCharacters)))
+            {
+                this.Messaging.Write(CompilerErrors.IllegalCharactersInProvider(sourceLineNumbers, "ProviderKey", providerKey[illegalChar], String.Join(" ", InvalidDependencyCharacters)));
+            }
+
+            if (!this.Messaging.EncounteredError)
+            {
+                var symbol = this.Core.AddSymbol(new WixDependencySymbol(sourceLineNumbers, id)
+                {
+                    ProviderKey = providerKey,
+                    MinVersion = minVersion,
+                    MaxVersion = maxVersion,
+                    Attributes = attributes
+                });
+
+                // Create the relationship between this WixDependency symbol and the WixDependencyProvider symbol.
+                if (!String.IsNullOrEmpty(providerId))
+                {
+                    this.Core.AddSymbol(new WixDependencyRefSymbol(sourceLineNumbers)
+                    {
+                        WixDependencyProviderRef = providerId,
+                        WixDependencyRef = id.Id,
+                    });
+                }
+            }
+        }
+
+        /// <summary>
+        /// Processes the RequiresRef element.
+        /// </summary>
+        /// <param name="node">The XML node for the RequiresRef element.</param>
+        /// <param name="providerId">The parent provider identifier.</param>
+        /// <param name="requiresAction">Whether the Requires custom action should be referenced.</param>
+        private void ParseRequiresRefElement(XElement node, string providerId, bool requiresAction)
+        {
+            var sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string id = null;
+
+            foreach (var attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.Core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.Core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.Core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            this.Core.ParseForExtensionElements(node);
+
+            if (String.IsNullOrEmpty(id))
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            if (!this.Messaging.EncounteredError)
+            {
+                // Create a link dependency on the row that contains information we'll need during bind.
+                this.Core.CreateSimpleReference(sourceLineNumbers, SymbolDefinitions.WixDependency, id);
+
+                // Create the relationship between the WixDependency row and the parent WixDependencyProvider row.
+                this.Core.AddSymbol(new WixDependencyRefSymbol(sourceLineNumbers)
+                {
+                    WixDependencyProviderRef = providerId,
+                    WixDependencyRef = id,
+                });
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Compiler_Module.cs b/src/WixToolset.Core/Compiler_Module.cs
index d730ae5d..6953467f 100644
--- a/src/WixToolset.Core/Compiler_Module.cs
+++ b/src/WixToolset.Core/Compiler_Module.cs
@@ -190,6 +190,9 @@ namespace WixToolset.Core
                         case "PropertyRef":
                             this.ParseSimpleRefElement(child, SymbolDefinitions.Property);
                             break;
+                        case "Requires":
+                            this.ParseRequiresElement(child, null, false);
+                            break;
                         case "SetDirectory":
                             this.ParseSetDirectoryElement(child);
                             break;
diff --git a/src/WixToolset.Core/Compiler_2.cs b/src/WixToolset.Core/Compiler_Package.cs
index 295392c8..d2728e9c 100644
--- a/src/WixToolset.Core/Compiler_2.cs
+++ b/src/WixToolset.Core/Compiler_Package.cs
@@ -306,6 +306,9 @@ namespace WixToolset.Core
                         case "PropertyRef":
                             this.ParseSimpleRefElement(child, SymbolDefinitions.Property);
                             break;
+                        case "Requires":
+                            this.ParseRequiresElement(child, null, false);
+                            break;
                         case "SetDirectory":
                             this.ParseSetDirectoryElement(child);
                             break;
diff --git a/src/test/WixToolsetTest.CoreIntegration/DependencyExtensionFixture.cs b/src/test/WixToolsetTest.CoreIntegration/DependencyExtensionFixture.cs
new file mode 100644
index 00000000..14eb8ff7
--- /dev/null
+++ b/src/test/WixToolsetTest.CoreIntegration/DependencyExtensionFixture.cs
@@ -0,0 +1,30 @@
+// 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 WixToolsetTest.CoreIntegration
+{
+    using WixBuildTools.TestSupport;
+    using WixToolset.Core.TestPackage;
+    using Xunit;
+
+    public class DependencyExtensionFixture
+    {
+        [Fact]
+        public void CanBuildUsingProvides()
+        {
+            var folder = TestData.Get(@"TestData\UsingProvides");
+            var build = new Builder(folder, null, new[] { folder });
+
+            var results = build.BuildAndQuery(Build, "WixDependencyProvider");
+            Assert.Equal(new[]
+            {
+                "WixDependencyProvider:dep74OfIcniaqxA7EprRGBw4Oyy3r8\tfilF5_pLhBuF5b4N9XEo52g_hUM5Lo\tUsingProvides\t\t\t",
+            }, results);
+        }
+
+        private static void Build(string[] args)
+        {
+            var result = WixRunner.Execute(args)
+                                  .AssertSuccess();
+        }
+    }
+}
diff --git a/src/test/WixToolsetTest.CoreIntegration/TestData/UsingProvides/Package.en-us.wxl b/src/test/WixToolsetTest.CoreIntegration/TestData/UsingProvides/Package.en-us.wxl
new file mode 100644
index 00000000..38c12ac1
--- /dev/null
+++ b/src/test/WixToolsetTest.CoreIntegration/TestData/UsingProvides/Package.en-us.wxl
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<!--
+This file contains the declaration of all the localizable strings.
+-->
+<WixLocalization xmlns="http://wixtoolset.org/schemas/v4/wxl" Culture="en-US">
+
+  <String Id="DowngradeError">A newer version of [ProductName] is already installed.</String>
+  <String Id="FeatureTitle">MsiPackage</String>
+
+</WixLocalization>
diff --git a/src/test/WixToolsetTest.CoreIntegration/TestData/UsingProvides/Package.wxs b/src/test/WixToolsetTest.CoreIntegration/TestData/UsingProvides/Package.wxs
new file mode 100644
index 00000000..07da1215
--- /dev/null
+++ b/src/test/WixToolsetTest.CoreIntegration/TestData/UsingProvides/Package.wxs
@@ -0,0 +1,14 @@
+<Wix xmlns="http://wixtoolset.org/schemas/v4/wxs">
+  <Package Name="MsiPackage" Language="1033" Version="1.0.0.0" Manufacturer="Example Corporation" UpgradeCode="047730a5-30fe-4a62-a520-da9381b8226a">
+
+    <MajorUpgrade DowngradeErrorMessage="!(loc.DowngradeError)" />
+
+    <Feature Id="ProductFeature" Title="!(loc.FeatureTitle)">
+      <ComponentGroupRef Id="ProductComponents" />
+    </Feature>
+  </Package>
+
+  <Fragment>
+    <Directory Id="INSTALLFOLDER" Name="ProgramFilesFolder:\MsiPackage" />
+  </Fragment>
+</Wix>
diff --git a/src/test/WixToolsetTest.CoreIntegration/TestData/UsingProvides/PackageComponents.wxs b/src/test/WixToolsetTest.CoreIntegration/TestData/UsingProvides/PackageComponents.wxs
new file mode 100644
index 00000000..7e459e9a
--- /dev/null
+++ b/src/test/WixToolsetTest.CoreIntegration/TestData/UsingProvides/PackageComponents.wxs
@@ -0,0 +1,10 @@
+<Wix xmlns="http://wixtoolset.org/schemas/v4/wxs">
+  <Fragment>
+    <ComponentGroup Id="ProductComponents" Directory="INSTALLFOLDER">
+        <Component>
+            <File Source="example.txt" />
+            <Provides Key="UsingProvides" />
+        </Component>
+    </ComponentGroup>
+  </Fragment>
+</Wix>
diff --git a/src/test/WixToolsetTest.CoreIntegration/TestData/UsingProvides/example.txt b/src/test/WixToolsetTest.CoreIntegration/TestData/UsingProvides/example.txt
new file mode 100644
index 00000000..1b4ffe8a
--- /dev/null
+++ b/src/test/WixToolsetTest.CoreIntegration/TestData/UsingProvides/example.txt
@@ -0,0 +1 @@
+This is example.txt.
\ No newline at end of file