public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
{
var metadataName = reader.ReadString();
var containingSymbolResolution = reader.ReadSymbolKey();
var isIndexer = reader.ReadBoolean();
var refKinds = reader.ReadRefKindArray();
var originalParameterTypes = reader.ReadSymbolKeyArray().Select(
r => GetFirstSymbol<ITypeSymbol>(r)).ToArray();
if (originalParameterTypes.Any(s_typeIsNull))
{
return default(SymbolKeyResolution);
}
var properties = containingSymbolResolution.GetAllSymbols().OfType<INamedTypeSymbol>()
.SelectMany(t => t.GetMembers())
.OfType<IPropertySymbol>()
.Where(p => p.Parameters.Length == refKinds.Length &&
p.MetadataName == metadataName &&
p.IsIndexer == isIndexer);
var matchingProperties = properties.Where(p =>
ParameterRefKindsMatch(p.OriginalDefinition.Parameters, refKinds) &&
reader.ParameterTypesMatch(p.OriginalDefinition.Parameters, originalParameterTypes));
return CreateSymbolInfo(matchingProperties);
}
public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
{
var pointedAtTypeResolution = reader.ReadSymbolKey();
return CreateSymbolInfo(GetAllSymbols<ITypeSymbol>(pointedAtTypeResolution)
.Select(reader.Compilation.CreatePointerTypeSymbol));
}
public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
{
var isAnonymousDelegateType = reader.ReadBoolean();
var location = reader.ReadLocation();
var syntaxTree = location.SourceTree;
if (syntaxTree == null)
{
return default(SymbolKeyResolution);
}
var semanticModel = reader.Compilation.GetSemanticModel(syntaxTree);
var root = syntaxTree.GetRoot(reader.CancellationToken);
var node = root.FindNode(location.SourceSpan, getInnermostNodeForTie: true);
var symbol = semanticModel.GetSymbolInfo(node, reader.CancellationToken)
.GetAnySymbol();
// If this was a key for an anonymous delegate type, then go find the
// associated delegate for this lambda and return that instead of the
// lambda function symbol itself.
if (isAnonymousDelegateType)
{
var anonymousDelegate = (symbol as IMethodSymbol).AssociatedAnonymousDelegate;
symbol = anonymousDelegate;
}
return new SymbolKeyResolution(symbol);
}
public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
{
var assemblyName = reader.ReadString();
return CreateSymbolInfo(GetAssemblySymbols(
assemblyName, reader.Compilation, reader.IgnoreAssemblyKey));
}
public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
{
var elementTypeResolution = reader.ReadSymbolKey();
var rank = reader.ReadInteger();
return CreateSymbolInfo(GetAllSymbols<ITypeSymbol>(elementTypeResolution)
.Select(s => reader.Compilation.CreateArrayTypeSymbol(s, rank)));
}
public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
{
var metadataName = reader.ReadString();
var containingSymbolResolution = reader.ReadSymbolKey();
var parameters = GetAllSymbols(containingSymbolResolution).SelectMany(
s => Resolve(reader, s, metadataName));
return CreateSymbolInfo(parameters);
}
public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
{
var metadataName = reader.ReadString();
var containingTypeResolution = reader.ReadSymbolKey();
var events = GetAllSymbols<INamedTypeSymbol>(containingTypeResolution)
.SelectMany(t => t.GetMembers(metadataName)).OfType<IEventSymbol>();
return CreateSymbolInfo(events);
}
public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
{
var containingSymbolResolution = reader.ReadSymbolKey();
// 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
var modules = GetAllSymbols<IAssemblySymbol>(containingSymbolResolution)
.SelectMany(a => a.Modules);
return CreateSymbolInfo(modules);
}
public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
{
var reducedFromResolution = reader.ReadSymbolKey();
var receiverTypeResolution = reader.ReadSymbolKey();
var q = from m in reducedFromResolution.GetAllSymbols().OfType<IMethodSymbol>()
from t in receiverTypeResolution.GetAllSymbols().OfType<ITypeSymbol>()
let r = m.ReduceExtensionMethod(t)
select r;
return CreateSymbolInfo(q);
}
public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
{
var metadataName = reader.ReadString();
var containingSymbolResolution = reader.ReadSymbolKey();
var arity = reader.ReadInteger();
var typeKind = (TypeKind)reader.ReadInteger();
var isUnboundGenericType = reader.ReadBoolean();
var typeArgumentsOpt = reader.ReadSymbolKeyArray();
var types = GetAllSymbols<INamespaceOrTypeSymbol>(containingSymbolResolution).SelectMany(
s => Resolve(reader, s, metadataName, arity, typeKind, isUnboundGenericType, typeArgumentsOpt));
return CreateSymbolInfo(types);
}
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);
}
var namespaces = GetAllSymbols(containingSymbolResolution).SelectMany(
s => Resolve(s, metadataName));
return CreateSymbolInfo(namespaces);
}
public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
{
var underlyingTypeResolution = reader.ReadSymbolKey();
var tupleElementNames = reader.ReadStringArray();
try
{
var result = GetAllSymbols<INamedTypeSymbol>(underlyingTypeResolution).Select(
t => reader.Compilation.CreateTupleTypeSymbol(t, tupleElementNames));
return CreateSymbolInfo(result);
}
catch (ArgumentException)
{
return new SymbolKeyResolution(reader.Compilation.ObjectType);
}
}
private static IEnumerable<INamedTypeSymbol> ResolveErrorTypes(
SymbolKeyReader reader,
SymbolKeyResolution containingSymbolResolution, string name, int arity)
{
if (containingSymbolResolution.GetAnySymbol() == null)
{
yield return reader.Compilation.CreateErrorTypeSymbol(null, name, arity);
}
else
{
foreach (var container in containingSymbolResolution.GetAllSymbols().OfType<INamespaceOrTypeSymbol>())
{
yield return reader.Compilation.CreateErrorTypeSymbol(container, name, arity);
}
}
}
private static IEnumerable<INamedTypeSymbol> Resolve(
SymbolKeyReader reader,
INamespaceOrTypeSymbol container,
string metadataName,
int arity,
TypeKind typeKind,
bool isUnboundGenericType,
ImmutableArray<SymbolKeyResolution> typeArguments)
{
var types = container.GetTypeMembers(GetName(metadataName), arity);
var result = InstantiateTypes(
reader.Compilation, reader.IgnoreAssemblyKey, types, arity, typeArguments);
return isUnboundGenericType
? result.Select(t => t.ConstructUnboundGenericType())
: result;
}
private static IEnumerable<IParameterSymbol> Resolve(
SymbolKeyReader reader, ISymbol container, string metadataName)
{
if (container is IMethodSymbol)
{
return ((IMethodSymbol)container).Parameters.Where(
p => SymbolKey.Equals(reader.Compilation, p.MetadataName, metadataName));
}
else if (container is IPropertySymbol)
{
return ((IPropertySymbol)container).Parameters.Where(
p => SymbolKey.Equals(reader.Compilation, p.MetadataName, metadataName));
}
else
{
return SpecializedCollections.EmptyEnumerable<IParameterSymbol>();
}
}
public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
{
var propertyTypeSymbols = reader.ReadSymbolKeyArray();
var propertyTypes = propertyTypeSymbols.Select(r => GetFirstSymbol<ITypeSymbol>(r)).ToImmutableArray();
var propertyNames = reader.ReadStringArray();
if (propertyTypes.Length == propertyNames.Length)
{
try
{
var anonymousType = reader.Compilation.CreateAnonymousTypeSymbol(propertyTypes, propertyNames);
return new SymbolKeyResolution(anonymousType);
}
catch (ArgumentException)
{
}
}
return new SymbolKeyResolution(reader.Compilation.ObjectType);
}
public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
{
var constructedFromResolution = reader.ReadSymbolKey();
var typeArgumentResolutions = reader.ReadSymbolKeyArray();
Debug.Assert(!typeArgumentResolutions.IsDefault);
var typeArguments = typeArgumentResolutions.Select(
r => GetFirstSymbol<ITypeSymbol>(r)).ToArray();
if (typeArguments.Any(s_typeIsNull))
{
return default(SymbolKeyResolution);
}
var result = constructedFromResolution.GetAllSymbols()
.OfType<IMethodSymbol>()
.Select(m => m.Construct(typeArguments));
return CreateSymbolInfo(result);
}
private static IEnumerable<IParameterSymbol> Resolve(
SymbolKeyReader reader, ISymbol container, string metadataName)
{
if (container is IMethodSymbol)
{
return ((IMethodSymbol)container).Parameters.Where(
p => SymbolKey.Equals(reader.Compilation, p.MetadataName, metadataName));
}
else if (container is IPropertySymbol)
{
return ((IPropertySymbol)container).Parameters.Where(
p => SymbolKey.Equals(reader.Compilation, p.MetadataName, metadataName));
}
else if (container is IEventSymbol)
{
// 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 eventSymbol = (IEventSymbol)container;
var delegateInvoke = (eventSymbol.Type as INamedTypeSymbol)?.DelegateInvokeMethod;
if (delegateInvoke != null)
{
return delegateInvoke.Parameters.Where(
p => SymbolKey.Equals(reader.Compilation, p.MetadataName, metadataName));
}
}
return SpecializedCollections.EmptyEnumerable<IParameterSymbol>();
}
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.Item2 == ordinal)
{
return new SymbolKeyResolution(symbol.Item1);
}
}
}
return new SymbolKeyResolution();
}
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());
}
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(SymbolKeyResolution);
}
public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
{
var metadataName = reader.ReadString();
var containingSymbolResolution = reader.ReadSymbolKey();
var result = containingSymbolResolution.GetAllSymbols()
.SelectMany(s =>
{
if (s is INamedTypeSymbol)
{
return ((INamedTypeSymbol)s).TypeParameters.Where(p => p.MetadataName == metadataName);
}
else if (s is IMethodSymbol)
{
return ((IMethodSymbol)s).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)));
}
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));
}
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)
{
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));
}
private static IMethodSymbol Resolve(
SymbolKeyReader reader, bool isPartialMethodImplementationPart,
IMethodSymbol method)
{
var originalParameterTypeResolutions = reader.ReadSymbolKeyArray();
var returnType = GetFirstSymbol<ITypeSymbol>(reader.ReadSymbolKey());
var originalParameterTypes = originalParameterTypeResolutions.Select(
r => GetFirstSymbol<ITypeSymbol>(r)).ToArray();
if (!originalParameterTypes.Any(s_typeIsNull))
{
if (reader.ParameterTypesMatch(method.OriginalDefinition.Parameters, originalParameterTypes))
{
if (returnType == null ||
reader.Comparer.Equals(returnType, method.ReturnType))
{
if (isPartialMethodImplementationPart)
{
method = method.PartialImplementationPart ?? method;
}
Debug.Assert(method != null);
return method;
}
}
}
return null;
}
public MethodPopper(SymbolKeyReader reader, IMethodSymbol?method)
{
_reader = reader;
_method = method;
}
public ContextualSymbolPopper(SymbolKeyReader reader, ISymbol?contextualSymbol)
{
_reader = reader;
_contextualSymbol = contextualSymbol;
}
protected abstract SymbolKeyResolution Resolve(SymbolKeyReader reader, TSymbol?contextualSymbol, out string?failureReason);
public SymbolKeyResolution Resolve(SymbolKeyReader reader, out string?failureReason) => Resolve(reader, reader.CurrentContextualSymbol as TSymbol, out failureReason);
public static SymbolKeyResolution Resolve(SymbolKeyReader reader, out string failureReason)
{
failureReason = null;
return(new SymbolKeyResolution(reader.Compilation.DynamicType));
}
public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
{
return new SymbolKeyResolution(reader.Compilation.DynamicType);
}
private static IMethodSymbol Resolve(
SymbolKeyReader reader, string metadataName, int arity, bool isPartialMethodImplementationPart,
ImmutableArray<RefKind> parameterRefKinds, int beforeParametersPosition,
INamedTypeSymbol namedType)
{
foreach (var method in namedType.GetMembers().OfType<IMethodSymbol>())
{
var result = Resolve(reader, metadataName, arity, isPartialMethodImplementationPart,
parameterRefKinds, beforeParametersPosition, method);
if (result != null)
{
return result;
}
}
return null;
}
public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
{
return(new SymbolKeyResolution(reader.Compilation.DynamicType));
}
public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
{
var ordinal = reader.ReadInteger();
var typeParameter = reader.CurrentMethod.TypeParameters[ordinal];
return new SymbolKeyResolution(typeParameter);
}
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)
{
var metadataName = reader.ReadString();
var containingSymbolResolution = reader.ReadSymbolKey();
var arity = reader.ReadInteger();
var isPartialMethodImplementationPart = reader.ReadBoolean();
var parameterRefKinds = reader.ReadRefKindArray();
// For each method that we look at, we'll have to resolve the parameter list and
// return type in the context of that method. i.e. if we have Foo<T>(IList<T> list)
// then we'll need to have marked that we're on the Foo<T> method so that we know
// 'T' in IList<T> resolves to.
//
// 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;
var result = new List<IMethodSymbol>();
var namedTypes = containingSymbolResolution.GetAllSymbols().OfType<INamedTypeSymbol>();
foreach (var namedType in namedTypes)
{
var method = Resolve(reader, metadataName, arity, isPartialMethodImplementationPart,
parameterRefKinds, beforeParametersPosition, namedType);
// Note: after finding the first method that matches we stop. That's necessary
// as we cache results while searching. We don't want to override these positive
// matches with a negative ones if we were to continue searching.
if (method != null)
{
result.Add(method);
break;
}
}
if (reader.Position == beforeParametersPosition)
{
// We didn't find any candidates. We still need to stream through this
// method signature so the reader is in a proper position.
var parameterTypeResolutions = reader.ReadSymbolKeyArray();
var returnType = GetFirstSymbol<ITypeSymbol>(reader.ReadSymbolKey());
}
return CreateSymbolInfo(result);
}
