internal bool ParameterTypesMatch(
ImmutableArray <IParameterSymbol> parameters,
PooledArrayBuilder <ITypeSymbol> originalParameterTypes)
{
if (originalParameterTypes.IsDefault || parameters.Length != originalParameterTypes.Count)
{
return(false);
}
// We are checking parameters for equality, if they refer to method type parameters,
// then we don't want to recurse through the method (which would then recurse right
// back into the parameters). So we use a signature type comparer as it will properly
// compare method type parameters by ordinal.
var signatureComparer = Comparer.SignatureTypeEquivalenceComparer;
for (var i = 0; i < originalParameterTypes.Count; i++)
{
if (!signatureComparer.Equals(originalParameterTypes[i], parameters[i].Type))
{
return(false);
}
}
return(true);
}
public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
{
var isCref = reader.ReadBoolean();
if (isCref)
{
var location = reader.ReadLocation();
var resolution = reader.ResolveLocation(location);
return(resolution.GetValueOrDefault());
}
else
{
var metadataName = reader.ReadString();
var containingSymbolResolution = reader.ReadSymbolKey();
using var result = PooledArrayBuilder <ITypeParameterSymbol> .GetInstance();
foreach (var containingSymbol in containingSymbolResolution)
{
foreach (var typeParam in containingSymbol.GetTypeParameters())
{
if (typeParam.MetadataName == metadataName)
{
result.AddIfNotNull(typeParam);
}
}
}
return(CreateResolution(result));
}
}
protected sealed override SymbolKeyResolution Resolve(
SymbolKeyReader reader, IAssemblySymbol?contextualSymbol, out string?failureReason)
{
var assemblyName = reader.ReadString();
var compilation = reader.Compilation;
var ignoreAssemblyKey = reader.IgnoreAssemblyKey;
using var result = PooledArrayBuilder <IAssemblySymbol> .GetInstance();
if (ignoreAssemblyKey || compilation.Assembly.Identity.Name == assemblyName)
{
result.AddIfNotNull(compilation.Assembly);
}
// Might need keys for symbols from previous script compilations.
foreach (var assembly in compilation.GetReferencedAssemblySymbols())
{
if (ignoreAssemblyKey || assembly.Identity.Name == assemblyName)
{
result.AddIfNotNull(assembly);
}
}
return(CreateResolution(result, $"({nameof(AssemblySymbolKey)} '{assemblyName}' not found)", out failureReason));
}
public PooledArrayBuilder <T> ReadArray <T>(ReadFunction <T> readFunction, out string?failureReason)
{
var builder = PooledArrayBuilder <T> .GetInstance();
EatSpace();
Debug.Assert((SymbolKeyType)Data[Position] != SymbolKeyType.Null);
EatOpenParen();
Eat(SymbolKeyType.Array);
string?totalFailureReason = null;
var length = ReadInteger();
for (var i = 0; i < length; i++)
{
CancellationToken.ThrowIfCancellationRequested();
builder.Builder.Add(readFunction(out var elementFailureReason));
if (elementFailureReason != null)
{
var reason = $"element {i} failed {elementFailureReason}";
totalFailureReason = totalFailureReason == null
? $"({reason})"
: $"({totalFailureReason} -> {reason})";
}
}
EatCloseParen();
failureReason = totalFailureReason;
return(builder);
}
protected sealed override SymbolKeyResolution Resolve(
SymbolKeyReader reader, IPropertySymbol?contextualSymbol, out string?failureReason)
{
var metadataName = reader.ReadString();
var containingTypeResolution = reader.ReadSymbolKey(contextualSymbol?.ContainingSymbol, out var containingTypeFailureReason);
var isIndexer = reader.ReadBoolean();
using var refKinds = reader.ReadRefKindArray();
using var properties = GetMembersOfNamedType <IPropertySymbol>(containingTypeResolution, metadataName: null);
using var result = PooledArrayBuilder <IPropertySymbol> .GetInstance();
// For each property that we look at, we'll have to resolve the parameter list and return type in the
// context of that method. This makes sure we can attempt to resolve the parameter list types against
// error types in the property we're currently looking at.
//
// Because of this, we keep track of where we are in the reader. Before resolving every parameter list,
// we'll mark which method we're on and we'll rewind to this point.
var beforeParametersPosition = reader.Position;
IPropertySymbol?property = null;
foreach (var candidate in properties)
{
if (candidate.Parameters.Length != refKinds.Count ||
candidate.MetadataName != metadataName ||
candidate.IsIndexer != isIndexer ||
!ParameterRefKindsMatch(candidate.OriginalDefinition.Parameters, refKinds))
{
continue;
}
property = Resolve(reader, candidate);
if (property != null)
{
break;
}
// reset ourselves so we can check the return-type/parameters against the next candidate.
reader.Position = beforeParametersPosition;
}
if (reader.Position == beforeParametersPosition)
{
// We didn't find a match. Read through the stream one final time so we're at the correct location
// after this PropertySymbolKey.
_ = reader.ReadSymbolKeyArray <IPropertySymbol, ITypeSymbol>(
contextualSymbol: null, getContextualSymbol: null, failureReason: out _);
}
if (containingTypeFailureReason != null)
{
failureReason = $"({nameof(PropertySymbolKey)} {nameof(containingTypeResolution)} failed -> {containingTypeFailureReason})";
return(default);
private static void Resolve(
PooledArrayBuilder <IParameterSymbol> result, SymbolKeyReader reader,
string metadataName, ImmutableArray <IParameterSymbol> parameters)
{
foreach (var parameter in parameters)
{
if (SymbolKey.Equals(reader.Compilation, parameter.MetadataName, metadataName))
{
result.AddIfNotNull(parameter);
}
}
}
public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
{
var pointedAtTypeResolution = reader.ReadSymbolKey();
using var result = PooledArrayBuilder <IPointerTypeSymbol> .GetInstance(pointedAtTypeResolution.SymbolCount);
foreach (var typeSymbol in pointedAtTypeResolution.OfType <ITypeSymbol>())
{
result.AddIfNotNull(reader.Compilation.CreatePointerTypeSymbol(typeSymbol));
}
return(CreateResolution(result));
}
public static SymbolKeyResolution Resolve(SymbolKeyReader reader, out string?failureReason)
{
using var propertyTypes = reader.ReadSymbolKeyArray <ITypeSymbol>(out var propertyTypesFailureReason);
#pragma warning disable IDE0007 // Use implicit type
using PooledArrayBuilder <string> propertyNames = reader.ReadStringArray() !;
#pragma warning restore IDE0007 // Use implicit type
using var propertyIsReadOnly = reader.ReadBooleanArray();
var propertyLocations = ReadPropertyLocations(reader, out var propertyLocationsFailureReason);
if (propertyTypesFailureReason != null)
{
failureReason = $"({nameof(AnonymousTypeSymbolKey)} {nameof(propertyTypes)} failed -> {propertyTypesFailureReason})";
return(default);
public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
{
var elementTypeResolution = reader.ReadSymbolKey();
var rank = reader.ReadInteger();
using var result = PooledArrayBuilder <IArrayTypeSymbol> .GetInstance(elementTypeResolution.SymbolCount);
foreach (var typeSymbol in elementTypeResolution.OfType <ITypeSymbol>())
{
result.AddIfNotNull(reader.Compilation.CreateArrayTypeSymbol(typeSymbol, rank));
}
return(CreateResolution(result));
}
public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
{
var isError = reader.ReadBoolean();
if (isError)
{
using var elementTypes = reader.ReadSymbolKeyArray <ITypeSymbol>();
using var elementNames = reader.ReadStringArray();
var elementLocations = ReadElementLocations(reader);
if (!elementTypes.IsDefault)
{
try
{
var result = reader.Compilation.CreateTupleTypeSymbol(
elementTypes.ToImmutable(), elementNames.ToImmutable(), elementLocations);
return(new SymbolKeyResolution(result));
}
catch (ArgumentException)
{
}
}
}
else
{
var underlyingTypeResolution = reader.ReadSymbolKey();
using var elementNamesBuilder = reader.ReadStringArray();
var elementLocations = ReadElementLocations(reader);
try
{
using var result = PooledArrayBuilder <INamedTypeSymbol> .GetInstance();
var elementNames = elementNamesBuilder.ToImmutable();
foreach (var namedType in underlyingTypeResolution.OfType <INamedTypeSymbol>())
{
result.AddIfNotNull(reader.Compilation.CreateTupleTypeSymbol(
namedType, elementNames, elementLocations));
}
return(CreateResolution(result));
}
catch (ArgumentException)
{
}
}
return(new SymbolKeyResolution(reader.Compilation.ObjectType));
}
public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
{
var containingSymbolResolution = reader.ReadSymbolKey();
using var result = PooledArrayBuilder <IModuleSymbol> .GetInstance();
foreach (var assembly in containingSymbolResolution.OfType <IAssemblySymbol>())
{
// Don't check ModuleIds for equality because in practice, no-one uses them,
// and there is no way to set netmodule name programmatically using Roslyn
result.AddValuesIfNotNull(assembly.Modules);
}
return(CreateResolution(result));
}
public static SymbolKeyResolution Resolve(SymbolKeyReader reader, out string?failureReason)
{
var cancellationToken = reader.CancellationToken;
var name = reader.ReadString() !;
var kind = (SymbolKind)reader.ReadInteger();
#pragma warning disable IDE0007 // Use implicit type
PooledArrayBuilder <Location> locations = reader.ReadLocationArray(out var locationsFailureReason) !;
#pragma warning restore IDE0007 // Use implicit type
var ordinal = reader.ReadInteger();
if (locationsFailureReason != null)
{
failureReason = $"({nameof(BodyLevelSymbolKey)} {nameof(locations)} failed -> {locationsFailureReason})";
return(default);
public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
{
var reducedFromResolution = reader.ReadSymbolKey();
var receiverTypeResolution = reader.ReadSymbolKey();
using var result = PooledArrayBuilder <IMethodSymbol> .GetInstance();
foreach (var reducedFrom in reducedFromResolution.OfType <IMethodSymbol>())
{
foreach (var receiverType in receiverTypeResolution.OfType <ITypeSymbol>())
{
result.AddIfNotNull(reducedFrom.ReduceExtensionMethod(receiverType));
}
}
return(CreateResolution(result));
}
public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
{
var metadataName = reader.ReadString();
var containingSymbolResolution = reader.ReadSymbolKey();
using var result = PooledArrayBuilder <IParameterSymbol> .GetInstance();
foreach (var container in containingSymbolResolution)
{
switch (container)
{
case IMethodSymbol method:
Resolve(result, reader, metadataName, method.Parameters);
break;
case IPropertySymbol property:
Resolve(result, reader, metadataName, property.Parameters);
break;
case IEventSymbol eventSymbol:
// Parameters can be owned by events in VB. i.e. it's legal in VB to have:
//
// Public Event E(a As Integer, b As Integer);
//
// In this case it's equivalent to:
//
// Public Delegate UnutterableCompilerName(a As Integer, b As Integer)
// public Event E As UnutterableCompilerName
//
// So, in this case, to resolve the parameter, we go have to map the event,
// then find the delegate it returns, then find the parameter in the delegate's
// 'Invoke' method.
var delegateInvoke = (eventSymbol.Type as INamedTypeSymbol)?.DelegateInvokeMethod;
if (delegateInvoke != null)
{
Resolve(result, reader, metadataName, delegateInvoke.Parameters);
}
break;
}
}
return(CreateResolution(result));
}
public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
{
var metadataName = reader.ReadString();
var isCompilationGlobalNamespace = reader.ReadBoolean();
var containingSymbolResolution = reader.ReadSymbolKey();
if (isCompilationGlobalNamespace)
{
return(new SymbolKeyResolution(reader.Compilation.GlobalNamespace));
}
using var result = PooledArrayBuilder <INamespaceSymbol> .GetInstance();
foreach (var container in containingSymbolResolution)
{
switch (container)
{
case IAssemblySymbol assembly:
Debug.Assert(metadataName == string.Empty);
result.AddIfNotNull(assembly.GlobalNamespace);
break;
case IModuleSymbol module:
Debug.Assert(metadataName == string.Empty);
result.AddIfNotNull(module.GlobalNamespace);
break;
case INamespaceSymbol namespaceSymbol:
foreach (var member in namespaceSymbol.GetMembers(metadataName))
{
if (member is INamespaceSymbol childNamespace)
{
result.AddIfNotNull(childNamespace);
}
}
break;
}
}
return(CreateResolution(result));
}
public PooledArrayBuilder <T> ReadArray <T>(Func <T> readFunction)
{
var builder = PooledArrayBuilder <T> .GetInstance();
EatSpace();
Debug.Assert((SymbolKeyType)Data[Position] != SymbolKeyType.Null);
EatOpenParen();
Eat(SymbolKeyType.Array);
var length = ReadInteger();
for (var i = 0; i < length; i++)
{
CancellationToken.ThrowIfCancellationRequested();
builder.Builder.Add(readFunction());
}
EatCloseParen();
return(builder);
}
public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
{
var assemblyName = reader.ReadString();
var compilation = reader.Compilation;
var ignoreAssemblyKey = reader.IgnoreAssemblyKey;
using var result = PooledArrayBuilder <IAssemblySymbol> .GetInstance();
if (ignoreAssemblyKey || compilation.Assembly.Identity.Name == assemblyName)
{
result.AddIfNotNull(compilation.Assembly);
}
// Might need keys for symbols from previous script compilations.
foreach (var assembly in compilation.GetReferencedAssemblySymbols())
{
if (ignoreAssemblyKey || assembly.Identity.Name == assemblyName)
{
result.AddIfNotNull(assembly);
}
}
return(CreateResolution(result));
}
