// the function returns true if the given type reference depends in a type parameter
// not necessarily the type must be declared as class Type<T>
// it could be nested and implicitly depend on a generic parameter
// it could inherit a generic parameter
// there are some situations that can only be resolved if the definition is present
private static bool IsParametericType(ITypeReference typeReference)
{
if (typeReference is IGenericTypeInstanceReference)
{
return(true);
}
INestedTypeReference nestedType = typeReference as INestedTypeReference;
if (nestedType != null && !(nestedType is Dummy))
{
// check Inner example in TestAxiomsGenerics2
// it is a nested type reference, and also a INamedTypeReference but GenericParameterCount is zero and DoesNotInheritGenericParameters is true
var res = !nestedType.ResolvedType.DoesNotInheritGenericParameters; //|| IsParametericType(nestedType.ResolvedType.BaseClasses.First());
return(res);
}
INamedTypeReference namedType = typeReference as INamedTypeReference;
if (namedType != null)
{
return(namedType.GenericParameterCount > 0);
}
return(false);
}
public bool AddTypeReference(INamedTypeReference type)
{
// TODO: Optionally add all members for interfaces, and add all abstract members for abstract classes
INamedTypeDefinition typeDef = Util.ResolveTypeThrowing(type);
IAssembly assembly = TypeHelper.GetDefiningUnit(typeDef) as IAssembly;
AddAssemblyReference(assembly);
if (!TypesClosure.ContainsKey(typeDef.InternedKey))
{
TypesClosure.Add(typeDef.InternedKey, typeDef);
_workList.Enqueue(typeDef);
if (Util.IsDelegateType(typeDef))
{
foreach (ITypeDefinitionMember member in typeDef.Members)
{
AddMemberReference(member);
}
}
return true;
}
return false;
}
private static string GetEscapedMetadataName(INamedTypeReference namedType)
{
var pooled = PooledStringBuilder.GetInstance();
StringBuilder mangledName = pooled.Builder;
const string needsEscaping = "\\[]*.+,& ";
if (namedType.AssociatedFileIdentifier is string fileIdentifier)
{
Debug.Assert(needsEscaping.All(c => !fileIdentifier.Contains(c)));
mangledName.Append(fileIdentifier);
}
foreach (var ch in namedType.Name)
{
if (needsEscaping.IndexOf(ch) >= 0)
{
mangledName.Append('\\');
}
mangledName.Append(ch);
}
if (namedType.MangleName && namedType.GenericParameterCount > 0)
{
mangledName.Append(MetadataHelpers.GetAritySuffix(namedType.GenericParameterCount));
}
return(pooled.ToStringAndFree());
}
public bool AddTypeReference(INamedTypeReference type)
{
// TODO: Optionally add all members for interfaces, and add all abstract members for abstract classes
INamedTypeDefinition typeDef = Util.ResolveTypeThrowing(type);
IAssembly assembly = TypeHelper.GetDefiningUnit(typeDef) as IAssembly;
AddAssemblyReference(assembly);
if (!TypesClosure.ContainsKey(typeDef.InternedKey))
{
TypesClosure.Add(typeDef.InternedKey, typeDef);
_workList.Enqueue(typeDef);
if (Util.IsDelegateType(typeDef))
{
foreach (ITypeDefinitionMember member in typeDef.Members)
{
AddMemberReference(member);
}
}
return(true);
}
return(false);
}
internal TypeInferencer(INamedTypeReference containingType, IMetadataHost host) {
Contract.Requires(containingType != null);
Contract.Requires(host != null);
this.containingType = containingType;
this.host = host;
this.platformType = containingType.PlatformType;
}
public static IGenericTypeInstanceReference MakeGenericType(
this INamedTypeReference genericType,
IInternFactory internFactory,
params ITypeReference[] genericArguments
)
{
return(genericType.MakeGenericType(internFactory, genericArguments as IEnumerable <ITypeReference>));
}
internal TypeInferencer(INamedTypeReference containingType, IMetadataHost host)
{
Contract.Requires(containingType != null);
Contract.Requires(host != null);
this.containingType = containingType;
this.host = host;
this.platformType = containingType.PlatformType;
}
public override void Visit(INamedTypeReference namedTypeReference)
{
if (Process(namedTypeReference))
{
visitor.Visit(namedTypeReference);
}
base.Visit(namedTypeReference);
}
public override bool Matches(ITypeReference typeReference)
{
INamedTypeReference named = typeReference as INamedTypeReference;
return(named != null &&
!named.Name.Value.StartsWith("<") &&
!named.Name.Value.Contains("="));
}
public static string GetMangledName(INamedTypeReference namedType)
{
string unmangledName = namedType.Name;
return(namedType.MangleName
? MetadataHelpers.ComposeAritySuffixedMetadataName(unmangledName, namedType.GenericParameterCount)
: unmangledName);
}
/// <summary>
/// This is "ugly" but I don't know how to query a type by name
/// Inspired in Zvonimir code
/// </summary>
/// <param name="host"></param>
public static void InitializeScopeTypes(IMetadataHost host, IAssembly scopeRuntime)
{
foreach (var type in scopeRuntime.GetAllTypes())
{
if (type.GetFullName() == "ScopeRuntime.Reducer")
{
Reducer = type;
}
else if (type.GetFullName() == "ScopeRuntime.Processor")
{
Processor = type;
}
else if (type.GetFullName() == "ScopeRuntime.Producer")
{
Producer = type;
}
else if (type.GetFullName() == "ScopeRuntime.Row")
{
Row = type;
}
else if (type.GetFullName() == "ScopeRuntime.RowSet")
{
RowSet = type;
}
else if (type.GetFullName() == "ScopeRuntime.RowList")
{
RowList = type;
}
else if (type.GetFullName() == "ScopeRuntime.ColumnData")
{
ColumnData = type;
}
else if (type.GetFullName() == "ScopeRuntime.ColumnData<T>")
{
ColumnData_Generic = type;
}
else if (type.GetFullName() == "ScopeRuntime.Schema")
{
Schema = type;
}
else if (type.GetFullName() == "ScopeRuntime.Combiner")
{
Combiner = type;
}
else if (type.GetFullName() == "ScopeRuntime.ScopeMap<K, V>")
{
ScopeMap = type;
}
if (type.ContainingNamespace() == "ScopeRuntime")
{
scopeTypes.Add(type);
}
}
}
public static IGenericTypeInstanceReference MakeGenericType(
this INamedTypeReference genericType,
IInternFactory internFactory,
IEnumerable <ITypeReference> genericArguments
)
{
return(new Microsoft.Cci.Immutable.GenericTypeInstanceReference(
genericType,
genericArguments,
internFactory
));
}
public static List <ITypeDefinitionMember> FindRelatedExternalMembers(ITypeDefinitionMember member, CanIncludeCheck canInclude)
{
List <ITypeDefinitionMember> relatedMembers = new List <ITypeDefinitionMember>();
Dictionary <uint, ITypeReference> participatingTypes = new Dictionary <uint, ITypeReference>();
ITypeDefinition currentType = member.ContainingTypeDefinition;
do
{
//
// add the type
//
if (!canInclude(Util.CanonicalizeTypeReference(currentType)))
{
participatingTypes.Add(currentType.InternedKey, currentType);
}
//
// add any interfaces it implements that are part of the closure
//
foreach (ITypeReference iface in currentType.Interfaces)
{
INamedTypeReference ifaceTemplate = Util.CanonicalizeTypeReference(iface);
// check the closure against the template type, but add
// the specialized type to participatingTypes so that
// argument matching works
if (!canInclude(ifaceTemplate) &&
!participatingTypes.ContainsKey(iface.InternedKey))
{
// Should we add ifaceTemplate or iface?
participatingTypes.Add(iface.InternedKey, iface);
}
}
//
// go up to the base type
//
currentType = TypeHelper.BaseClass(currentType);
}while (currentType != null);
foreach (ITypeReference type in participatingTypes.Values)
{
ITypeDefinitionMember relatedMember = FindRelatedMember(type, member);
if (null != relatedMember)
{
relatedMembers.Add(relatedMember);
}
}
return(relatedMembers);
}
public override void Visit(ITypeMemberReference member)
{
// The member can resolve to an external assembly, so we need to check whether we can include the external assembly.
INamedTypeReference containingType = Util.CanonicalizeType(Util.CanonicalizeMemberReference(member).ContainingType);
if (m_implModel.CanInclude(containingType))
{
AddTypeReference(containingType);
if (member != null)
{
AddMemberReference(Util.CanonicalizeMember(member));
return;
}
}
}
public override void AddTypeReference(INamedTypeReference type)
{
INamedTypeDefinition typeDef = Util.CanonicalizeType(type);
// For enums, we want to include all their values.
// TODO: Should this be optional?
if (typeDef.IsEnum)
{
foreach (ITypeDefinitionMember member in typeDef.Members)
{
AddMemberReference(member);
}
}
base.AddTypeReference(type);
}
public override void AddTypeReference(INamedTypeReference type)
{
INamedTypeDefinition typeDef = Util.CanonicalizeType(type);
// For enums, we want to include all their values.
// TODO: Should this be optional?
if (typeDef.IsEnum)
{
foreach (ITypeDefinitionMember member in typeDef.Members)
{
AddMemberReference(member);
}
}
base.AddTypeReference(type);
}
public static INamedTypeDefinition ResolveTypeThrowing(INamedTypeReference typeRef)
{
INamedTypeDefinition result = typeRef.ResolvedType;
if (result == Dummy.Type ||
result == Dummy.NamespaceTypeDefinition ||
result == Dummy.NestedType)
{
throw new Exception(String.Format("Cannot resolve type '{0}'. Are all dependent assemblies loaded?", typeRef.ToString()));
}
if (result == Dummy.GenericTypeParameter)
{
throw new InvalidOperationException("Why is a generic parameter being resolved?");
}
Debug.Assert(!result.GetType().Name.Contains("Dummy"));
return result;
}
public static INamedTypeDefinition ResolveTypeThrowing(INamedTypeReference typeRef)
{
INamedTypeDefinition result = typeRef.ResolvedType;
if (result == Dummy.Type ||
result == Dummy.NamespaceTypeDefinition ||
result == Dummy.NestedType)
{
throw new Exception(String.Format("Cannot resolve type '{0}'. Are all dependent assemblies loaded?", typeRef.ToString()));
}
if (result == Dummy.GenericTypeParameter)
{
throw new InvalidOperationException("Why is a generic parameter being resolved?");
}
Debug.Assert(!result.GetType().Name.Contains("Dummy"));
return(result);
}
/// <summary>
/// Caching GenericTypeInstanceRefernece objects based on interned key, avoiding GenericTypeInstance.InitializeIfNecessary expense
/// </summary>
public IGenericTypeInstanceReference GetOrMakeGenericTypeInstanceReference(INamedTypeReference genericTypeReference, IEnumerable <ITypeReference> genericArguments)
{
InternFactory factory = m_factory as InternFactory;
if (factory != null && !factory.InternKeysAreReliablyUnique)
{
return(new Microsoft.Cci.Immutable.GenericTypeInstanceReference(genericTypeReference, genericArguments, this, true));
}
uint key = m_factory.GetGenericTypeInstanceReferenceInternedKey(genericTypeReference, genericArguments);
IGenericTypeInstanceReference type = null;
object value;
if (m_objects.TryGetValue(key, out value))
{
type = value as IGenericTypeInstanceReference;
if (type != null && !SequenceEquals(genericArguments, type.GenericArguments))
{
// We can currently get problematic cache hits here for different objects representing the same type.
// e.g. SignatureGenericTypeParameter from ref signature can substitute for GenericTypeParameter
// from def signature. This breaks assumptions that were there prior to the sharing of generic
// type instances that was introduced by the caching intern factory. In that particular case, it breaks
// the subsequent specialization of the type parameter.
//
// We should investigate how to share more in these cases, but in the meantime, we conservatively
// only use an existing instantiation if the genericArguments are identical object references and
// otherwise force a cache miss here.
type = null;
}
}
if (type == null)
{
type = new Microsoft.Cci.Immutable.GenericTypeInstanceReference(genericTypeReference, genericArguments, this, true);
m_objects[key] = type;
}
return(type);
}
public virtual void VisitNode(IReference node)
{
IAssembly assembly = node as IAssembly;
INamedTypeDefinition type = node as INamedTypeDefinition;
ITypeDefinitionMember member = node as ITypeDefinitionMember;
IAliasForType alias = node as IAliasForType;
if (assembly != null)
{
if (m_implModel.CanIncludeAssembly(assembly.AssemblyIdentity))
{
Visit(assembly);
}
}
else if (type != null)
{
INamedTypeReference typeRef = Util.CanonicalizeTypeReference(type);
if (m_implModel.CanInclude(typeRef))
{
Visit(type);
}
}
else if (member != null)
{
INamedTypeReference typeRef = Util.CanonicalizeTypeReference(member.ContainingType);
if (m_implModel.CanInclude(typeRef))
{
Visit(member);
}
}
else if (alias != null)
{
Visit(alias);
}
else
{
throw new Exception("Illegal node: " + node.GetType().Name);
}
}
private static string GetMangledAndEscapedName(INamedTypeReference namedType)
{
var pooled = PooledStringBuilder.GetInstance();
StringBuilder mangledName = pooled.Builder;
const string needsEscaping = "\\[]*.+,& ";
foreach (var ch in namedType.Name)
{
if (needsEscaping.IndexOf(ch) >= 0)
{
mangledName.Append('\\');
}
mangledName.Append(ch);
}
if (namedType.MangleName && namedType.GenericParameterCount > 0)
{
mangledName.Append(MetadataHelpers.GetAritySuffix(namedType.GenericParameterCount));
}
return(pooled.ToStringAndFree());
}
public bool CanInclude(INamedTypeReference typeRef)
{
return(CanIncludeUnit(TypeHelper.GetDefiningUnitReference(typeRef)));
}
public virtual void AddTypeReference(INamedTypeReference type)
{
m_implModel.AddTypeReference(type);
}
public virtual void AddTypeReference(INamedTypeReference type)
{
Debug.Assert(CanInclude(type));
_depot.AddTypeReference(type);
}
public override void Visit(INamedTypeReference namedTypeReference)
{
allElements.Add(new InvokInfo(Traverser, "INamedTypeReference", namedTypeReference));
}
/// <summary>
/// Caching GenericTypeInstanceRefernece objects based on interned key, avoiding GenericTypeInstance.InitializeIfNecessary expense
/// </summary>
public IGenericTypeInstanceReference GetOrMakeGenericTypeInstanceReference(INamedTypeReference genericTypeReference, IEnumerable<ITypeReference> genericArguments)
{
InternFactory factory = m_factory as InternFactory;
if (factory != null && !factory.InternKeysAreReliablyUnique)
{
return new Microsoft.Cci.Immutable.GenericTypeInstanceReference(genericTypeReference, genericArguments, this, true);
}
uint key = m_factory.GetGenericTypeInstanceReferenceInternedKey(genericTypeReference, genericArguments);
IGenericTypeInstanceReference type = null;
object value;
if (m_objects.TryGetValue(key, out value))
{
type = value as IGenericTypeInstanceReference;
if (type != null && !SequenceEquals(genericArguments, type.GenericArguments))
{
// We can currently get problematic cache hits here for different objects representing the same type.
// e.g. SignatureGenericTypeParameter from ref signature can substitute for GenericTypeParameter
// from def signature. This breaks assumptions that were there prior to the sharing of generic
// type instances that was introduced by the caching intern factory. In that particular case, it breaks
// the subsequent specialization of the type parameter.
//
// We should investigate how to share more in these cases, but in the meantime, we conservatively
// only use an existing instantiation if the genericArguments are identical object references and
// otherwise force a cache miss here.
type = null;
}
}
if (type == null)
{
type = new Microsoft.Cci.Immutable.GenericTypeInstanceReference(genericTypeReference, genericArguments, this, true);
m_objects[key] = type;
}
return type;
}
public bool CanInclude(INamedTypeReference typeRef)
{
return CanIncludeUnit(TypeHelper.GetDefiningUnitReference(typeRef));
}
private ITypeReference Instantiate(uint typeSpecToken, INamedTypeReference templateTypeReference, ushort genericArgumentCount) {
//It would be very desirable to cache these objects by structure so that we can reuse them.
//However, it is not safe at this point to use the intern table because we might still be reading the
//signature of a generic method whose generic parameters feature in the arguments to the generic type.
//We cannot compute the intern key of a generic method type parameter before we are able to compute the intern key of the generic method.
var genericArgumentArray = new ITypeReference[genericArgumentCount];
for (int i = 0; i < genericArgumentCount; ++i) genericArgumentArray[i] = this.GetTypeReference()??Dummy.TypeReference;
if (typeSpecToken != 0xFFFFFFFF)
return new GenericTypeInstanceReferenceWithToken(typeSpecToken, templateTypeReference, IteratorHelper.GetReadonly(genericArgumentArray), this.PEFileToObjectModel.InternFactory);
else
return new GenericTypeInstanceReference(templateTypeReference, IteratorHelper.GetReadonly(genericArgumentArray), this.PEFileToObjectModel.InternFactory);
}
public static bool SameType(this INamedTypeReference containingType, ITypeDefinition iteratorClass)
{
return(containingType.TypeEquals(iteratorClass));
}
private static bool SeeIfTypeNamesAreMangled(INamedTypeReference/*?*/ templateTypeReference) {
if (templateTypeReference == null) return false;
if (templateTypeReference.MangleName) return true;
var nestedTypeReference = templateTypeReference as INestedTypeReference;
if (nestedTypeReference != null) return SeeIfTypeNamesAreMangled(nestedTypeReference.ContainingType as INamedTypeReference);
return false;
}
public Assembly GenerateFacade(IAssembly contractAssembly, IAssemblyReference seedCoreAssemblyReference, bool ignoreMissingTypes, IAssembly overrideContractAssembly = null, bool buildPartialReferenceFacade = false)
{
Assembly assembly;
if (overrideContractAssembly != null)
{
MetadataDeepCopier copier = new MetadataDeepCopier(_seedHost);
assembly = copier.Copy(overrideContractAssembly); // Use non-empty partial facade if present
}
else
{
MetadataDeepCopier copier = new MetadataDeepCopier(_contractHost);
assembly = copier.Copy(contractAssembly);
// if building a reference facade don't strip the contract
if (!buildPartialReferenceFacade)
{
ReferenceAssemblyToFacadeRewriter rewriter = new ReferenceAssemblyToFacadeRewriter(_seedHost, _contractHost, seedCoreAssemblyReference, _assemblyFileVersion != null);
rewriter.Rewrite(assembly);
}
}
string contractAssemblyName = contractAssembly.AssemblyIdentity.Name.Value;
IEnumerable <string> docIds = _docIdTable[contractAssemblyName];
// Add all the type forwards
bool error = false;
Dictionary <string, INamedTypeDefinition> existingDocIds = assembly.AllTypes.ToDictionary(typeDef => typeDef.RefDocId(), typeDef => typeDef);
IEnumerable <string> docIdsToForward = buildPartialReferenceFacade ? existingDocIds.Keys : docIds.Where(id => !existingDocIds.ContainsKey(id));
Dictionary <string, INamedTypeReference> forwardedTypes = new Dictionary <string, INamedTypeReference>();
foreach (string docId in docIdsToForward)
{
IReadOnlyList <INamedTypeDefinition> seedTypes;
if (!_typeTable.TryGetValue(docId, out seedTypes))
{
if (!ignoreMissingTypes && !buildPartialReferenceFacade)
{
Trace.TraceError("Did not find type '{0}' in any of the seed assemblies.", docId);
error = true;
}
continue;
}
INamedTypeDefinition seedType = GetSeedType(docId, seedTypes);
if (seedType == null)
{
TraceDuplicateSeedTypeError(docId, seedTypes);
error = true;
continue;
}
if (buildPartialReferenceFacade)
{
// honor preferSeedType for keeping contract type
string preferredSeedAssembly;
bool keepType = _seedTypePreferences.TryGetValue(docId, out preferredSeedAssembly) &&
contractAssemblyName.Equals(preferredSeedAssembly, StringComparison.OrdinalIgnoreCase);
if (keepType)
{
continue;
}
assembly.AllTypes.Remove(existingDocIds[docId]);
forwardedTypes.Add(docId, seedType);
}
AddTypeForward(assembly, seedType);
}
if (buildPartialReferenceFacade)
{
if (forwardedTypes.Count == 0)
{
Trace.TraceError("Did not find any types in any of the seed assemblies.");
return(null);
}
else
{
// for any thing that's now a typeforward, make sure typerefs point to that rather than
// the type previously inside the assembly.
TypeReferenceRewriter typeRefRewriter = new TypeReferenceRewriter(_seedHost, oldType =>
{
INamedTypeReference newType = null;
return(forwardedTypes.TryGetValue(oldType.DocId(), out newType) ? newType : oldType);
});
typeRefRewriter.Rewrite(assembly);
}
}
if (error)
{
return(null);
}
if (_assemblyFileVersion != null)
{
assembly.AssemblyAttributes.Add(CreateAttribute("System.Reflection.AssemblyFileVersionAttribute", seedCoreAssemblyReference.ResolvedAssembly, _assemblyFileVersion.ToString()));
assembly.AssemblyAttributes.Add(CreateAttribute("System.Reflection.AssemblyInformationalVersionAttribute", seedCoreAssemblyReference.ResolvedAssembly, _assemblyFileVersion.ToString()));
}
if (_buildDesignTimeFacades)
{
assembly.AssemblyAttributes.Add(CreateAttribute("System.Runtime.CompilerServices.ReferenceAssemblyAttribute", seedCoreAssemblyReference.ResolvedAssembly));
assembly.Flags |= ReferenceAssemblyFlag;
}
if (_clearBuildAndRevision)
{
assembly.Version = new Version(assembly.Version.Major, assembly.Version.Minor, 0, 0);
}
AddWin32VersionResource(contractAssembly.Location, assembly);
return(assembly);
}
private ITypeReference Specialize(uint typeSpecToken, INamedTypeReference namedTypeReference, ref ushort genericArgumentCount, bool outer) {
if (genericArgumentCount == 0) return namedTypeReference;
var nestedTypeReference = namedTypeReference as INestedTypeReference;
if (nestedTypeReference != null) {
Contract.Assume(!(nestedTypeReference is ISpecializedNestedTypeReference)); //the type reference comes from the metadata, which is always fully unspecialized
var containingType = this.Specialize(0, (INamedTypeReference)nestedTypeReference.ContainingType, ref genericArgumentCount, outer: false);
if (containingType != nestedTypeReference.ContainingType)
namedTypeReference = new SpecializedNestedTypeReference(nestedTypeReference, containingType, this.PEFileToObjectModel.InternFactory);
}
var genericParametersCount = namedTypeReference.GenericParameterCount;
if (genericParametersCount == 0) {
if (genericArgumentCount == 0 || !outer) return namedTypeReference;
//If we get here we believed that namedTypeReference has no type parameters because it has no tick in its name.
//However, there actually are generic types without ticks, so we better now change our belief to match this signature.
//This does not work for nested generics, but that is just too bad.
genericParametersCount = genericArgumentCount;
}
genericArgumentCount -= genericParametersCount;
var genericArgumentArray = new ITypeReference[genericParametersCount];
//TODO: it would be very desirable to cache these objects by structure so that we can reuse them.
//However, it is not safe at this point to use the intern table because we might still be reading the
//signature of a generic method whose generic parameters feature in the arguments to the generic type.
//We cannot compute the intern key of a generic method type parameter before we are able to compute the intern key of the generic method.
for (int i = 0; i < genericParametersCount; ++i) genericArgumentArray[i] = this.GetTypeReference()??Dummy.TypeReference;
if (outer && typeSpecToken != 0xFFFFFFFF)
return new GenericTypeInstanceReferenceWithToken(typeSpecToken, namedTypeReference, IteratorHelper.GetReadonly(genericArgumentArray), this.PEFileToObjectModel.InternFactory);
else
return new GenericTypeInstanceReference(namedTypeReference, IteratorHelper.GetReadonly(genericArgumentArray), this.PEFileToObjectModel.InternFactory);
}
/// <summary>
/// Performs some computation with the given named type reference.
/// </summary>
public virtual void Visit(INamedTypeReference namedTypeReference)
{
}
/// <summary>
/// Provides the host with an opportunity to substitute one type reference for another during metadata reading.
/// This avoids the cost of rewriting the entire unit in order to make such changes.
/// </summary>
/// <param name="referringUnit">The unit that contains the reference.</param>
/// <param name="typeReference">A named type reference encountered during metadata reading.</param>
/// <returns>
/// Usually the value in typeReference, but occassionally something else.
/// </returns>
public INamedTypeReference Redirect(IUnit referringUnit, INamedTypeReference typeReference) {
Contract.Requires(referringUnit != null);
Contract.Requires(typeReference != null);
Contract.Ensures(Contract.Result<INamedTypeReference>() != null);
throw new NotImplementedException();
}
internal TypeInferencer(INamedTypeReference containingType, IMetadataHost host)
{
this.containingType = containingType;
this.host = host;
this.platformType = containingType.PlatformType;
}
public override void Visit(INamedTypeReference namedTypeReference)
{
if(Process(namedTypeReference)){visitor.Visit(namedTypeReference);}
base.Visit(namedTypeReference);
}
private ITypeReference SpecializeAndOrInstantiate(uint typeSpecToken, INamedTypeReference namedTypeReference, ref ushort genericArgumentCount, bool outer) {
if (genericArgumentCount == 0) return namedTypeReference;
var nestedTypeReference = namedTypeReference as INestedTypeReference;
if (nestedTypeReference != null) {
Contract.Assume(!(nestedTypeReference is ISpecializedNestedTypeReference)); //the type reference comes from the metadata, which is always fully unspecialized
var containingType = this.SpecializeAndOrInstantiate(0, (INamedTypeReference)nestedTypeReference.ContainingType, ref genericArgumentCount, outer: false);
if (containingType != nestedTypeReference.ContainingType)
namedTypeReference = new SpecializedNestedTypeReference(nestedTypeReference, containingType, this.PEFileToObjectModel.InternFactory);
}
if (genericArgumentCount <= 0) return namedTypeReference;
var genericParametersCount = namedTypeReference.GenericParameterCount;
genericArgumentCount -= genericParametersCount;
if (genericArgumentCount < 0) { genericParametersCount += genericArgumentCount; };
if (genericParametersCount == 0) return namedTypeReference;
return this.Instantiate(typeSpecToken, namedTypeReference, genericParametersCount);
}
public static string Serialize(INamedTypeReference type)
{
var types = new INamedTypeReference[] { type };
return(Serialize(type));
}
public static List <ITypeDefinitionMember> FindRelatedMembers(ITypeDefinitionMember member, TypeIncluded includeType)
{
List <ITypeDefinitionMember> relatedMembers = new List <ITypeDefinitionMember>();
Dictionary <uint, ITypeReference> participatingTypes = new Dictionary <uint, ITypeReference>();
ITypeDefinition currentType = member.ContainingTypeDefinition;
do
{
//
// add the type
//
participatingTypes.Add(currentType.InternedKey, currentType);
//
// add any interfaces it implements that are part of the closure
//
foreach (ITypeReference iface in currentType.Interfaces)
{
INamedTypeReference ifaceTemplate = Util.CanonicalizeTypeReference(iface);
// check the closure against the template type, but add
// the specialized type to participatingTypes so that
// argument matching works
if (includeType(ifaceTemplate) &&
!participatingTypes.ContainsKey(iface.InternedKey))
{
// Should we add ifaceTemplate or iface?
participatingTypes.Add(iface.InternedKey, iface);
}
}
//
// go up to the base type
//
currentType = TypeHelper.BaseClass(currentType);
}while (currentType != null);
foreach (ITypeReference type in participatingTypes.Values)
{
ITypeDefinitionMember relatedMember = FindRelatedMember(type, member);
if (null != relatedMember)
{
relatedMembers.Add(relatedMember);
}
// TODO: Review
foreach (IMethodImplementation methodImpl in Util.CanonicalizeType(type).ExplicitImplementationOverrides)
{
ITypeDefinitionMember implementingMethod = Util.CanonicalizeMember(methodImpl.ImplementingMethod);
ITypeDefinitionMember implementedMethod = Util.CanonicalizeMember(methodImpl.ImplementedMethod);
bool implementedTypeIncluded = includeType(Util.CanonicalizeType(implementedMethod.ContainingType));
if ((implementedMethod == member) ||
(implementingMethod == member && implementedTypeIncluded))
{
if (!relatedMembers.Contains(implementingMethod))
{
relatedMembers.Add(implementingMethod);
}
if (!relatedMembers.Contains(implementedMethod))
{
relatedMembers.Add(implementedMethod);
}
}
}
}
return(relatedMembers);
}
private static string GetMangledAndEscapedName(INamedTypeReference namedType)
{
var pooled = PooledStringBuilder.GetInstance();
StringBuilder mangledName = pooled.Builder;
const string needsEscaping = "\\[]*.+,& ";
foreach (var ch in namedType.Name)
{
if (needsEscaping.IndexOf(ch) >= 0)
{
mangledName.Append('\\');
}
mangledName.Append(ch);
}
if (namedType.MangleName && namedType.GenericParameterCount > 0)
{
mangledName.Append(MetadataHelpers.GetAritySuffix(namedType.GenericParameterCount));
}
return pooled.ToStringAndFree();
}
internal TypeInferencer(INamedTypeReference containingType, IMetadataHost host)
{
this.containingType = containingType;
this.host = host;
this.platformType = containingType.PlatformType;
}
/// <summary>
/// Performs some computation with the given named type reference.
/// </summary>
public void Visit(INamedTypeReference namedTypeReference)
{
this.Visit((ITypeReference)namedTypeReference);
}
/// <summary>
/// Rewrites the named specified type reference.
/// </summary>
public virtual INamedTypeReference Rewrite(INamedTypeReference typeReference)
{
return typeReference;
}
private ITypeReference GetSpecializedTypeReference(PEFileToObjectModel peFileToObjectModel, INamedTypeReference nominalType, out int argumentUsed, bool mostNested) {
argumentUsed = 0;
int len = this.GenericArguments.Count;
var nestedType = nominalType as INestedTypeReference;
if (nestedType != null) {
var parentTemplate = this.GetSpecializedTypeReference(peFileToObjectModel, (INamedTypeReference)nestedType.ContainingType, out argumentUsed, mostNested: false);
if (parentTemplate != nestedType.ContainingType)
nominalType = new SpecializedNestedTypeReference(nestedType, parentTemplate, peFileToObjectModel.InternFactory);
}
var argsToUse = mostNested ? len-argumentUsed : nominalType.GenericParameterCount;
if (argsToUse == 0) return nominalType;
var genericArgumentsReferences = new ITypeReference[argsToUse];
for (int i = 0; i < argsToUse; ++i)
genericArgumentsReferences[i] = this.GenericArguments[i+argumentUsed].GetAsTypeReference(peFileToObjectModel, peFileToObjectModel.Module)??Dummy.TypeReference;
argumentUsed += argsToUse;
return new GenericTypeInstanceReference(nominalType, IteratorHelper.GetReadonly(genericArgumentsReferences), peFileToObjectModel.InternFactory);
}
private ITypeReference Specialize(uint typeSpecToken, INamedTypeReference namedTypeReference, ref ushort genericArgumentCount, bool outer) {
if (genericArgumentCount == 0) return namedTypeReference;
var nestedTypeReference = namedTypeReference as INestedTypeReference;
if (nestedTypeReference != null) {
Contract.Assume(!(nestedTypeReference is ISpecializedNestedTypeReference)); //the type reference comes from the metadata, which is always fully unspecialized
var containingType = this.Specialize(0, (INamedTypeReference)nestedTypeReference.ContainingType, ref genericArgumentCount, outer: false);
if (containingType != nestedTypeReference.ContainingType)
namedTypeReference = new SpecializedNestedTypeReference(nestedTypeReference, containingType, this.PEFileToObjectModel.InternFactory);
}
var genericParametersCount = namedTypeReference.GenericParameterCount;
if (genericParametersCount == 0) {
if (genericArgumentCount == 0 || !outer) return namedTypeReference;
//If we get here we believed that namedTypeReference has no type parameters because it has no tick in its name.
//However, there actually are generic types without ticks, so we better now change our belief to match this signature.
//This does not work for nested generics, but that is just too bad.
genericParametersCount = genericArgumentCount;
}
genericArgumentCount -= genericParametersCount;
var genericArgumentArray = new ITypeReference[genericParametersCount];
for (int i = 0; i < genericParametersCount; ++i) genericArgumentArray[i] = this.GetTypeReference()??Dummy.TypeReference;
if (outer)
return new GenericTypeInstanceReferenceWithToken(typeSpecToken, namedTypeReference, IteratorHelper.GetReadonly(genericArgumentArray), this.PEFileToObjectModel.InternFactory);
else
return new GenericTypeInstanceReference(namedTypeReference, IteratorHelper.GetReadonly(genericArgumentArray), this.PEFileToObjectModel.InternFactory);
}
public virtual void AddTypeReference(INamedTypeReference type)
{
Debug.Assert(CanInclude(type));
_depot.AddTypeReference(type);
}
/// <summary>
/// Performs some computation with the given named type reference.
/// </summary>
public virtual void Visit(INamedTypeReference namedTypeReference)
{
}
/// <summary>
/// Provides the host with an opportunity to substitute one named type reference for another during metadata reading.
/// This avoids the cost of rewriting the entire unit in order to make such changes.
/// </summary>
/// <param name="referringUnit">The unit that contains the reference.</param>
/// <param name="typeReference">A named type reference encountered during metadata reading.</param>
/// <returns>
/// Usually the value in typeReference, but occassionally something else.
/// </returns>
public virtual INamedTypeReference Redirect(IUnit referringUnit, INamedTypeReference typeReference) {
return typeReference;
}
/// <summary>
/// Provides the host with an opportunity to substitute one type reference for another during metadata reading.
/// This avoids the cost of rewriting the entire unit in order to make such changes.
/// </summary>
/// <param name="referringUnit">The unit that contains the reference.</param>
/// <param name="typeReference">A type reference encountered during metadata reading.</param>
/// <returns>
/// Usually the value in typeReference, but occassionally something else.
/// </returns>
public override INamedTypeReference Redirect(IUnit referringUnit, INamedTypeReference typeReference) {
if (!this.projectToCLRTypes) return typeReference;
var referringModule = referringUnit as IModule;
if (referringModule == null || referringModule.ContainingAssembly == null || !(referringModule.ContainingAssembly.ContainsForeignTypes)) return typeReference;
var platformType = (WindowsRuntimePlatform)this.PlatformType;
var namespaceTypeReference = typeReference as INamespaceTypeReference;
if (namespaceTypeReference == null) return typeReference;
var namespaceReference = namespaceTypeReference.ContainingUnitNamespace as INestedUnitNamespaceReference;
if (namespaceReference == null) return typeReference;
if (this.IsWindowsFoundationMetadata(namespaceReference)) {
if (namespaceTypeReference.Name == platformType.SystemAttributeUsageAttribute.Name) return platformType.SystemAttributeUsageAttribute;
if (namespaceTypeReference.Name == platformType.SystemAttributeTargets.Name) return platformType.SystemAttributeTargets;
} else if (this.IsWindowsUI(namespaceReference)) {
if (namespaceTypeReference.Name == platformType.WindowsUIColor.Name) return platformType.WindowsUIColor;
} else if (this.IsWindowsFoundation(namespaceReference)) {
if (namespaceTypeReference.Name == platformType.SystemDateTime.Name) return platformType.SystemDateTimeOffset;
if (namespaceTypeReference.Name == platformType.SystemEventHandler1.Name && namespaceTypeReference.GenericParameterCount == 1)
return platformType.SystemEventHandler1;
if (namespaceTypeReference.Name == platformType.SystemRuntimeInteropServicesWindowsRuntimeEventRegistrationToken.Name)
return platformType.SystemRuntimeInteropServicesWindowsRuntimeEventRegistrationToken;
if (namespaceTypeReference.Name == this.HResult) return platformType.SystemException;
if (namespaceTypeReference.Name == this.IReference && namespaceTypeReference.GenericParameterCount == 1)
return platformType.SystemNullable1;
if (namespaceTypeReference.Name == platformType.WindowsFoundationPoint.Name) return platformType.WindowsFoundationPoint;
if (namespaceTypeReference.Name == platformType.WindowsFoundationRect.Name) return platformType.WindowsFoundationRect;
if (namespaceTypeReference.Name == platformType.WindowsFoundationSize.Name) return platformType.WindowsFoundationSize;
if (namespaceTypeReference.Name == platformType.SystemTimeSpan.Name) return platformType.SystemTimeSpan;
if (namespaceTypeReference.Name == platformType.SystemUri.Name) return platformType.SystemUri;
if (namespaceTypeReference.Name == this.IClosable) return platformType.SystemIDisposable;
} else if (this.IsWindowsFoundationCollections(namespaceReference)) {
if (namespaceTypeReference.Name == this.IIterable) return platformType.SystemCollectionsGenericIEnumerable;
if (namespaceTypeReference.Name == this.IVector) return platformType.SystemCollectionsGenericIList;
if (namespaceTypeReference.Name == this.IVectorView) return platformType.SystemCollectionsGenericReadOnlyList;
if (namespaceTypeReference.Name == this.IMap) return platformType.SystemCollectionsGenericIDictionary;
if (namespaceTypeReference.Name == this.IMapView) return platformType.SystemCollectionsGenericReadOnlyDictionary;
if (namespaceTypeReference.Name == this.IKeyValuePair) return platformType.SystemCollectionsGenericKeyValuePair;
} else if (this.IsWindowsUIXamlInput(namespaceReference)) {
if (namespaceTypeReference.Name == platformType.SystemWindowsInputICommand.Name) return platformType.SystemWindowsInputICommand;
} else if (this.IsWindowsUIXamlInterop(namespaceReference)) {
if (namespaceTypeReference.Name == this.IBindableIterable) return platformType.SystemCollectionsIEnumerable;
if (namespaceTypeReference.Name == this.IBindableVector) return platformType.SystemCollectionsIList;
if (namespaceTypeReference.Name == this.INotifyCollectionChanged) return platformType.SystemCollectionsSpecializedINotifyColletionChanged;
if (namespaceTypeReference.Name == this.NotifyCollectionChangedEventHandler) return platformType.SystemCollectionsSpecializedNotifyCollectionChangedEventHandler;
if (namespaceTypeReference.Name == this.NotifyCollectionChangedEventArgs) return platformType.SystemCollectionsSpecializedNotifyCollectionChangedEventArgs;
if (namespaceTypeReference.Name == this.NotifyCollectionChangedAction) return platformType.SystemCollectionsSpecializedNotifyCollectionChangedAction;
if (namespaceTypeReference.Name == this.TypeName) return platformType.SystemType;
} else if (this.IsWindowsUIXamlData(namespaceReference)) {
if (namespaceTypeReference.Name == this.INotifyPropertyChanged) return platformType.SystemComponentModelINotifyPropertyChanged;
if (namespaceTypeReference.Name == this.PropertyChangedEventArgs) return platformType.SystemComponentModelPropertyChangedEventArgs;
if (namespaceTypeReference.Name == this.PropertyChangedEventHandler) return platformType.SystemComponentModelPropertyChangedEventHandler;
} else if (this.IsWindowsUIXaml(namespaceReference)) {
if (namespaceTypeReference.Name == platformType.WindowsUIXamlCornerRadius.Name) return platformType.WindowsUIXamlCornerRadius;
if (namespaceTypeReference.Name == platformType.WindowsUIXamlDuration.Name) return platformType.WindowsUIXamlDuration;
if (namespaceTypeReference.Name == platformType.WindowsUIXamlDurationType.Name) return platformType.WindowsUIXamlDurationType;
if (namespaceTypeReference.Name == platformType.WindowsUIXamlGridLength.Name) return platformType.WindowsUIXamlGridLength;
if (namespaceTypeReference.Name == platformType.WindowsUIXamlGridUnitType.Name) return platformType.WindowsUIXamlGridUnitType;
if (namespaceTypeReference.Name == platformType.WindowsUIXamlThickness.Name) return platformType.WindowsUIXamlThickness;
} else if (this.IsWindowsUIXamlControlsPrimitives(namespaceReference)) {
if (namespaceTypeReference.Name == platformType.WindowsUIXamlControlsPrimitivesGeneratorPosition.Name)
return platformType.WindowsUIXamlControlsPrimitivesGeneratorPosition;
} else if (this.IsWindowsUIXamlMedia(namespaceReference)) {
if (namespaceTypeReference.Name == platformType.WindowsUIXamlMediaMatrix.Name) return platformType.WindowsUIXamlMediaMatrix;
} else if (this.IsWindowsUIXamlMediaAnimation(namespaceReference)) {
if (namespaceTypeReference.Name == platformType.WindowsUIXamlMediaAnimationKeyTime.Name)
return platformType.WindowsUIXamlMediaAnimationKeyTime;
if (namespaceTypeReference.Name == platformType.WindowsUIXamlMediaAnimationRepeatBehavior.Name)
return platformType.WindowsUIXamlMediaAnimationRepeatBehavior;
if (namespaceTypeReference.Name == platformType.WindowsUIXamlMediaAnimationRepeatBehaviorType.Name)
return platformType.WindowsUIXamlMediaAnimationRepeatBehaviorType;
} else if (this.IsWindowsUIXamlMediaMedia3D(namespaceReference)) {
if (namespaceTypeReference.Name == platformType.WindowsUIXamlMediaMedia3DMatrix3D.Name)
return platformType.WindowsUIXamlMediaMedia3DMatrix3D;
}
return typeReference;
}
private static void WriteType(ITypeReference type, TextWriter writer, bool omitOutermostTypeFormals)
{
Contract.Requires(type != null);
Contract.Requires(writer != null);
IArrayType array = type as IArrayType;
if (array != null)
{
Contract.Assume(array.ElementType != null, "lack of CCI2 contracts");
WriteType(array.ElementType, writer);
writer.Write("[");
if (array.Rank > 1)
{
for (int i = 0; i < array.Rank; i++)
{
if (i > 0)
{
writer.Write(",");
}
writer.Write("0:");
}
}
writer.Write("]");
return;
}
IManagedPointerTypeReference reference = type as IManagedPointerTypeReference;;
if (reference != null)
{
Contract.Assume(reference.TargetType != null, "lack of CCI2 contracts");
var referencedType = reference.TargetType;
WriteType(referencedType, writer);
writer.Write("@");
return;
}
IPointerTypeReference pointer = type as IPointerTypeReference;
if (pointer != null)
{
Contract.Assume(pointer.TargetType != null, "lack of CCI2 contracts");
WriteType(pointer.TargetType, writer);
writer.Write("*");
return;
}
IModifiedTypeReference modref = type as IModifiedTypeReference;
if (modref != null)
{
Contract.Assume(modref.UnmodifiedType != null, "lack of CCI2 contracts");
Contract.Assume(modref.CustomModifiers != null, "lack of CCI2 contracts");
WriteType(modref.UnmodifiedType, writer);
foreach (var modifier in modref.CustomModifiers)
{
Contract.Assume(modifier != null, "lack of collection contracts and CCI2 contracts");
Contract.Assume(modifier.Modifier != null, "lack of CCI2 contracts");
if (modifier.IsOptional)
{
writer.Write("!");
}
else
{
writer.Write("|");
}
WriteType(modifier.Modifier, writer);
}
return;
}
IGenericTypeParameterReference gtp = type as IGenericTypeParameterReference;
if (gtp != null)
{
writer.Write("`");
writer.Write(gtp.Index);
return;
}
IGenericMethodParameterReference gmp = type as IGenericMethodParameterReference;
if (gmp != null)
{
writer.Write("``");
writer.Write(gmp.Index);
return;
}
IGenericTypeInstanceReference instance = type as IGenericTypeInstanceReference;
if (instance != null)
{
Contract.Assume(instance.GenericType != null, "lack of CCI2 contracts");
Contract.Assume(instance.GenericArguments != null, "lack of CCI2 contracts");
WriteType(instance.GenericType, writer, true);
writer.Write("{");
var first = true;
foreach (var arg in instance.GenericArguments)
{
Contract.Assume(arg != null, "lack of collection and CCI2 contracts");
if (first)
{
first = false;
}
else
{
writer.Write(",");
}
WriteType(arg, writer);
}
writer.Write("}");
return;
}
// namespace or nested
INamedTypeReference named = (INamedTypeReference)type;
INestedTypeReference nested = type as INestedTypeReference;
if (nested != null)
{
Contract.Assume(nested.ContainingType != null, "lack of CCI2 contracts");
// names of nested types begin with outer type name
WriteType(nested.ContainingType, writer);
writer.Write(".");
// continue to write type sig
}
INamespaceTypeReference nt = type as INamespaceTypeReference;
if (nt != null)
{
Contract.Assume(nt.ContainingUnitNamespace != null, "lack of CCI2 contracts");
WriteNamespaceAndSeparator(nt.ContainingUnitNamespace, writer);
// continue to write type sig
}
// name
writer.Write(named.Name.Value);
// generic parameters
if (omitOutermostTypeFormals)
{
return;
}
if (named.GenericParameterCount > 0)
{
writer.Write("`{0}", named.GenericParameterCount);
}
}
public virtual void AddTypeReference(INamedTypeReference type)
{
m_implModel.AddTypeReference(type);
}
