public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
{
var localName = reader.ReadString();
var containingSymbolResolution = reader.ReadSymbolKey();
var ordinal = reader.ReadInteger();
var kind = (SymbolKind)reader.ReadInteger();
var containingSymbol = containingSymbolResolution.Symbol;
if (containingSymbol != null)
{
foreach (var symbol in EnumerateSymbols(
reader.Compilation, containingSymbol, kind, localName, reader.CancellationToken))
{
if (symbol.ordinal == ordinal)
{
return(new SymbolKeyResolution(symbol.symbol));
}
}
}
return(new SymbolKeyResolution());
}
protected sealed override SymbolKeyResolution Resolve(
SymbolKeyReader reader, INamespaceSymbol?contextualSymbol, out string?failureReason)
{
var metadataName = reader.ReadRequiredString();
var containerKind = reader.ReadInteger();
var containingContextualSymbol = containerKind switch
{
0 => contextualSymbol?.ContainingNamespace,
1 => contextualSymbol?.ContainingModule,
2 => contextualSymbol?.ContainingAssembly,
3 => (ISymbol?)null,
_ => throw ExceptionUtilities.UnexpectedValue(containerKind),
};
// Namespaces are never parented by types, so there can be no contextual type to resolve our container.
var containingSymbolResolution = reader.ReadSymbolKey(
containingContextualSymbol, out var containingSymbolFailureReason);
if (containingSymbolFailureReason != null)
{
failureReason = $"({nameof(EventSymbolKey)} {nameof(containingSymbolResolution)} failed -> {containingSymbolFailureReason})";
return(default);
public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
{
var name = reader.ReadString();
var targetResolution = reader.ReadSymbolKey();
var filePath = reader.ReadString();
var syntaxTree = reader.GetSyntaxTree(filePath);
if (syntaxTree != null)
{
var target = targetResolution.GetAnySymbol();
if (target != null)
{
var semanticModel = reader.Compilation.GetSemanticModel(syntaxTree);
var result = Resolve(semanticModel, syntaxTree.GetRoot(reader.CancellationToken), name, target, reader.CancellationToken);
if (result.HasValue)
{
return(result.Value);
}
}
}
return(default);
public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
{
using var propertyTypes = reader.ReadSymbolKeyArray <ITypeSymbol>();
using var propertyNames = reader.ReadStringArray();
using var propertyIsReadOnly = reader.ReadBooleanArray();
using var propertyLocations = reader.ReadLocationArray();
if (!propertyTypes.IsDefault)
{
try
{
var anonymousType = reader.Compilation.CreateAnonymousTypeSymbol(
propertyTypes.ToImmutable(), propertyNames.ToImmutable(),
propertyIsReadOnly.ToImmutable(), propertyLocations.ToImmutable());
return(new SymbolKeyResolution(anonymousType));
}
catch (ArgumentException)
{
}
}
return(new SymbolKeyResolution(reader.Compilation.ObjectType));
}
public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
{
var propertyTypeSymbols = reader.ReadSymbolKeyArray();
var propertyTypes = propertyTypeSymbols.Select(r => GetFirstSymbol <ITypeSymbol>(r)).ToImmutableArray();
var propertyNames = reader.ReadStringArray();
var propertyIsReadOnly = reader.ReadBooleanArray();
var propertyLocations = reader.ReadLocationArray();
if (propertyTypes.Length == propertyNames.Length)
{
try
{
var anonymousType = reader.Compilation.CreateAnonymousTypeSymbol(
propertyTypes, propertyNames, propertyIsReadOnly, propertyLocations);
return(new SymbolKeyResolution(anonymousType));
}
catch (ArgumentException)
{
}
}
return(new SymbolKeyResolution(reader.Compilation.ObjectType));
}
private static IMethodSymbol Resolve(
SymbolKeyReader reader, string metadataName, int arity, bool isPartialMethodImplementationPart,
ImmutableArray <RefKind> parameterRefKinds, int beforeParametersPosition,
IMethodSymbol method)
{
if (method.Arity == arity &&
method.MetadataName == metadataName &&
ParameterRefKindsMatch(method.Parameters, parameterRefKinds))
{
// Method looks like a potential match. It has the right arity, name and
// refkinds match. We now need to do the more complicated work of checking
// the parameters (and possibly the return type). This is more complicated
// because those symbols might refer to method type parameters. In order
// for resolution to work on those type parameters, we have to keep track
// in the reader that we're on this specific method.
// Restore our position to right before the list of parameters.
// Also set the current method so that we can properly resolve
// method type parameter ordinals.
reader.Position = beforeParametersPosition;
Debug.Assert(reader.CurrentMethod == null);
reader.CurrentMethod = method;
var result = Resolve(reader, isPartialMethodImplementationPart, method);
Debug.Assert(reader.CurrentMethod == method);
reader.CurrentMethod = null;
if (result != null)
{
return(result);
}
}
return(null);
}
public static SymbolKeyResolution Resolve(SymbolKeyReader reader, 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 static SymbolKeyResolution Resolve(SymbolKeyReader reader)
{
var metadataName = reader.ReadString();
var containingSymbolResolution = reader.ReadSymbolKey();
var result = containingSymbolResolution.GetAllSymbols()
.SelectMany(s =>
{
if (s is INamedTypeSymbol namedType)
{
return(namedType.TypeParameters.Where(p => p.MetadataName == metadataName));
}
else if (s is IMethodSymbol method)
{
return(method.TypeParameters.Where(p => p.MetadataName == metadataName));
}
else
{
return(SpecializedCollections.EmptyEnumerable <ITypeParameterSymbol>());
}
});
return(CreateSymbolInfo(result));
}
public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
{
var name = reader.ReadString();
var containingSymbolResolution = reader.ReadSymbolKey();
var arity = reader.ReadInteger();
var typeArgumentResolutions = reader.ReadSymbolKeyArray();
var errorTypes = ResolveErrorTypes(reader, containingSymbolResolution, name, arity);
if (typeArgumentResolutions.IsDefault)
{
return(CreateSymbolInfo(errorTypes));
}
var typeArguments = typeArgumentResolutions.Select(
r => GetFirstSymbol <ITypeSymbol>(r)).ToArray();
if (typeArguments.Any(s_typeIsNull))
{
return(default(SymbolKeyResolution));
}
return(CreateSymbolInfo(errorTypes.Select(t => t.Construct(typeArguments))));
}
protected sealed override SymbolKeyResolution Resolve(
SymbolKeyReader reader, INamedTypeSymbol?contextualSymbol, out string?failureReason)
{
contextualSymbol = contextualSymbol is { IsAnonymousType : true } ? contextualSymbol : null;
public static SymbolKeyResolution Resolve(SymbolKeyReader reader, out string?failureReason)
{
var isError = reader.ReadBoolean();
return(isError ? ResolveErrorTuple(reader, out failureReason) : ResolveNormalTuple(reader, out failureReason));
}
