Add support for adding RIDs to runtime.json during build

src/libraries/Microsoft.NETCore.Platforms/src/GenerateRuntimeGraph.cs

@@ -53,6 +53,24 @@ public ITaskItem[] RuntimeGroups
             set;
         }
 
+        /// <summary>
+        /// Additional runtime identifiers to add to the graph.
+        /// </summary>
+        public string[] AdditionalRuntimeIdentifiers
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Parent RID to use for any unknown AdditionalRuntimeIdentifer.
+        /// </summary>
+        public string AdditionalRuntimeIdentifierParent
+        {
+            get;
+            set;
+        }
+
         /// <summary>
         /// Optional source Runtime.json to use as a starting point when merging additional RuntimeGroups
         /// </summary>
@@ -134,7 +152,11 @@ public override bool Execute()
                 runtimeGraph = new RuntimeGraph();
             }
 
-            foreach (var runtimeGroup in RuntimeGroups.NullAsEmpty().Select(i => new RuntimeGroup(i)))
+            List<RuntimeGroup> runtimeGroups = RuntimeGroups.NullAsEmpty().Select(i => new RuntimeGroup(i)).ToList();
+
+            AddRuntimeIdentifiers(runtimeGroups);
+
+            foreach (var runtimeGroup in runtimeGroups)
             {
                 runtimeGraph = SafeMerge(runtimeGraph, runtimeGroup);
             }
@@ -291,6 +313,21 @@ private void ValidateImports(RuntimeGraph runtimeGraph, IDictionary<string, stri
             }
         }
 
