public override void Visit(IModifiedTypeReference modifiedTypeReference) { if (Process(modifiedTypeReference)) { visitor.Visit(modifiedTypeReference); } base.Visit(modifiedTypeReference); }
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); } } }
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 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); }
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); }
/// <summary> /// Returns true if the field signature has the System.Runtime.CompilerServices.IsVolatile modifier. /// Such fields should only be accessed with volatile reads and writes. /// </summary> /// <param name="field">The field to inspect for the System.Runtime.CompilerServices.IsVolatile modifier.</param> public static bool IsVolatile(IFieldDefinition field) { IModifiedTypeReference /*?*/ modifiedTypeReference = field.Type as IModifiedTypeReference; if (modifiedTypeReference == null) { return(false); } uint isVolatileKey = modifiedTypeReference.PlatformType.SystemRuntimeCompilerServicesIsVolatile.InternedKey; foreach (ICustomModifier customModifier in modifiedTypeReference.CustomModifiers) { if (customModifier.Modifier.InternedKey == isVolatileKey) { return(true); } } return(false); }
/// <summary> /// Traverses the modified type reference. /// </summary> public void Traverse(IModifiedTypeReference modifiedTypeReference) { Contract.Requires(modifiedTypeReference != null); if (!this.objectsThatHaveAlreadyBeenTraversed.Add(modifiedTypeReference)) return; if (this.preorderVisitor != null) this.preorderVisitor.Visit(modifiedTypeReference); if (this.stopTraversal) return; this.TraverseChildren(modifiedTypeReference); if (this.stopTraversal) return; if (this.postorderVisitor != null) this.postorderVisitor.Visit(modifiedTypeReference); }
/// <summary> /// Performs some computation with the given modified type reference. /// </summary> public virtual void Visit(IModifiedTypeReference modifiedTypeReference) { }
public virtual void Visit(IModifiedTypeReference modifiedTypeReference) { this.Visit(modifiedTypeReference.CustomModifiers); this.Visit(modifiedTypeReference.UnmodifiedType); }
public override void Visit(IModifiedTypeReference modifiedTypeReference) { modifiedTypeReference.UnmodifiedType.ResolvedType.Dispatch(this); this.Visit(modifiedTypeReference.CustomModifiers); }
public override void Visit(IModifiedTypeReference modifiedTypeReference) { //Sytem.Reflection cannot model modified typeBuilder references. Just strip the modifiers. modifiedTypeReference.UnmodifiedType.Dispatch(this); }
public override void TraverseChildren(IModifiedTypeReference modifiedTypeReference) { MethodEnter(modifiedTypeReference); base.TraverseChildren(modifiedTypeReference); MethodExit(); }
public override void TraverseChildren(IModifiedTypeReference modifiedTypeReference) { base.TraverseChildren(modifiedTypeReference); }
//^ ensures this.path.Count == old(this.path.Count); /// <summary> /// Performs some computation with the given modified type reference. /// </summary> /// <param name="modifiedTypeReference"></param> public virtual void Visit(IModifiedTypeReference modifiedTypeReference) { if (this.stopTraversal) return; //^ int oldCount = this.path.Count; this.path.Push(modifiedTypeReference); this.Visit(modifiedTypeReference.CustomModifiers); this.Visit(modifiedTypeReference.UnmodifiedType); //^ assume this.path.Count == oldCount+1; //True because all of the virtual methods of this class promise not decrease this.path.Count. this.path.Pop(); }
/// <summary> /// Traverses the children of the modified type reference. /// </summary> public virtual void TraverseChildren(IModifiedTypeReference modifiedTypeReference) { Contract.Requires(modifiedTypeReference != null); this.TraverseChildren((ITypeReference)modifiedTypeReference); if (this.stopTraversal) return; this.Traverse(modifiedTypeReference.CustomModifiers); if (this.stopTraversal) return; this.Traverse(modifiedTypeReference.UnmodifiedType); }
public override void Visit(IModifiedTypeReference modifiedTypeReference) { if(Process(modifiedTypeReference)){visitor.Visit(modifiedTypeReference);} base.Visit(modifiedTypeReference); }
/// <summary> /// Rewrites the given modified type reference. /// </summary> public virtual IModifiedTypeReference Rewrite(IModifiedTypeReference modifiedTypeReference) { return modifiedTypeReference; }
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()); }
public override void Visit(IModifiedTypeReference modifiedTypeReference) { allElements.Add(new InvokInfo(Traverser, "IModifiedTypeReference", modifiedTypeReference)); }
public void Visit(IModifiedTypeReference modifiedTypeReference) { this.traverser.Traverse(modifiedTypeReference); }
/// <summary> /// Performs some computation with the given modified type reference. /// </summary> public void Visit(IModifiedTypeReference modifiedTypeReference) { this.Visit((ITypeReference)modifiedTypeReference); }
public virtual void onMetadataElement(IModifiedTypeReference modifiedTypeReference) { }
/// <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; } }
public void Visit(IModifiedTypeReference modifiedTypeReference) { throw new NotImplementedException(); }
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 modified type reference. /// </summary> public virtual void TraverseChildren(IModifiedTypeReference modifiedTypeReference) { this.TraverseChildren((ITypeReference)modifiedTypeReference); if (this.stopTraversal) return; this.Traverse(modifiedTypeReference.CustomModifiers); if (this.stopTraversal) return; this.Traverse(modifiedTypeReference.UnmodifiedType); }