Changes to PR comments

* Rename some contract types
* Remove blazor.webassembly.js

Author: pranavkm

src/Components/Blazor/Build/src/Core/BootJsonWriter.cs

@@ -41,17 +41,28 @@ public static string GetBootJsonContent(string entryAssembly, string[] assemblyR
         /// </summary>
         readonly struct BootJsonData
         {
+            /// <summary>
+            /// Gets the name of the assembly with the application entry point
+            /// </summary>
             public string EntryAssembly { get; }
-            public IEnumerable<string> AssemblyReferences { get; }
+
+            /// <summary>
+            /// Gets the closure of assemblies to be loaded by Blazor WASM. This includes the application entry assembly.
+            /// </summary>
+            public IEnumerable<string> Assemblies { get; }
+
+            /// <summary>
+            /// Gets a value that determines if the linker is enabled.
+            /// </summary>
             public bool LinkerEnabled { get; }
 
             public BootJsonData(
                 string entryAssembly,
-                IEnumerable<string> assemblyReferences,
+                IEnumerable<string> assemblies,
                 bool linkerEnabled)
             {
                 EntryAssembly = entryAssembly;
-                AssemblyReferences = assemblyReferences;
+                Assemblies = assemblies;
                 LinkerEnabled = linkerEnabled;
             }
         }

src/Components/Blazor/Build/src/Core/RuntimeDependenciesResolver.cs

@@ -29,31 +29,44 @@ public static IEnumerable<string> ResolveRuntimeDependenciesCore(
             string[] applicationDependencies,
             string[] monoBclDirectories)
         {
-            var assembly = new AssemblyEntry(entryPoint, GetAssemblyName(entryPoint));
+            var entryAssembly = new AssemblyEntry(entryPoint, GetAssemblyName(entryPoint));
 
-            var dependencies = applicationDependencies
-                .Select(a => new AssemblyEntry(a, GetAssemblyName(a)))
-                .ToArray();
+            var dependencies = CreateAssemblyLookup(applicationDependencies);
 
-            var bcl = monoBclDirectories
-                .SelectMany(d => Directory.EnumerateFiles(d, "*.dll").Select(f => Path.Combine(d, f)))
-                .Select(a => new AssemblyEntry(a, GetAssemblyName(a)))
-                .ToArray();
+            var bcl = CreateAssemblyLookup(monoBclDirectories
+                .SelectMany(d => Directory.EnumerateFiles(d, "*.dll").Select(f => Path.Combine(d, f))));
 
             var assemblyResolutionContext = new AssemblyResolutionContext(
-                assembly,
+                entryAssembly,
                 dependencies,
                 bcl);
 
             assemblyResolutionContext.ResolveAssemblies();
 
             var paths = assemblyResolutionContext.Results.Select(r => r.Path);
             return paths.Concat(FindPdbs(paths));
+
+            static Dictionary<string, AssemblyEntry> CreateAssemblyLookup(IEnumerable<string> assemblyPaths)
+            {
+                var dictionary = new Dictionary<string, AssemblyEntry>(StringComparer.Ordinal);
+                foreach (var path in assemblyPaths)
+                {
+                    var assemblyName = AssemblyName.GetAssemblyName(path).Name;
+                    if (dictionary.TryGetValue(assemblyName, out var previous))
+                    {
+                        throw new InvalidOperationException($"Multiple assemblies found with the same assembly name '{assemblyName}':" +
+                            Environment.NewLine + string.Join(Environment.NewLine, previous, path));
+                    }
+                    dictionary[assemblyName] = new AssemblyEntry(path, assemblyName);
+                }
+
+                return dictionary;
+            }
         }
 
-        private static string GetAssemblyName(string entryPoint)
+        private static string GetAssemblyName(string assemblyPath)
         {
-            return AssemblyName.GetAssemblyName(entryPoint).Name;
+            return AssemblyName.GetAssemblyName(assemblyPath).Name;
         }
 
         private static IEnumerable<string> FindPdbs(IEnumerable<string> dllPaths)
@@ -66,26 +79,26 @@ private static IEnumerable<string> FindPdbs(IEnumerable<string> dllPaths)
         public class AssemblyResolutionContext
         {
             public AssemblyResolutionContext(
-                AssemblyEntry assembly,
-                AssemblyEntry[] dependencies,
-                AssemblyEntry[] bcl)
+                AssemblyEntry entryAssembly,
+                Dictionary<string, AssemblyEntry> dependencies,
+                Dictionary<string, AssemblyEntry> bcl)
             {
-                Assembly = assembly;
+                EntryAssembly = entryAssembly;
                 Dependencies = dependencies;
                 Bcl = bcl;
             }
 
-            public AssemblyEntry Assembly { get; }
-            public AssemblyEntry[] Dependencies { get; }
-            public AssemblyEntry[] Bcl { get; }
+            public AssemblyEntry EntryAssembly { get; }
+            public Dictionary<string, AssemblyEntry> Dependencies { get; }
+            public Dictionary<string, AssemblyEntry> Bcl { get; }
 
             public IList<AssemblyEntry> Results { get; } = new List<AssemblyEntry>();
 
             internal void ResolveAssemblies()
             {
                 var visitedAssemblies = new HashSet<string>();
                 var pendingAssemblies = new Stack<string>();
-                pendingAssemblies.Push(Assembly.Name);
+                pendingAssemblies.Push(EntryAssembly.Name);
                 ResolveAssembliesCore();
 
                 void ResolveAssembliesCore()
@@ -96,8 +109,7 @@ void ResolveAssembliesCore()
                         {
                             // Not all references will be resolvable within the Mono BCL.
                             // Skipping unresolved assemblies here is equivalent to passing "--skip-unresolved true" to the Mono linker.
-                            var resolved = Resolve(current);
-                            if (resolved != null)
+                            if (Resolve(current) is AssemblyEntry resolved)
                             {
                                 Results.Add(resolved);
                                 var references = GetAssemblyReferences(resolved.Path);
@@ -110,17 +122,22 @@ void ResolveAssembliesCore()
                     }
                 }
 
-                AssemblyEntry Resolve(string assemblyName)
+                AssemblyEntry? Resolve(string assemblyName)
                 {
-                    if (Assembly.Name == assemblyName)
+                    if (EntryAssembly.Name == assemblyName)
                     {
-                        return Assembly;
+                        return EntryAssembly;
                     }
 
                     // Resolution logic. For right now, we will prefer the mono BCL version of a given
                     // assembly if there is a candidate assembly and an equivalent mono assembly.
-                    return Bcl.FirstOrDefault(c => c.Name == assemblyName) ??
-                        Dependencies.FirstOrDefault(c => c.Name == assemblyName);
+                    if (Bcl.TryGetValue(assemblyName, out var assembly) ||
+                        Dependencies.TryGetValue(assemblyName, out assembly))
+                    {
+                        return assembly;
+                    }
+
+                    return null;
                 }
 
                 static IReadOnlyList<string> GetAssemblyReferences(string assemblyPath)
@@ -157,16 +174,16 @@ static IReadOnlyList<string> GetAssemblyReferences(string assemblyPath)
         }
 
         [DebuggerDisplay("{ToString(),nq}")]
-        public class AssemblyEntry
+        public readonly struct AssemblyEntry
         {
             public AssemblyEntry(string path, string name)
             {
                 Path = path;
                 Name = name;
             }
 
-            public string Path { get; set; }
-            public string Name { get; set; }
+            public string Path { get; }
+            public string Name { get; }
 
             public override string ToString() => Name;
         }

src/Components/Blazor/Build/src/targets/Blazor.MonoRuntime.targets

@@ -623,7 +623,7 @@
     Inputs="$(BlazorBuildBootJsonInputsCache);@(_BlazorDependencyInput)"
     Outputs="$(BlazorBootJsonIntermediateOutputPath)">
     <ItemGroup>
-      <_AppReferences Include="@(BlazorItemOutput->WithMetadataValue('Type','Assembly')->WithMetadataValue('PrimaryOutput','')->'%(FileName)%(Extension)')" />
+      <_AppReferences Include="@(BlazorItemOutput->WithMetadataValue('Type','Assembly')->'%(FileName)%(Extension)')" />
       <_AppReferences Include="@(BlazorItemOutput->WithMetadataValue('Type','Pdb')->'%(FileName)%(Extension)')" Condition="'$(BlazorEnableDebugging)' == 'true'" />
     </ItemGroup>
     <PropertyGroup>

src/Components/Blazor/Build/test/BootJsonWriterTest.cs

@@ -3,8 +3,6 @@
 
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
-using System;
-using System.Linq;
 using Xunit;
 
 namespace Microsoft.AspNetCore.Blazor.Build.Test
@@ -18,45 +16,13 @@ public void ProducesJsonReferencingAssemblyAndDependencies()
             var assemblyReferences = new string[] { "System.Abc.dll", "MyApp.ClassLib.dll", };
             var content = BootJsonWriter.GetBootJsonContent(
                 "MyApp.Entrypoint.dll",
-                "MyNamespace.MyType::MyMethod",
                 assemblyReferences,
-                Enumerable.Empty<EmbeddedResourceInfo>(),
                 linkerEnabled: true);
 
             // Assert
             var parsedContent = JsonConvert.DeserializeObject<JObject>(content);
             Assert.Equal("MyApp.Entrypoint.dll", parsedContent["main"].Value<string>());
-            Assert.Equal("MyNamespace.MyType::MyMethod", parsedContent["entryPoint"].Value<string>());
             Assert.Equal(assemblyReferences, parsedContent["assemblyReferences"].Values<string>());
         }