+        private void AddRuntimeIdentifiers(ICollection<RuntimeGroup> runtimeGroups)
+        {
+            if (AdditionalRuntimeIdentifiers == null || AdditionalRuntimeIdentifiers.Length == 0)
+            {
+                return;
+            }
+
+            RuntimeGroupCollection runtimeGroupCollection = new RuntimeGroupCollection(runtimeGroups);
+
+            foreach (string additionalRuntimeIdentifier in AdditionalRuntimeIdentifiers)
+            {
+                runtimeGroupCollection.AddRuntimeIdentifier(additionalRuntimeIdentifier, AdditionalRuntimeIdentifierParent);
+            }
+        }
+
         private static IDictionary<string, IEnumerable<string>> GetCompatibilityMap(RuntimeGraph graph)
         {
             Dictionary<string, IEnumerable<string>> compatibilityMap = new Dictionary<string, IEnumerable<string>>();

src/libraries/Microsoft.NETCore.Platforms/src/Microsoft.NETCore.Platforms.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.SDK">
+<Project Sdk="Microsoft.NET.SDK">
   <!-- These are wrapper project files for packaging.-->
   <PropertyGroup>
     <TargetFrameworks>$(NetCoreAppToolCurrent);net472</TargetFrameworks>
@@ -14,6 +14,13 @@
     <PackageDescription>Provides runtime information required to resolve target framework, platform, and runtime specific implementations of .NETCore packages.</PackageDescription>
   </PropertyGroup>
 
+  <PropertyGroup Condition="'$(DotNetBuildFromSource)' == 'true'">
+    <!-- When building from source, ensure the RID we're building for is part of the RID graph -->
+    <AdditionalRuntimeIdentifiers>$(AdditionalRuntimeIdentifiers);$(OutputRID)</AdditionalRuntimeIdentifiers>
+    <!-- Also ensure the RID we're bulding on is part of the RID graph, since this may be more specific -->
+    <AdditionalRuntimeIdentifiers>$(AdditionalRuntimeIdentifiers);$([System.Runtime.InteropServices.RuntimeInformation]::RuntimeIdentifier)</AdditionalRuntimeIdentifiers>
+  </PropertyGroup>
+
   <ItemGroup Condition="'$(TargetFramework)' == 'net472'">
     <Compile Include="BuildTask.Desktop.cs" />
     <Compile Include="AssemblyResolver.cs" />
@@ -24,11 +31,14 @@
     <Compile Include="Extensions.cs" />
     <Compile Include="GenerateRuntimeGraph.cs" />
     <Compile Include="RID.cs" />
+    <Compile Include="RuntimeGroupCollection.cs" />
     <Compile Include="RuntimeGroup.cs" />
+    <Compile Include="RuntimeVersion.cs" />
   </ItemGroup>
 
   <ItemGroup>
-    <Content Include="runtime.json" PackagePath="/" />
+    <Content Condition="'$(AdditionalRuntimeIdentifiers)' == ''" Include="runtime.json" PackagePath="/" />
+    <Content Condition="'$(AdditionalRuntimeIdentifiers)' != ''" Include="$(IntermediateOutputPath)runtime.json" PackagePath="/" />
     <Content Include="_._" PackagePath="lib/netstandard1.0" />
   </ItemGroup>
 
@@ -38,5 +48,14 @@
     <PackageReference Include="NuGet.ProjectModel" Version="$(RefOnlyNugetProjectModelVersion)" />
   </ItemGroup>
 
+  <Target Name="GenerateRuntimeJson" Condition="'$(AdditionalRuntimeIdentifiers)' != ''" BeforeTargets="Pack">
+    <MakeDir Directories="$(IntermediateOutputPath)" />
+    <GenerateRuntimeGraph RuntimeGroups="@(RuntimeGroupWithQualifiers)"
+                          AdditionalRuntimeIdentifiers="$(AdditionalRuntimeIdentifiers)"
+                          AdditionalRuntimeIdentifierParent="$(AdditionalRuntimeIdentifierParent)"
+                          RuntimeJson="$(IntermediateOutputPath)runtime.json"
+                          UpdateRuntimeFiles="True" />
+  </Target>
+
   <Import Project="runtimeGroups.props" />
 </Project>

src/libraries/Microsoft.NETCore.Platforms/src/RID.cs

@@ -1,37 +1,44 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System;
+using System.Diagnostics;
 using System.Text;
 
 namespace Microsoft.NETCore.Platforms.BuildTasks
 {
-    internal class RID
+    public class RID
     {
+        internal const char VersionDelimiter = '.';
+        internal const char ArchitectureDelimiter = '-';
+        internal const char QualifierDelimiter = '-';
+
         public string BaseRID { get; set; }
-        public string VersionDelimiter { get; set; }
-        public string Version { get; set; }
-        public string ArchitectureDelimiter { get; set; }
+        public bool OmitVersionDelimiter { get; set; }
+        public RuntimeVersion Version { get; set; }
         public string Architecture { get; set; }
-        public string QualifierDelimiter { get; set; }
         public string Qualifier { get; set; }
 
         public override string ToString()
         {
             StringBuilder builder = new StringBuilder(BaseRID);
 
-            if (HasVersion())
+            if (HasVersion)
             {
-                builder.Append(VersionDelimiter);
+                if (!OmitVersionDelimiter)
+                {
+                    builder.Append(VersionDelimiter);
+                }
                 builder.Append(Version);
             }
 
-            if (HasArchitecture())
+            if (HasArchitecture)
             {
                 builder.Append(ArchitectureDelimiter);
                 builder.Append(Architecture);
             }
 
-            if (HasQualifier())
+            if (HasQualifier)
             {
                 builder.Append(QualifierDelimiter);
                 builder.Append(Qualifier);
@@ -40,20 +47,153 @@ public override string ToString()
             return builder.ToString();
         }
 
-        public bool HasVersion()
+        private enum RIDPart : int
+        {
+            Base = 0,
+            Version,
+            Architcture,
+            Qualifier,
+            Max = Qualifier
+        }
+
+        public static RID Parse(string runtimeIdentifier)
+        {
+            string[] parts = new string[(int)RIDPart.Max + 1];
+            bool omitVersionDelimiter = true;
+            RIDPart parseState = RIDPart.Base;
+
+            int partStart = 0, partLength = 0;
+
+            // qualifier is indistinguishable from arch so we cannot distinguish it for parsing purposes
+            Debug.Assert(ArchitectureDelimiter == QualifierDelimiter);
+
+            for (int i = 0; i < runtimeIdentifier.Length; i++)
+            {
+                char current = runtimeIdentifier[i];
+                partLength = i - partStart;
+
+                switch (parseState)
+                {
+                    case RIDPart.Base:
+                        // treat any number as the start of the version
+                        if (current == VersionDelimiter || (current >= '0' && current <= '9'))
+                        {
+                            SetPart();
+                            partStart = i;
+                            if (current == VersionDelimiter)
+                            {
+                                omitVersionDelimiter = false;
+                                partStart = i + 1;
+                            }
+                            parseState = RIDPart.Version;
+                        }
+                        // version might be omitted
+                        else if (current == ArchitectureDelimiter)
+                        {
+                            // ensure there's no version later in the string
+                            if (-1 != runtimeIdentifier.IndexOf(VersionDelimiter, i))
+                            {
+                                break;
+                            }
+                            SetPart();
+                            partStart = i + 1;  // skip delimiter
+                            parseState = RIDPart.Architcture;
+                        }
+                        break;
+                    case RIDPart.Version:
+                        if (current == ArchitectureDelimiter)
+                        {
+                            SetPart();
+                            partStart = i + 1;  // skip delimiter
+                            parseState = RIDPart.Architcture;
+                        }
+                        break;
+                    case RIDPart.Architcture:
+                        if (current == QualifierDelimiter)
+                        {
+                            SetPart();
+                            partStart = i + 1;  // skip delimiter
+                            parseState = RIDPart.Qualifier;
+                        }
+                        break;
+                    default:
+                        break;
+                }
+            }
+
+            partLength = runtimeIdentifier.Length - partStart;
+            if (partLength > 0)
+            {
+                SetPart();
+            }
+
+            string GetPart(RIDPart part)
+            {
+                return parts[(int)part];
+            }
+
+            void SetPart()
+            {
+                if (partLength == 0)
+                {
+                    throw new ArgumentException($"unexpected delimiter at position {partStart} in {runtimeIdentifier}");
+                }
+
+                parts[(int)parseState] = runtimeIdentifier.Substring(partStart, partLength);
+            }
+
+            string version = GetPart(RIDPart.Version);
+
+            if (version == null)
+            {
+                omitVersionDelimiter = false;
+            }
+
+            return new RID()
+            {
+                BaseRID = GetPart(RIDPart.Base),
+                OmitVersionDelimiter = omitVersionDelimiter,
+                Version = version == null ? null : new RuntimeVersion(version),
+                Architecture = GetPart(RIDPart.Architcture),
+                Qualifier = GetPart(RIDPart.Qualifier)
+            };
+        }
+
+        public bool HasVersion => Version != null;
+
+        public bool HasArchitecture => Architecture != null;
+
+        public bool HasQualifier => Qualifier != null;
+
+        public override bool Equals(object obj)
         {
-            return Version != null;
+            return Equals(obj as RID);
         }
 
-        public bool HasArchitecture()
+        public bool Equals(RID obj)
         {
-            return Architecture != null;
+            return object.ReferenceEquals(obj, this) ||
+                (!(obj is null) &&
+                BaseRID == obj.BaseRID &&
+                (Version == null || OmitVersionDelimiter == obj.OmitVersionDelimiter) &&
+                Version == obj.Version &&
+                Architecture == obj.Architecture &&
+                Qualifier == obj.Qualifier);
+
         }
 
-        public bool HasQualifier()
+        public override int GetHashCode()
         {
-            return Qualifier != null;
+#if NETFRAMEWORK
+            return BaseRID.GetHashCode();
+#else
+            HashCode hashCode = default;
+            hashCode.Add(BaseRID);
+            hashCode.Add(Version);
+            hashCode.Add(Architecture);
+            hashCode.Add(Qualifier);
+            return hashCode.ToHashCode();
+#endif
         }
     }
-
 }