public MethodDefinition(string name, MethodAttributes attributes, TypeReference returnType) : base(name, returnType) { this.attributes = (ushort)attributes; this.HasThis = !this.IsStatic; this.token = new MetadataToken(TokenType.Method); }
public OptionalModifierType(TypeReference modifierType, TypeReference type) : base(type) { Mixin.CheckModifier(modifierType, type); this.modifier_type = modifierType; this.etype = MD.ElementType.CModOpt; }
internal ParameterReference(string name, TypeReference parameterType) { if (parameterType == null) throw new ArgumentNullException("parameterType"); this.name = name ?? string.Empty; this.parameter_type = parameterType; }
public MethodReference(string name, TypeReference returnType, TypeReference declaringType) : this(name, returnType) { if (declaringType == null) throw new ArgumentNullException("declaringType"); this.DeclaringType = declaringType; }
protected EventReference(string name, TypeReference eventType) : base(name) { if (eventType == null) throw new ArgumentNullException("eventType"); event_type = eventType; }
public CallSite(TypeReference returnType) : this() { if (returnType == null) throw new ArgumentNullException("returnType"); this.signature.ReturnType = returnType; }
internal PropertyReference(string name, TypeReference propertyType) : base(name) { if (propertyType == null) throw new ArgumentNullException("propertyType"); property_type = propertyType; }
public FieldReference(string name, TypeReference fieldType, TypeReference declaringType) : this(name, fieldType) { if (declaringType == null) throw new ArgumentNullException("declaringType"); this.DeclaringType = declaringType; }
public FieldReference(string name, TypeReference fieldType) : base(name) { if (fieldType == null) throw new ArgumentNullException("fieldType"); this.field_type = fieldType; this.token = new MetadataToken(TokenType.MemberRef); }
public MethodReference(string name, TypeReference returnType) : base(name) { if (returnType == null) throw new ArgumentNullException("returnType"); this.return_type = new MethodReturnType(this); this.return_type.ReturnType = returnType; this.token = new MetadataToken(TokenType.MemberRef); }
public void AddTypeReference(TypeReference type) { TypeReferences[type.token.RID - 1] = type; }
public ArrayType(TypeReference type, int rank) : this(type) { Mixin.CheckType(type); if (rank == 1) return; dimensions = new Collection<ArrayDimension>(rank); for (int i = 0; i < rank; i++) dimensions.Add(new ArrayDimension()); this.etype = MD.ElementType.Array; }
public PinnedType(TypeReference type) : base(type) { Mixin.CheckType(type); this.etype = MD.ElementType.Pinned; }
TypeReference ImportTypeSpecification(TypeReference type, ImportGenericContext context) { switch (type.etype) { case ElementType.SzArray: var vector = (ArrayType)type; return new ArrayType(ImportType(vector.ElementType, context)); case ElementType.Ptr: var pointer = (PointerType)type; return new PointerType(ImportType(pointer.ElementType, context)); case ElementType.ByRef: var byref = (ByReferenceType)type; return new ByReferenceType(ImportType(byref.ElementType, context)); case ElementType.Pinned: var pinned = (PinnedType)type; return new PinnedType(ImportType(pinned.ElementType, context)); case ElementType.Sentinel: var sentinel = (SentinelType)type; return new SentinelType(ImportType(sentinel.ElementType, context)); case ElementType.CModOpt: var modopt = (OptionalModifierType)type; return new OptionalModifierType( ImportType(modopt.ModifierType, context), ImportType(modopt.ElementType, context)); case ElementType.CModReqD: var modreq = (RequiredModifierType)type; return new RequiredModifierType( ImportType(modreq.ModifierType, context), ImportType(modreq.ElementType, context)); case ElementType.Array: var array = (ArrayType)type; var imported_array = new ArrayType(ImportType(array.ElementType, context)); if (array.IsVector) return imported_array; var dimensions = array.Dimensions; var imported_dimensions = imported_array.Dimensions; imported_dimensions.Clear(); for (int i = 0; i < dimensions.Count; i++) { var dimension = dimensions[i]; imported_dimensions.Add(new ArrayDimension(dimension.LowerBound, dimension.UpperBound)); } return imported_array; case ElementType.GenericInst: var instance = (GenericInstanceType)type; var element_type = ImportType(instance.ElementType, context); var imported_instance = new GenericInstanceType(element_type); var arguments = instance.GenericArguments; var imported_arguments = imported_instance.GenericArguments; for (int i = 0; i < arguments.Count; i++) imported_arguments.Add(ImportType(arguments[i], context)); return imported_instance; case ElementType.Var: var var_parameter = (GenericParameter)type; return context.TypeParameter(type.DeclaringType.FullName, var_parameter.Position); case ElementType.MVar: var mvar_parameter = (GenericParameter)type; return context.MethodParameter(mvar_parameter.DeclaringMethod.Name, mvar_parameter.Position); } throw new NotSupportedException(type.etype.ToString()); }
public ArrayType(TypeReference type) : base(type) { Mixin.CheckType(type); this.etype = MD.ElementType.Array; }
public TypeReference ImportType(Type type, ImportGenericContext context, ImportGenericKind import_kind) { if (IsTypeSpecification(type) || ImportOpenGenericType(type, import_kind)) return ImportTypeSpecification(type, context); var reference = new TypeReference( string.Empty, type.Name, module, ImportScope(type.Assembly), type.IsValueType); reference.etype = ImportElementType(type); if (IsNestedType(type)) reference.DeclaringType = ImportType(type.DeclaringType, context, import_kind); else reference.Namespace = type.Namespace ?? string.Empty; if (type.IsGenericType) ImportGenericParameters(reference, type.GetGenericArguments()); return reference; }
public TypeReference ImportType(TypeReference type, ImportGenericContext context) { if (type.IsTypeSpecification()) return ImportTypeSpecification(type, context); var reference = new TypeReference( type.Namespace, type.Name, module, ImportScope(type.Scope), type.IsValueType); MetadataSystem.TryProcessPrimitiveTypeReference(reference); if (type.IsNested) reference.DeclaringType = ImportType(type.DeclaringType, context); if (type.HasGenericParameters) ImportGenericParameters(reference, type); return reference; }
static bool AreSame(TypeReference a, TypeReference b) { if (ReferenceEquals(a, b)) return true; if (a == null || b == null) return false; if (a.etype != b.etype) return false; if (a.IsGenericParameter) return AreSame((GenericParameter)a, (GenericParameter)b); if (a.IsTypeSpecification()) return AreSame((TypeSpecification)a, (TypeSpecification)b); if (a.Name != b.Name || a.Namespace != b.Namespace) return false; //TODO: check scope return AreSame(a.DeclaringType, b.DeclaringType); }
static TypeDefinition GetType(ModuleDefinition module, TypeReference reference) { var type = GetTypeDefinition(module, reference); if (type != null) return type; if (!module.HasExportedTypes) return null; var exported_types = module.ExportedTypes; for (int i = 0; i < exported_types.Count; i++) { var exported_type = exported_types[i]; if (exported_type.Name != reference.Name) continue; if (exported_type.Namespace != reference.Namespace) continue; return exported_type.Resolve(); } return null; }
public SentinelType(TypeReference type) : base(type) { Mixin.CheckType(type); this.etype = MD.ElementType.Sentinel; }
public static void CheckModifier(TypeReference modifierType, TypeReference type) { if (modifierType == null) throw new ArgumentNullException("modifierType"); if (type == null) throw new ArgumentNullException("type"); }
public FieldDefinition(string name, FieldAttributes attributes, TypeReference fieldType) : base(name, fieldType) { this.attributes = (ushort)attributes; }
internal ParameterDefinition(TypeReference parameterType, IMethodSignature method) : this(string.Empty, ParameterAttributes.None, parameterType) { this.method = method; }
public ParameterDefinition(string name, ParameterAttributes attributes, TypeReference parameterType) : base(name, parameterType) { this.attributes = (ushort)attributes; this.token = new MetadataToken(TokenType.Param); }
public ParameterDefinition(TypeReference parameterType) : this(string.Empty, ParameterAttributes.None, parameterType) { }
public SecurityAttribute(TypeReference attributeType) { this.attribute_type = attributeType; }
public RequiredModifierType(TypeReference modifierType, TypeReference type) : base(type) { Mixin.CheckModifier(modifierType, type); this.modifier_type = modifierType; this.etype = MD.ElementType.CModReqD; }
static bool TryGetPrimitiveData(TypeReference type, out Row<ElementType, bool> primitive_data) { if (primitive_value_types == null) InitializePrimitives(); return primitive_value_types.TryGetValue(type.Name, out primitive_data); }
public static void TryProcessPrimitiveTypeReference(TypeReference type) { if (type.Namespace != "System") return; var scope = type.scope; if (scope == null || scope.MetadataScopeType != MetadataScopeType.AssemblyNameReference) return; Row<ElementType, bool> primitive_data; if (!TryGetPrimitiveData(type, out primitive_data)) return; type.etype = primitive_data.Col1; type.IsValueType = primitive_data.Col2; }
static TypeDefinition GetTypeDefinition(ModuleDefinition module, TypeReference type) { if (!type.IsNested) return module.GetType(type.Namespace, type.Name); var declaring_type = type.DeclaringType.Resolve(); if (declaring_type == null) return null; return declaring_type.GetNestedType(type.TypeFullName()); }