Merge pull request #46315 from dotnet/merges/release/dev16.7-to-release/dev16.8-preview1

Merge release/dev16.7 to release/dev16.8-preview1

Author: JoeRobich

src/Workspaces/Core/Portable/Remote/RemoteArguments.cs

@@ -114,7 +114,7 @@ public async Task<ISymbol> TryRehydrateAsync(
                 try
                 {
                     throw new InvalidOperationException(
-                        $"We should always be able to resolve a symbol back on the host side:\r\n{SymbolKeyData}\r\n{failureReason}");
+                        $"We should always be able to resolve a symbol back on the host side:\r\n{project.Name}\r\n{SymbolKeyData}\r\n{failureReason}");
                 }
                 catch (Exception ex) when (FatalError.ReportWithoutCrash(ex))
                 {

src/Workspaces/Core/Portable/SymbolKey/SymbolKey.BodyLevelSymbolKey.cs

@@ -132,20 +132,22 @@ public static SymbolKeyResolution Resolve(SymbolKeyReader reader, out string? fa
                 }
 
                 // First check if we can recover the symbol just through the original location.
-                foreach (var loc in locations)
+
+                string? totalFailureReason = null;
+                for (var i = 0; i < locations.Count; i++)
                 {
-                    var resolutionOpt = reader.ResolveLocation(loc);
-                    if (resolutionOpt.HasValue)
+                    var loc = locations[i];
+
+                    if (!TryResolveLocation(loc, i, out var resolution, out var reason))
                     {
-                        var resolution = resolutionOpt.Value;
-                        var symbol = resolution.GetAnySymbol();
-                        if (symbol?.Kind == kind &&
-                            SymbolKey.Equals(reader.Compilation, name, symbol.Name))
-                        {
-                            failureReason = null;
-                            return resolution;
-                        }
+                        totalFailureReason = totalFailureReason == null
+                            ? $"({reason})"
+                            : $"({totalFailureReason} -> {reason})";
+                        continue;
                     }
+
+                    failureReason = null;
+                    return resolution;
                 }
 
                 // Couldn't recover.  See if we can still find a match across the textual drift.
@@ -162,8 +164,42 @@ public static SymbolKeyResolution Resolve(SymbolKeyReader reader, out string? fa
                     }
                 }
 
-                failureReason = $"({nameof(BodyLevelSymbolKey)} '{name}' not found)";
+                failureReason = $"({nameof(BodyLevelSymbolKey)} '{name}' not found -> {totalFailureReason})";
                 return default;
+
+                bool TryResolveLocation(Location loc, int index, out SymbolKeyResolution resolution, out string? reason)
+                {
+                    var resolutionOpt = reader.ResolveLocation(loc);
+                    if (resolutionOpt == null)
+                    {
+                        reason = $"location {index} failed to resolve";
+                        resolution = default;
+                        return false;
+                    }
+
+                    resolution = resolutionOpt.Value;
+                    var symbol = resolution.GetAnySymbol();
+                    if (symbol == null)
+                    {
+                        reason = $"location {index} did not produce any symbol";
+                        return false;
+                    }
+
+                    if (symbol.Kind != kind)
+                    {
+                        reason = $"location {index} did not match kind: {symbol.Kind} != {kind}";
+                        return false;
+                    }
+
+                    if (!SymbolKey.Equals(reader.Compilation, name, symbol.Name))
+                    {
+                        reason = $"location {index} did not match name: {symbol.Name} != {name}";
+                        return false;
+                    }
+
+                    reason = null;
+                    return true;
+                }
             }
 
             private static IEnumerable<(ISymbol symbol, int ordinal)> EnumerateSymbols(

src/Workspaces/Core/Portable/SymbolKey/SymbolKey.SymbolKeyReader.cs

@@ -202,7 +202,7 @@ public PooledArrayBuilder<T> ReadArray<T>(ReadFunction<T> readFunction, out stri
                         var reason = $"element {i} failed {elementFailureReason}";
                         totalFailureReason = totalFailureReason == null
                             ? $"({reason})"
-                            : $"(totalFailureReason -> {reason})";
+                            : $"({totalFailureReason} -> {reason})";
                     }
                 }
 
@@ -538,20 +538,26 @@ public Location ReadLocation(out string failureReason)
                 }
 
                 var kind = (LocationKind)ReadInteger();
-                if (kind == LocationKind.SourceFile)
+                if (kind == LocationKind.None)
+                {
+                    failureReason = null;
+                    return Location.None;
+                }
+                else if (kind == LocationKind.SourceFile)
                 {
                     var filePath = ReadString();
                     var start = ReadInteger();
                     var length = ReadInteger();
 
-                    // The syntax tree can be null if we're resolving this location in a compilation
-                    // that does not contain this file.  In this case, just map this location to None.
                     var syntaxTree = GetSyntaxTree(filePath);
-                    if (syntaxTree != null)
+                    if (syntaxTree == null)
                     {
-                        failureReason = null;
-                        return Location.Create(syntaxTree, new TextSpan(start, length));
+                        failureReason = $"({nameof(ReadLocation)} failed -> '{filePath}' not in compilation)";
+                        return null;
                     }
+
+                    failureReason = null;
+                    return Location.Create(syntaxTree, new TextSpan(start, length));
                 }
                 else if (kind == LocationKind.MetadataFile)
                 {
@@ -579,10 +585,14 @@ public Location ReadLocation(out string failureReason)
                             }
                         }
                     }
-                }
 
-                failureReason = null;
-                return Location.None;
+                    failureReason = null;
+                    return Location.None;
+                }
+                else
+                {
+                    throw ExceptionUtilities.UnexpectedValue(kind);
+                }
             }
 
             public SymbolKeyResolution? ResolveLocation(Location location)