/// <summary>
/// Gets a type by its metadata name to use for code analysis within a <see cref="Compilation"/>. This method
/// attempts to find the "best" symbol to use for code analysis, which is the symbol matching the first of the
/// following rules.
///
/// <list type="number">
/// <item><description>
/// If only one type with the given name is found within the compilation and its referenced assemblies, that
/// type is returned regardless of accessibility.
/// </description></item>
/// <item><description>
/// If the current <paramref name="compilation"/> defines the symbol, that symbol is returned.
/// </description></item>
/// <item><description>
/// If exactly one referenced assembly defines the symbol in a manner that makes it visible to the current
/// <paramref name="compilation"/>, that symbol is returned.
/// </description></item>
/// <item><description>
/// Otherwise, this method returns <see langword="null"/>.
/// </description></item>
/// </list>
/// </summary>
/// <param name="compilation">The <see cref="Compilation"/> to consider for analysis.</param>
/// <param name="fullyQualifiedMetadataName">The fully-qualified metadata type name to find.</param>
/// <returns>The symbol to use for code analysis; otherwise, <see langword="null"/>.</returns>
public static INamedTypeSymbol?GetBestTypeByMetadataName(this Compilation compilation, string fullyQualifiedMetadataName)
{
INamedTypeSymbol?type = null;
foreach (var currentType in compilation.GetTypesByMetadataName(fullyQualifiedMetadataName))
{
if (ReferenceEquals(currentType.ContainingAssembly, compilation.Assembly))
{
Debug.Assert(type is null);
return(currentType);
}
switch (currentType.GetResultantVisibility())
{
case Utilities.SymbolVisibility.Public:
case Utilities.SymbolVisibility.Internal when currentType.ContainingAssembly.GivesAccessTo(compilation.Assembly):
break;
default:
continue;
}
if (type is object)
{
// Multiple visible types with the same metadata name are present
return(null);
}
type = currentType;
}
return(type);
}
/// <summary>
/// Get subchains defining current type definition's inheritance.
/// </summary>
/// <returns>Subchains.</returns>
internal override IEnumerable <InheritanceChain> GetSubChains()
{
if (_simulatedType == null)
{
return(new InheritanceChain[] { ContainingAssembly.GetChain(typeof(object)) });
}
else
{
return(GetSubChains(_simulatedType));
}
}
public IteratorStateMachine(VariableSlotAllocator slotAllocatorOpt, TypeCompilationState compilationState, MethodSymbol iteratorMethod, int iteratorMethodOrdinal, bool isEnumerable, TypeSymbol elementType)
: base(slotAllocatorOpt, compilationState, iteratorMethod, iteratorMethodOrdinal)
{
this.ElementType = TypeMap.SubstituteType(elementType).TypeSymbol;
throw new NotImplementedException("TODO");
var interfaces = ArrayBuilder <NamedTypeSymbol> .GetInstance();
// TODO: Add proper arguments
interfaces.Add(ContainingAssembly.GetSpecialType(SpecialType.core_Iterable_T_TIterator).Construct(ElementType));
_interfaces = interfaces.ToImmutableAndFree();
_constructor = new IteratorConstructor(this);
}
/// <summary>
/// Gets the sub chains.
/// </summary>
/// <param name="type">The type which subchains are requested.</param>
/// <returns>IEnumerable<InheritanceChain>.</returns>
protected IEnumerable <InheritanceChain> GetSubChains(Type type)
{
if (ForcedSubTypes == null)
{
yield return(ContainingAssembly.GetChain(type.BaseType));
foreach (var subType in type.GetInterfaces())
{
yield return(ContainingAssembly.GetChain(subType));
}
}
else
{
foreach (var forcedSubType in ForcedSubTypes)
{
yield return(ContainingAssembly.GetChain(forcedSubType));
}
}
}
public IteratorClass(MethodSymbol method, bool isEnumerable, TypeSymbol elementType, TypeCompilationState compilationState)
: base(method, GeneratedNames.MakeIteratorOrAsyncDisplayClassName(method.Name, compilationState.GenerateTempNumber()), TypeKind.Class)
{
this.ElementType = TypeMap.SubstituteType(elementType);
var interfaces = ArrayBuilder <NamedTypeSymbol> .GetInstance();
if (isEnumerable)
{
interfaces.Add(ContainingAssembly.GetSpecialType(SpecialType.System_Collections_Generic_IEnumerable_T).Construct(ElementType));
interfaces.Add(ContainingAssembly.GetSpecialType(SpecialType.System_Collections_IEnumerable));
}
interfaces.Add(ContainingAssembly.GetSpecialType(SpecialType.System_Collections_Generic_IEnumerator_T).Construct(ElementType));
interfaces.Add(ContainingAssembly.GetSpecialType(SpecialType.System_IDisposable));
interfaces.Add(ContainingAssembly.GetSpecialType(SpecialType.System_Collections_IEnumerator));
this.interfaces = interfaces.ToImmutableAndFree();
this.constructor = new IteratorConstructor(this);
}
public IteratorStateMachine(VariableSlotAllocator slotAllocatorOpt, TypeCompilationState compilationState, MethodSymbol iteratorMethod, int iteratorMethodOrdinal, bool isEnumerable, TypeWithAnnotations elementType)
: base(slotAllocatorOpt, compilationState, iteratorMethod, iteratorMethodOrdinal)
{
this.ElementType = TypeMap.SubstituteType(elementType);
var interfaces = ArrayBuilder <NamedTypeSymbol> .GetInstance();
if (isEnumerable)
{
interfaces.Add(ContainingAssembly.GetSpecialType(SpecialType.System_Collections_Generic_IEnumerable_T).Construct(ElementType.Type));
interfaces.Add(ContainingAssembly.GetSpecialType(SpecialType.System_Collections_IEnumerable));
}
interfaces.Add(ContainingAssembly.GetSpecialType(SpecialType.System_Collections_Generic_IEnumerator_T).Construct(ElementType.Type));
interfaces.Add(ContainingAssembly.GetSpecialType(SpecialType.System_IDisposable));
interfaces.Add(ContainingAssembly.GetSpecialType(SpecialType.System_Collections_IEnumerator));
_interfaces = interfaces.ToImmutableAndFree();
_constructor = new IteratorConstructor(this);
}
internal IEnumerable <NamedTypeSymbol> GetForwardedTypes()
{
foreach (KeyValuePair <string, (int FirstIndex, int SecondIndex)> forwarder in Module.GetForwardedTypes())
{
var name = MetadataTypeName.FromFullName(forwarder.Key);
Debug.Assert(forwarder.Value.FirstIndex >= 0, "First index should never be negative");
AssemblySymbol firstSymbol = this.GetReferencedAssemblySymbol(forwarder.Value.FirstIndex);
Debug.Assert((object)firstSymbol != null, "Invalid indexes (out of bound) are discarded during reading metadata in PEModule.EnsureForwardTypeToAssemblyMap()");
if (forwarder.Value.SecondIndex >= 0)
{
var secondSymbol = this.GetReferencedAssemblySymbol(forwarder.Value.SecondIndex);
Debug.Assert((object)secondSymbol != null, "Invalid indexes (out of bound) are discarded during reading metadata in PEModule.EnsureForwardTypeToAssemblyMap()");
yield return(ContainingAssembly.CreateMultipleForwardingErrorTypeSymbol(ref name, this, firstSymbol, secondSymbol));
}
else
{
yield return(firstSymbol.LookupTopLevelMetadataType(ref name, digThroughForwardedTypes: true));
}
}
}
private NamedTypeSymbol GetDefaultBaseType()
{
return(ContainingAssembly.GetSpecialType(SpecialType.System_Object));
}
/// <summary>
/// Gets methods defined by current type definition.
/// </summary>
/// <returns>Defined methods</returns>
internal override IEnumerable <RuntimeMethodGenerator> GetMethods()
{
return(ContainingAssembly.GetMethodGenerators(this));
}
