/// <summary> /// Get the reference of a method in the closure class as used by other methods in the same class. /// </summary> private IMethodReference GetReferenceOfMethodUsedByPeers(IMethodDefinition method) { IMethodReference methodReference = null; ITypeReference typeReference = this.ClosureDefinitionReference; ISpecializedNestedTypeReference specializedNestedTypeRef = typeReference as ISpecializedNestedTypeReference; IGenericTypeInstanceReference genericInstanceRef = typeReference as IGenericTypeInstanceReference; if (specializedNestedTypeRef != null || genericInstanceRef != null) { methodReference = new SpecializedMethodReference() { ContainingType = typeReference, GenericParameterCount = method.GenericParameterCount, InternFactory = this.host.InternFactory, UnspecializedVersion = method, Type = method.Type, Name = method.Name, CallingConvention = method.CallingConvention, Parameters = method.ParameterCount == 0 ? null : new List <IParameterTypeInformation>(((IMethodReference)method).Parameters), ExtraParameters = null, ReturnValueIsByRef = method.ReturnValueIsByRef, ReturnValueIsModified = method.ReturnValueIsModified, Attributes = null, }; } else { methodReference = method; } return(methodReference); }
/// <summary> /// See if a type reference refers to a type definition that is compiler generated. /// </summary> /// <param name="typeReference"></param> /// <returns></returns> internal static bool IsCompilerGenerated(ITypeReference /*!*/ typeReference) { if (AttributeHelper.Contains(typeReference.ResolvedType.Attributes, typeReference.PlatformType.SystemRuntimeCompilerServicesCompilerGeneratedAttribute)) { return(true); } IGenericTypeInstanceReference genericTypeInstanceReference = typeReference as IGenericTypeInstanceReference; if (genericTypeInstanceReference != null && IsCompilerGenerated(genericTypeInstanceReference.GenericType)) { return(true); } ISpecializedNestedTypeReference specializedNestedType = typeReference as ISpecializedNestedTypeReference; if (specializedNestedType != null && IsCompilerGenerated(specializedNestedType.UnspecializedVersion)) { return(true); } ISpecializedNestedTypeDefinition specializedNestedTypeDefinition = typeReference as ISpecializedNestedTypeDefinition; if (specializedNestedTypeDefinition != null && IsCompilerGenerated(specializedNestedTypeDefinition.UnspecializedVersion)) { return(true); } INestedTypeReference nestedTypeReference = UnspecializedMethods.AsUnspecializedNestedTypeReference(typeReference); if (nestedTypeReference != null) { return(IsCompilerGenerated(nestedTypeReference.ContainingType)); } return(false); }
public override void Visit(IGenericTypeInstanceReference genericTypeInstanceReference) { if (Process(genericTypeInstanceReference)) { visitor.Visit(genericTypeInstanceReference); } base.Visit(genericTypeInstanceReference); }
private static void VisitTypeReference(ITypeReference typeReference, EmitContext context) { Debug.Assert(typeReference != null); IArrayTypeReference arrayType = typeReference as IArrayTypeReference; if (arrayType != null) { VisitTypeReference(arrayType.GetElementType(context), context); return; } IPointerTypeReference pointerType = typeReference as IPointerTypeReference; if (pointerType != null) { VisitTypeReference(pointerType.GetTargetType(context), context); return; } //IManagedPointerTypeReference managedPointerType = typeReference as IManagedPointerTypeReference; //if (managedPointerType != null) //{ // VisitTypeReference(managedPointerType.GetTargetType(this.context)); // return; //} IModifiedTypeReference modifiedType = typeReference as IModifiedTypeReference; if (modifiedType != null) { foreach (var custModifier in modifiedType.CustomModifiers) { VisitTypeReference(custModifier.GetModifier(context), context); } VisitTypeReference(modifiedType.UnmodifiedType, context); return; } // Visit containing type INestedTypeReference nestedType = typeReference.AsNestedTypeReference; if (nestedType != null) { VisitTypeReference(nestedType.GetContainingType(context), context); } // Visit generic arguments IGenericTypeInstanceReference genericInstance = typeReference.AsGenericTypeInstanceReference; if (genericInstance != null) { foreach (var arg in genericInstance.GetGenericArguments(context)) { VisitTypeReference(arg, context); } } }
protected override string GetGenericTypeInstanceName(IGenericTypeInstanceReference genericTypeInstance, NameFormattingOptions formattingOptions) { Contract.Requires(genericTypeInstance != null); Contract.Ensures(Contract.Result <string>() != null); ITypeReference genericType = genericTypeInstance.GenericType; if ((formattingOptions & NameFormattingOptions.ContractNullable) != 0) { if (TypeHelper.TypesAreEquivalent(genericType, genericTypeInstance.PlatformType.SystemNullable)) { foreach (ITypeReference tref in genericTypeInstance.GenericArguments) { return(this.GetTypeName(tref, formattingOptions) + "?"); } } } if ((formattingOptions & NameFormattingOptions.OmitTypeArguments) == 0) { // Don't include the type parameters if we are to include the type arguments // If formatting for a documentation id, don't use generic type name suffixes. StringBuilder sb = new StringBuilder(this.GetTypeName(genericType, formattingOptions & ~(NameFormattingOptions.TypeParameters | ((formattingOptions & NameFormattingOptions.FormattingForDocumentationId) != 0 ? NameFormattingOptions.UseGenericTypeNameSuffix : NameFormattingOptions.None)))); if ((formattingOptions & NameFormattingOptions.FormattingForDocumentationId) != 0) { sb.Append("{"); } else { sb.Append("(Of "); } bool first = true; string delim = ((formattingOptions & NameFormattingOptions.OmitWhiteSpaceAfterListDelimiter) == 0) ? ", " : ","; foreach (ITypeReference argument in genericTypeInstance.GenericArguments) { if (first) { first = false; } else { sb.Append(delim); } sb.Append(this.GetTypeName(argument, formattingOptions & ~(NameFormattingOptions.MemberKind | NameFormattingOptions.DocumentationIdMemberKind))); } if ((formattingOptions & NameFormattingOptions.FormattingForDocumentationId) != 0) { sb.Append("}"); } else { sb.Append(")"); } return(sb.ToString()); } //If type arguments are not wanted, then type parameters are not going to be welcome either. return(this.GetTypeName(genericType, formattingOptions & ~NameFormattingOptions.TypeParameters)); }
public override void TraverseChildren(IGenericTypeInstanceReference genericTypeInstanceReference) { var typ = genericTypeInstanceReference.ResolvedType; if (!(typ is IGenericTypeInstance) || (((IGenericTypeInstance)typ).GenericType is Dummy)) { this.EmitError(genericTypeInstanceReference, ErrorCode.GenericTypeInstanceResolution); } base.TraverseChildren(genericTypeInstanceReference); }
private static void AppendAssemblyQualifierIfNecessary(StringBuilder sb, ITypeReference typeReference, out bool isAssemQualified, EmitContext context) { INestedTypeReference nestedType = typeReference.AsNestedTypeReference; if (nestedType != null) { AppendAssemblyQualifierIfNecessary(sb, nestedType.GetContainingType(context), out isAssemQualified, context); return; } IGenericTypeInstanceReference genInst = typeReference.AsGenericTypeInstanceReference; if (genInst != null) { AppendAssemblyQualifierIfNecessary(sb, genInst.GetGenericType(context), out isAssemQualified, context); return; } IArrayTypeReference arrType = typeReference as IArrayTypeReference; if (arrType != null) { AppendAssemblyQualifierIfNecessary(sb, arrType.GetElementType(context), out isAssemQualified, context); return; } IPointerTypeReference pointer = typeReference as IPointerTypeReference; if (pointer != null) { AppendAssemblyQualifierIfNecessary(sb, pointer.GetTargetType(context), out isAssemQualified, context); return; } isAssemQualified = false; IAssemblyReference referencedAssembly = null; INamespaceTypeReference namespaceType = typeReference.AsNamespaceTypeReference; if (namespaceType != null) { referencedAssembly = namespaceType.GetUnit(context) as IAssemblyReference; } if (referencedAssembly != null) { var containingAssembly = context.Module.GetContainingAssembly(context); if (containingAssembly == null || !ReferenceEquals(referencedAssembly, containingAssembly)) { sb.Append(", "); sb.Append(MetadataWriter.StrongName(referencedAssembly)); isAssemQualified = true; } } }
internal static void GetConsolidatedTypeArguments(this ITypeReference typeReference, ArrayBuilder <ITypeReference> consolidatedTypeArguments, EmitContext context) { INestedTypeReference nestedTypeReference = typeReference.AsNestedTypeReference; nestedTypeReference?.GetContainingType(context).GetConsolidatedTypeArguments(consolidatedTypeArguments, context); IGenericTypeInstanceReference genTypeInstance = typeReference.AsGenericTypeInstanceReference; if (genTypeInstance != null) { consolidatedTypeArguments.AddRange(genTypeInstance.GetGenericArguments(context)); } }
public static INamedTypeReference CanonicalizeTypeReference(ITypeReference type) { while (type != null) { IModifiedTypeReference modifiedType = type as IModifiedTypeReference; IPointerTypeReference ptrType = type as IPointerTypeReference; IManagedPointerType refType = type as IManagedPointerType; IArrayTypeReference arrType = type as IArrayTypeReference; IGenericTypeInstanceReference genType = type as IGenericTypeInstanceReference; ISpecializedNestedTypeReference nestedType = type as ISpecializedNestedTypeReference; // TODO: Why doesn't ISpecializedNestedTypeDefinition derive from ISpecializedNestedTypeReference? ISpecializedNestedTypeDefinition nestedTypeDef = type as ISpecializedNestedTypeDefinition; if (modifiedType != null) { type = modifiedType.UnmodifiedType; } else if (ptrType != null) { type = ptrType.TargetType; } else if (refType != null) { type = refType.TargetType; } else if (arrType != null) { type = arrType.ElementType; } else if (genType != null) { type = genType.GenericType; } else if (nestedType != null) { type = nestedType.UnspecializedVersion; } else if (nestedTypeDef != null) { type = nestedTypeDef.UnspecializedVersion; } else /* ITypeDefinition */ { break; } } return(type as INamedTypeReference); }
public override void Visit(IGenericTypeInstanceReference genericTypeInstanceReference) { var template = genericTypeInstanceReference.GenericType; var specializedNestedType = template as ISpecializedNestedTypeReference; if (specializedNestedType != null) { template = specializedNestedType.UnspecializedVersion; } var templateType = this.mapper.GetType(template); var consolidatedArguments = new List <Type>(); this.GetConsolidatedTypeArguments(consolidatedArguments, genericTypeInstanceReference); this.result = templateType.MakeGenericType(consolidatedArguments.ToArray()); }
private bool IncludeTypeReference(ITypeReference type) { // if a generic type and one of the generic arguments are excluded IGenericTypeInstanceReference genericType = type as IGenericTypeInstanceReference; if (genericType != null && genericType.GenericArguments.Any(genArg => _docIds.Contains(genArg.DocId()))) { return(false); } // if the type itself is excluded string typeId = type.DocId(); return(!_docIds.Contains(typeId)); }
public static ITypeReference UnWrap(this ITypeReference reference) { IPointerTypeReference pointer = reference as IPointerTypeReference; if (pointer != null) { return(pointer.TargetType.UnWrap()); } IArrayTypeReference array = reference as IArrayTypeReference; if (array != null) { return(array.ElementType.UnWrap()); } IModifiedTypeReference modified = reference as IModifiedTypeReference; if (modified != null) { return(modified.UnmodifiedType.UnWrap()); } ISpecializedNestedTypeReference specialized = reference as ISpecializedNestedTypeReference; if (specialized != null) { return(specialized.UnspecializedVersion.UnWrap()); } IGenericTypeInstanceReference instantiation = reference as IGenericTypeInstanceReference; if (instantiation != null) { return(instantiation.GenericType.UnWrap()); } Contract.Assert(reference is INamedTypeReference || reference is INestedTypeReference || reference is INamespaceTypeReference || reference is IGenericTypeParameterReference || reference is IGenericMethodParameterReference || reference is IFunctionPointerTypeReference || reference is IManagedPointerType, string.Format("Unexpected type reference that we may need to unwrap {0}", (reference != null ? reference.GetType().FullName : "null"))); return(reference); }
/// <summary> /// Given a type, if it is a specialized type, return its generic type. Otherwise return itself. /// If the type reference refers to a nested type, return a reference to the uninstantiated and/or unspecialized version /// of the nested type. Otherwise return the given type reference. /// </summary> internal static ITypeReference /*!*/ AsUnspecializedTypeReference(ITypeReference /*!*/ typeReference) { IGenericTypeInstanceReference genericTypeInstanceReference = typeReference as IGenericTypeInstanceReference; if (genericTypeInstanceReference != null) { return(AsUnspecializedTypeReference(genericTypeInstanceReference.GenericType)); } var specializedNestedTypeReference = typeReference as ISpecializedNestedTypeReference; if (specializedNestedTypeReference != null) { return(specializedNestedTypeReference.UnspecializedVersion); } return(typeReference); }
public static ITypeReference UnWrap(this ITypeReference reference) { IPointerTypeReference pointer = reference as IPointerTypeReference; if (pointer != null) { return(pointer.TargetType.UnWrap()); } IArrayTypeReference array = reference as IArrayTypeReference; if (array != null) { return(array.ElementType.UnWrap()); } IModifiedTypeReference modified = reference as IModifiedTypeReference; if (modified != null) { return(modified.UnmodifiedType.UnWrap()); } ISpecializedNestedTypeReference specialized = reference as ISpecializedNestedTypeReference; if (specialized != null) { return(specialized.UnspecializedVersion.UnWrap()); } IGenericTypeInstanceReference instantiation = reference as IGenericTypeInstanceReference; if (instantiation != null) { return(instantiation.GenericType.UnWrap()); } Contract.Assert(reference is INamedTypeReference || reference is INestedTypeReference || reference is INamespaceTypeReference || reference is IGenericTypeParameterReference || reference is IGenericMethodParameterReference || reference is IFunctionPointerTypeReference, string.Format(CultureInfo.CurrentCulture, LocalizedStrings.UnexpectedTypeReference, (reference?.GetType()?.FullName ?? "null"))); return(reference); }
internal static ITypeReference GetUninstantiatedGenericType(this ITypeReference typeReference, EmitContext context) { IGenericTypeInstanceReference genericTypeInstanceReference = typeReference.AsGenericTypeInstanceReference; if (genericTypeInstanceReference != null) { return(genericTypeInstanceReference.GetGenericType(context)); } ISpecializedNestedTypeReference specializedNestedType = typeReference.AsSpecializedNestedTypeReference; if (specializedNestedType != null) { return(specializedNestedType.GetUnspecializedVersion(context)); } return(typeReference); }
public override void Visit(IGenericTypeInstanceReference genericTypeInstanceReference) { // ^ ensures this.path.Count == old(this.path.Count); INestedTypeReference nestedType = genericTypeInstanceReference.AsNestedTypeReference; if (nestedType != null) { ITypeReference containingType = nestedType.GetContainingType(Context); if (containingType.AsGenericTypeInstanceReference != null || containingType.AsSpecializedNestedTypeReference != null) { this.Visit(nestedType.GetContainingType(Context)); } } this.Visit(genericTypeInstanceReference.GenericType); this.Visit(genericTypeInstanceReference.GetGenericArguments(Context)); }
public override void Visit(IGenericTypeInstanceReference genericTypeInstanceReference) { // ^ ensures this.path.Count == old(this.path.Count); INestedTypeReference nestedType = genericTypeInstanceReference.AsNestedTypeReference; if (nestedType != null) { ITypeReference containingType = nestedType.GetContainingType(Context); if (containingType.AsGenericTypeInstanceReference != null || containingType.AsSpecializedNestedTypeReference != null) { this.Visit(nestedType.GetContainingType(Context)); } } this.Visit(genericTypeInstanceReference.GetGenericType(Context)); this.Visit(genericTypeInstanceReference.GetGenericArguments(Context)); }
/// <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); }
/// <summary> /// Given a field definition in the closure class, get its reference as will be used by the methods in the closure class. /// </summary> internal IFieldReference GetReferenceOfFieldUsedByPeers(IFieldDefinition fieldDef) { IFieldReference fieldReference = null; ITypeReference typeReference = this.ClosureDefinitionReference; ISpecializedNestedTypeReference nestedTypeRef = typeReference as ISpecializedNestedTypeReference; IGenericTypeInstanceReference genericTypeInstanceRef = typeReference as IGenericTypeInstanceReference; if (nestedTypeRef != null || genericTypeInstanceRef != null) { fieldReference = new SpecializedFieldReference() { ContainingType = typeReference, InternFactory = this.host.InternFactory, Name = fieldDef.Name, UnspecializedVersion = fieldDef, Type = fieldDef.Type }; } else { fieldReference = fieldDef; } return(fieldReference); }
public abstract void Visit(IGenericTypeInstanceReference genericTypeInstanceReference);
/// <summary> /// Performs some computation with the given generic type instance reference. /// </summary> public virtual void Visit(IGenericTypeInstanceReference genericTypeInstanceReference) { }
/// <summary> /// Traverses the children of the generic type instance reference. /// </summary> public virtual void TraverseChildren(IGenericTypeInstanceReference genericTypeInstanceReference) { Contract.Requires(genericTypeInstanceReference != null); this.TraverseChildren((ITypeReference)genericTypeInstanceReference); if (this.stopTraversal) return; this.Traverse(genericTypeInstanceReference.GenericType); if (this.stopTraversal) return; this.Traverse(genericTypeInstanceReference.GenericArguments); }
public void Visit(IGenericTypeInstanceReference genericTypeInstanceReference) { this.traverser.Traverse(genericTypeInstanceReference); }
private static IEnumerable<ITypeReference> AnalyzeGenericTypeReference(IGenericTypeInstanceReference typeReference) { return GetGenericType(typeReference) .Union(GetGenericTypeArguments(typeReference)); }
/// <summary> /// Performs some computation with the given generic type instance reference. /// </summary> public virtual void Visit(IGenericTypeInstanceReference genericTypeInstanceReference) { }
public override string GetTypeName(ITypeReference type, NameFormattingOptions formattingOptions) { Contract.Requires(type != null); Contract.Ensures(Contract.Result <string>() != null); if (type is Dummy) { return("Microsoft.Cci.DummyTypeReference"); } if ((formattingOptions & NameFormattingOptions.UseTypeKeywords) != 0) { switch (type.TypeCode) { case PrimitiveTypeCode.Boolean: return("Boolean"); case PrimitiveTypeCode.Char: return("Char"); case PrimitiveTypeCode.Float32: return("Float"); case PrimitiveTypeCode.Float64: return("Double"); case PrimitiveTypeCode.Int16: return("Short"); case PrimitiveTypeCode.Int32: return("Integer"); case PrimitiveTypeCode.Int64: return("Long"); case PrimitiveTypeCode.Int8: return("SByte"); case PrimitiveTypeCode.String: return("String"); case PrimitiveTypeCode.UInt16: return("UShort"); case PrimitiveTypeCode.UInt32: return("UInteger"); case PrimitiveTypeCode.UInt64: return("ULong"); case PrimitiveTypeCode.UInt8: return("Byte"); case PrimitiveTypeCode.Void: { Contract.Assert(false); throw new InvalidOperationException(); } case PrimitiveTypeCode.NotPrimitive: if (TypeHelper.TypesAreEquivalent(type, type.PlatformType.SystemDecimal)) { return("Decimal"); } if (TypeHelper.TypesAreEquivalent(type, type.PlatformType.SystemObject)) { return("Object"); } break; } } IArrayTypeReference /*?*/ arrayType = type as IArrayTypeReference; if (arrayType != null) { return(this.GetArrayTypeName(arrayType, formattingOptions)); } IFunctionPointerTypeReference /*?*/ functionPointerType = type as IFunctionPointerTypeReference; if (functionPointerType != null) { return(this.GetFunctionPointerTypeName(functionPointerType, formattingOptions)); } IGenericTypeParameterReference /*?*/ genericTypeParam = type as IGenericTypeParameterReference; if (genericTypeParam != null) { return(this.GetGenericTypeParameterName(genericTypeParam, formattingOptions)); } IGenericMethodParameterReference /*?*/ genericMethodParam = type as IGenericMethodParameterReference; if (genericMethodParam != null) { return(this.GetGenericMethodParameterName(genericMethodParam, formattingOptions)); } IGenericTypeInstanceReference /*?*/ genericInstance = type as IGenericTypeInstanceReference; if (genericInstance != null) { return(this.GetGenericTypeInstanceName(genericInstance, formattingOptions)); } INestedTypeReference /*?*/ ntTypeDef = type as INestedTypeReference; if (ntTypeDef != null) { return(this.GetNestedTypeName(ntTypeDef, formattingOptions)); } INamespaceTypeReference /*?*/ nsTypeDef = type as INamespaceTypeReference; if (nsTypeDef != null) { return(this.GetNamespaceTypeName(nsTypeDef, formattingOptions)); } IPointerTypeReference /*?*/ pointerType = type as IPointerTypeReference; if (pointerType != null) { return(this.GetPointerTypeName(pointerType, formattingOptions)); } IManagedPointerTypeReference /*?*/ managedPointerType = type as IManagedPointerTypeReference; if (managedPointerType != null) { return(this.GetManagedPointerTypeName(managedPointerType, formattingOptions)); } IModifiedTypeReference /*?*/ modifiedType = type as IModifiedTypeReference; if (modifiedType != null) { return(this.GetModifiedTypeName(modifiedType, formattingOptions)); } if (type.ResolvedType != type && !(type.ResolvedType is Dummy)) { return(this.GetTypeName(type.ResolvedType, formattingOptions)); } return("unknown type: " + type.GetType().ToString()); }
private static IEnumerable<ITypeReference> GetGenericTypeArguments(IGenericTypeInstanceReference typeReference) { return from a in typeReference.GenericArguments from t in a.GetAllRealTypeReferences() select t; }
public virtual void onMetadataElement(IGenericTypeInstanceReference genericTypeInstanceReference) { }
unsafe uint IMetaDataImport.GetTypeDefProps(uint td, IntPtr szTypeDef, uint cchTypeDef, out uint pchTypeDef, IntPtr pdwTypeDefFlags) { pchTypeDef = 0; if (td == 0) { return(0); } ITypeReference t = null; if ((td & 0xFF000000) == 0x1B000000) { t = this.writer.typeSpecList[(int)(td & 0xFFFFFF) - 1]; IGenericTypeInstanceReference gt = t as IGenericTypeInstanceReference; if (gt != null) { t = gt.GenericType; } } else { t = this.writer.typeDefList[(int)(td & 0xFFFFFF) - 1]; } string tName; uint parentToken = 0; if (this.lastTd == td) { tName = this.lastTName; parentToken = this.lastParentToken; } else { tName = TypeHelper.GetTypeName(t, NameFormattingOptions.UseGenericTypeNameSuffix | NameFormattingOptions.OmitContainingType); this.lastTd = td; this.lastTName = tName; ITypeReference bc = null; foreach (ITypeReference baseClassRef in t.ResolvedType.BaseClasses) { bc = baseClassRef; } if (bc != null) { parentToken = (uint)this.writer.GetTypeToken(bc); } this.lastParentToken = parentToken; } pchTypeDef = (uint)tName.Length; if (pchTypeDef >= cchTypeDef) { pchTypeDef = cchTypeDef - 1; } char *pTypeDef = (char *)szTypeDef.ToPointer(); for (int i = 0; i < pchTypeDef; i++) { *(pTypeDef + i) = tName[i]; } *(pTypeDef + pchTypeDef) = (char)0; uint *pFlags = (uint *)pdwTypeDefFlags.ToPointer(); *(pFlags) = PeWriter.GetTypeDefFlags(t.ResolvedType); return(parentToken); }
public override void TraverseChildren(IGenericTypeInstanceReference genericTypeInstanceReference) { base.TraverseChildren(genericTypeInstanceReference); }
private void EmitTypeLoadingCallsFor(IGenericTypeInstanceReference genericTypeInstance, string typeObjectName, SetOfUints alreadyLoadedTypes) { Contract.Requires(genericTypeInstance != null); Contract.Requires(typeObjectName != null); Contract.Requires(alreadyLoadedTypes != null); this.EmitSetTypeAndSetBaseClass(genericTypeInstance.ResolvedType, typeObjectName, alreadyLoadedTypes); this.sourceEmitter.EmitString("AllocateForGenericArguments("); this.sourceEmitter.EmitString(typeObjectName); this.sourceEmitter.EmitString(", " + genericTypeInstance.GenericType.GenericParameterCount + ");"); this.sourceEmitter.EmitNewLine(); int count = 0; foreach (var genericArgument in genericTypeInstance.GenericArguments) { Contract.Assume(genericArgument != null); this.sourceEmitter.EmitString("SetGenericArgument("); this.sourceEmitter.EmitString(typeObjectName); this.sourceEmitter.EmitString(", "); this.sourceEmitter.EmitString(this.GetMangledTypeName(genericArgument)+"_typeObject"); this.sourceEmitter.EmitString(", " + count + ");"); this.sourceEmitter.EmitNewLine(); count++; } }
/// <summary> /// Rewrites the given generic type instance reference. /// </summary> public virtual ITypeReference Rewrite(IGenericTypeInstanceReference genericTypeInstanceReference) { return genericTypeInstanceReference; }
public override void Visit(IGenericTypeInstanceReference genericTypeInstanceReference) { if(Process(genericTypeInstanceReference)){visitor.Visit(genericTypeInstanceReference);} base.Visit(genericTypeInstanceReference); }
public virtual void onMetadataElement(IGenericTypeInstanceReference genericTypeInstanceReference) { }
public override void Visit(IGenericTypeInstanceReference genericTypeInstanceReference) { var template = genericTypeInstanceReference.GenericType; var specializedNestedType = template as ISpecializedNestedTypeReference; if (specializedNestedType != null) template = specializedNestedType.UnspecializedVersion; var templateType = this.mapper.GetType(template); var consolidatedArguments = new List<Type>(); this.GetConsolidatedTypeArguments(consolidatedArguments, genericTypeInstanceReference); this.result = templateType.MakeGenericType(consolidatedArguments.ToArray()); }
public override void TraverseChildren(IGenericTypeInstanceReference genericTypeInstanceReference) { MethodEnter(genericTypeInstanceReference); base.TraverseChildren(genericTypeInstanceReference); MethodExit(); }
private static IEnumerable<ITypeReference> GetGenericType(IGenericTypeInstanceReference typeReference) { yield return typeReference.GenericType; }
public void Visit(IGenericTypeInstanceReference genericTypeInstanceReference) { throw new NotImplementedException(); }
public override void TraverseChildren(IGenericTypeInstanceReference genericTypeInstanceReference) { base.TraverseChildren(genericTypeInstanceReference); }
/// <summary> /// Performs some computation with the given generic type instance reference. /// </summary> public void Visit(IGenericTypeInstanceReference genericTypeInstanceReference) { var mfmv = this.validator.currentModule.MetadataFormatMajorVersion; if (mfmv < 2) this.ReportError(MetadataError.InvalidMetadataFormatVersionForGenerics, genericTypeInstanceReference, mfmv.ToString()); this.Visit((ITypeReference)genericTypeInstanceReference); }
/// <summary> /// Traverses the generic type instance reference. /// </summary> public void Traverse(IGenericTypeInstanceReference genericTypeInstanceReference) { Contract.Requires(genericTypeInstanceReference != null); if (!this.objectsThatHaveAlreadyBeenTraversed.Add(genericTypeInstanceReference)) return; if (this.preorderVisitor != null) this.preorderVisitor.Visit(genericTypeInstanceReference); if (this.stopTraversal) return; this.TraverseChildren(genericTypeInstanceReference); if (this.stopTraversal) return; if (this.postorderVisitor != null) this.postorderVisitor.Visit(genericTypeInstanceReference); }
public override void Visit(IGenericTypeInstanceReference genericTypeInstanceReference) { allElements.Add(new InvokInfo(Traverser, "IGenericTypeInstanceReference", genericTypeInstanceReference)); }
//^ ensures this.path.Count == old(this.path.Count); /// <summary> /// Performs some computation with the given generic type instance reference. /// </summary> /// <param name="genericTypeInstanceReference"></param> public virtual void Visit(IGenericTypeInstanceReference genericTypeInstanceReference) { if (this.stopTraversal) return; //^ int oldCount = this.path.Count; this.path.Push(genericTypeInstanceReference); this.Visit(genericTypeInstanceReference.GenericType); this.Visit(genericTypeInstanceReference.GenericArguments); //^ assume this.path.Count == oldCount; //True because all of the virtual methods of this class promise not decrease this.path.Count. this.path.Pop(); }
public override void Visit(IGenericTypeInstanceReference genericTypeInstanceReference) { genericTypeInstanceReference.GenericType.ResolvedType.Dispatch(this); foreach (var genArg in genericTypeInstanceReference.GenericArguments) { Contract.Assume(genArg != null); genArg.ResolvedType.Dispatch(this); } }
/// <summary> /// Performs some computation with the given generic type instance reference. /// </summary> public void Visit(IGenericTypeInstanceReference genericTypeInstanceReference) { this.Visit((ITypeReference)genericTypeInstanceReference); }
public abstract void Visit(IGenericTypeInstanceReference genericTypeInstanceReference);
/// <summary> /// Use this routine, rather than ITypeReference.Dispatch, to call the appropriate derived overload of an ITypeReference. /// The former routine will call Visit(INamespaceTypeDefinition) rather than Visit(INamespaceTypeReference), etc., /// in the case where a definition is used as a reference to itself. /// </summary> /// <param name="typeReference">A reference to a type definition. Note that a type definition can serve as a reference to itself.</param> protected void DispatchAsReference(ITypeReference typeReference) { INamespaceTypeReference namespaceTypeReference = typeReference.AsNamespaceTypeReference; if (namespaceTypeReference != null) { this.Visit(namespaceTypeReference); return; } IGenericTypeInstanceReference genericTypeInstanceReference = typeReference.AsGenericTypeInstanceReference; if (genericTypeInstanceReference != null) { this.Visit(genericTypeInstanceReference); return; } INestedTypeReference nestedTypeReference = typeReference.AsNestedTypeReference; if (nestedTypeReference != null) { this.Visit(nestedTypeReference); return; } IArrayTypeReference arrayTypeReference = typeReference as IArrayTypeReference; if (arrayTypeReference != null) { this.Visit(arrayTypeReference); return; } IGenericTypeParameterReference genericTypeParameterReference = typeReference.AsGenericTypeParameterReference; if (genericTypeParameterReference != null) { this.Visit(genericTypeParameterReference); return; } IGenericMethodParameterReference genericMethodParameterReference = typeReference.AsGenericMethodParameterReference; if (genericMethodParameterReference != null) { this.Visit(genericMethodParameterReference); return; } IPointerTypeReference pointerTypeReference = typeReference as IPointerTypeReference; if (pointerTypeReference != null) { this.Visit(pointerTypeReference); return; } IModifiedTypeReference modifiedTypeReference = typeReference as IModifiedTypeReference; if (modifiedTypeReference != null) { this.Visit(modifiedTypeReference); return; } }
internal static string TypeDefinition(IUnit currentUnit, ITypeDefinition typeDefinition) { if (typeDefinition == Dummy.Type) { return("###DummyType###"); } PrimitiveTypeCode ptc = typeDefinition.TypeCode; switch (ptc) { case PrimitiveTypeCode.Boolean: return("bool"); case PrimitiveTypeCode.Char: return("char"); case PrimitiveTypeCode.Int8: return("int8"); case PrimitiveTypeCode.Float32: return("float32"); case PrimitiveTypeCode.Float64: return("float64"); case PrimitiveTypeCode.Int16: return("int16"); case PrimitiveTypeCode.Int32: return("int32"); case PrimitiveTypeCode.Int64: return("int64"); case PrimitiveTypeCode.IntPtr: return("native int"); case PrimitiveTypeCode.UInt8: return("unsigned int8"); case PrimitiveTypeCode.UInt16: return("unsigned int16"); case PrimitiveTypeCode.UInt32: return("unsigned int32"); case PrimitiveTypeCode.UInt64: return("unsigned int64"); case PrimitiveTypeCode.UIntPtr: return("native unsigned int"); case PrimitiveTypeCode.Void: return("void"); } INamespaceTypeDefinition namespaceType = typeDefinition as INamespaceTypeDefinition; if (namespaceType != null) { bool wasRoot; StringBuilder sb = new StringBuilder(Helper.ModuleQualifiedUnitNamespace(currentUnit, (IUnitNamespace)namespaceType.ContainingNamespace, out wasRoot)); if (!wasRoot) { sb.Append("."); } sb.Append(namespaceType.Name.Value); if (namespaceType.GenericParameterCount != 0) { sb.Append("`"); sb.Append(namespaceType.GenericParameterCount); } return(sb.ToString()); } INestedTypeDefinition nestedTypeDefinition = typeDefinition as INestedTypeDefinition; if (nestedTypeDefinition != null) { StringBuilder sb = new StringBuilder(Helper.TypeDefinition(currentUnit, nestedTypeDefinition.ContainingTypeDefinition)); sb.Append("/"); sb.Append(nestedTypeDefinition.Name.Value); if (nestedTypeDefinition.GenericParameterCount != 0) { sb.Append("`"); sb.Append(nestedTypeDefinition.GenericParameterCount); } return(sb.ToString()); } IGenericTypeInstanceReference genericTypeInstance = typeDefinition as IGenericTypeInstanceReference; if (genericTypeInstance != null) { StringBuilder sb = new StringBuilder(Helper.TypeDefinition(currentUnit, genericTypeInstance.GenericType.ResolvedType)); sb.Append("<"); bool isNotFirst = false; foreach (ITypeReference typeReference in genericTypeInstance.GenericArguments) { if (isNotFirst) { sb.Append(","); } isNotFirst = true; sb.Append(Helper.TypeDefinition(currentUnit, typeReference.ResolvedType)); } sb.Append(">"); return(sb.ToString()); } IPointerTypeReference pointerType = typeDefinition as IPointerTypeReference; if (pointerType != null) { StringBuilder sb = new StringBuilder(Helper.TypeDefinition(currentUnit, pointerType.TargetType.ResolvedType)); sb.Append("*"); return(sb.ToString()); } IArrayTypeReference arrayType = typeDefinition as IArrayTypeReference; if (arrayType != null) { StringBuilder sb = new StringBuilder(Helper.TypeDefinition(currentUnit, arrayType.ElementType.ResolvedType)); sb.Append("["); if (!arrayType.IsVector) { if (arrayType.Rank == 1) { sb.Append("*"); } else { for (int i = 1; i < arrayType.Rank; ++i) { sb.Append(","); } } } sb.Append("]"); return(sb.ToString()); } IGenericTypeParameter genericTypeParameter = typeDefinition as IGenericTypeParameter; if (genericTypeParameter != null) { return("!" + genericTypeParameter.Index); } IGenericMethodParameter genericMethodParameter = typeDefinition as IGenericMethodParameter; if (genericMethodParameter != null) { return("!!" + genericMethodParameter.Index); } return("!?!ErrorType!?!"); }
public override void TraverseChildren(IGenericTypeInstanceReference genericTypeInstanceReference) { MethodEnter(genericTypeInstanceReference); base.TraverseChildren(genericTypeInstanceReference); MethodExit(); }
public static bool IsNullableValueType(this IGenericTypeInstanceReference genericType) { return(genericType.GenericType.FullName().StartsWith("System.Nullable")); }
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); } }
/// <summary> /// Traverses the children of the generic type instance reference. /// </summary> public virtual void TraverseChildren(IGenericTypeInstanceReference genericTypeInstanceReference) { this.TraverseChildren((ITypeReference)genericTypeInstanceReference); if (this.stopTraversal) return; this.Traverse(genericTypeInstanceReference.GenericType); if (this.stopTraversal) return; this.Traverse(genericTypeInstanceReference.GenericArguments); }