-
-        [Fact]
-        public void IncludesReferencesToEmbeddedContent()
-        {
-            // Arrange/Act
-            var embeddedContent = new[]
-            {
-                new EmbeddedResourceInfo(EmbeddedResourceKind.Static, "my/static/file"),
-                new EmbeddedResourceInfo(EmbeddedResourceKind.Css, "css/first.css"),
-                new EmbeddedResourceInfo(EmbeddedResourceKind.JavaScript, "javascript/first.js"),
-                new EmbeddedResourceInfo(EmbeddedResourceKind.Css, "css/second.css"),
-                new EmbeddedResourceInfo(EmbeddedResourceKind.JavaScript, "javascript/second.js"),
-            };
-            var content = BootJsonWriter.GetBootJsonContent(
-                "MyApp.Entrypoint",
-                "MyNamespace.MyType::MyMethod",
-                assemblyReferences: new[] { "Something.dll" },
-                embeddedContent: embeddedContent,
-                linkerEnabled: true);
-
-            // Assert
-            var parsedContent = JsonConvert.DeserializeObject<JObject>(content);
-            Assert.Equal(
-                new[] { "css/first.css", "css/second.css" },
-                parsedContent["cssReferences"].Values<string>());
-            Assert.Equal(
-                new[] { "javascript/first.js", "javascript/second.js" },
-                parsedContent["jsReferences"].Values<string>());
-        }
     }
 }

src/Components/Web.JS/.gitignore

@@ -1,2 +1,3 @@
 node_modules/
 dist/Debug/
+dist/Release/blazor.webassembly.js

src/Components/Web.JS/src/Boot.WebAssembly.ts

@@ -44,7 +44,7 @@ async function boot(options?: any): Promise<void> {
   }
 
   // Determine the URLs of the assemblies we want to load, then begin fetching them all
-  const loadAssemblyUrls = bootConfig.assemblyReferences
+  const loadAssemblyUrls = bootConfig.assemblies
     .map(filename => `_framework/_bin/${filename}`);
 
   try {
@@ -67,7 +67,7 @@ async function fetchBootConfigAsync() {
 // Keep in sync with BootJsonData in Microsoft.AspNetCore.Blazor.Build
 interface BootJsonData {
   entryAssembly: string;
-  assemblyReferences: string[];
+  assemblies: string[];
   linkerEnabled: boolean;
 }