public OptionalModifierType (TypeReference modifierType, TypeReference type) : base (type) { Mixin.CheckModifier (modifierType, type); this.modifier_type = modifierType; this.etype = MD.ElementType.CModOpt; }
public static TypeDefinition Resolve (IAssemblyResolver resolver, TypeReference type) { type = type.GetElementType (); var scope = type.Scope; switch (scope.MetadataScopeType) { case MetadataScopeType.AssemblyNameReference: var assembly = resolver.Resolve ((AssemblyNameReference) scope); if (assembly == null) return null; return GetType (resolver, assembly.MainModule, type); case MetadataScopeType.ModuleDefinition: return GetType (resolver, (ModuleDefinition) scope, type); case MetadataScopeType.ModuleReference: var modules = type.Module.Assembly.Modules; var module_ref = (ModuleReference) scope; for (int i = 0; i < modules.Count; i++) { var netmodule = modules [i]; if (netmodule.Name == module_ref.Name) return GetType (resolver, netmodule, type); } break; } throw new NotSupportedException (); }
protected EventReference (string name, TypeReference eventType) : base (name) { if (eventType == null) throw new ArgumentNullException ("eventType"); event_type = eventType; }
internal ParameterReference (string name, TypeReference parameterType) { if (parameterType == null) throw new ArgumentNullException ("parameterType"); this.name = name ?? string.Empty; this.parameter_type = parameterType; }
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 RequiredModifierType (TypeReference modifierType, TypeReference type) : base (type) { Mixin.CheckModifier (modifierType, type); this.modifier_type = modifierType; this.etype = MD.ElementType.CModReqD; }
public PropertyDefinition (string name, PropertyAttributes attributes, TypeReference propertyType) : base (name, propertyType) { this.attributes = (ushort) attributes; this.token = new MetadataToken (TokenType.Property); }
static TypeDefinition GetType (IAssemblyResolver resolver, ModuleDefinition module, TypeReference reference) { var type = GetType (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 TypeDefinition (string @namespace, string name, TypeAttributes attributes, TypeReference baseType) : this (@namespace, name, attributes) { this.BaseType = baseType; }
public TypeReference ImportType (TypeReference type, IGenericContext context) { if (type.IsTypeSpecification ()) return ImportTypeSpecification (type, context); var reference = new TypeReference ( type.Namespace, type.Name, module, ImportScope (type.Scope), type.IsValueType); MetadataSystem.TryProcessPrimitiveType (reference); if (type.IsNested) reference.DeclaringType = ImportType (type.DeclaringType, context); if (type.HasGenericParameters) ImportGenericParameters (reference, type); return reference; }
public TypeReference ImportType (Type type, IGenericContext 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; if (type.IsGenericType) ImportGenericParameters (reference, type.GetGenericArguments ()); return reference; }
private TypeSymbol ResolveType(TypeReference type) { int arrayDimensions = 0; while (type is ArrayType) { arrayDimensions++; type = ((ArrayType)type).ElementType; } GenericInstanceType genericType = type as GenericInstanceType; if (genericType != null) { type = genericType.ElementType; } string name = type.FullName; if (String.CompareOrdinal(name, "System.ValueType") == 0) { // Ignore this type - it is the base class for enums, and other primitive types // but we don't import it since it is not useful in script return null; } TypeSymbol typeSymbol; GenericParameter genericParameter = type as GenericParameter; if (genericParameter != null) { typeSymbol = new GenericParameterSymbol(genericParameter.Position, genericParameter.Name, (genericParameter.Owner.GenericParameterType == GenericParameterType.Type), _symbols.GlobalNamespace); } else { typeSymbol = (TypeSymbol)((ISymbolTable)_symbols).FindSymbol(name, null, SymbolFilter.Types); if (typeSymbol == null) { _errorHandler.ReportError("Unable to resolve referenced type '" + name + "'. Make sure all needed assemblies have been explicitly referenced.", String.Empty); _resolveError = true; } } if (genericType != null) { List<TypeSymbol> typeArgs = new List<TypeSymbol>(); foreach (TypeReference argTypeRef in genericType.GenericArguments) { TypeSymbol argType = ResolveType(argTypeRef); typeArgs.Add(argType); } typeSymbol = _symbols.CreateGenericTypeSymbol(typeSymbol, typeArgs); Debug.Assert(typeSymbol != null); } if (arrayDimensions != 0) { for (int i = 0; i < arrayDimensions; i++) { typeSymbol = _symbols.CreateArrayTypeSymbol(typeSymbol); } } return typeSymbol; }
public ParameterDefinition (TypeReference parameterType) : this (string.Empty, ParameterAttributes.None, parameterType) { }
public FieldDefinition (string name, FieldAttributes attributes, TypeReference fieldType) : base (name, fieldType) { this.attributes = (ushort) attributes; }
public CustomAttributeArgument (TypeReference type, object value) { Mixin.CheckType (type); this.type = type; this.value = value; }
public MethodReference (string name, TypeReference returnType, TypeReference declaringType) : this (name, returnType) { if (declaringType == null) throw new ArgumentNullException ("declaringType"); this.DeclaringType = declaringType; }
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 ByReferenceType (TypeReference type) : base (type) { Mixin.CheckType (type); this.etype = MD.ElementType.ByRef; }
public static void CheckModifier (TypeReference modifierType, TypeReference type) { if (modifierType == null) throw new ArgumentNullException ("modifierType"); if (type == null) throw new ArgumentNullException ("type"); }
public ParameterDefinition (string name, ParameterAttributes attributes, TypeReference parameterType) : base (name, parameterType) { this.attributes = (ushort) attributes; this.token = new MetadataToken (TokenType.Param); }
static TypeDefinition GetType (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.Name); }
public FieldDefinition(string name, FieldAttributes attributes, TypeReference fieldType) : base(name, fieldType) { this.attributes = (ushort)attributes; }
TypeReference ImportTypeSpecification (TypeReference type, IGenericContext 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: if (context == null || context.Type == null) throw new InvalidOperationException (); return ((TypeReference) context.Type).GetElementType ().GenericParameters [((GenericParameter) type).Position]; case ElementType.MVar: if (context == null || context.Method == null) throw new InvalidOperationException (); return context.Method.GenericParameters [((GenericParameter) type).Position]; } throw new NotSupportedException (type.etype.ToString ()); }
public PointerType (TypeReference type) : base (type) { Mixin.CheckType (type); this.etype = MD.ElementType.Ptr; }
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 static void TryProcessPrimitiveType (TypeReference type) { var scope = type.scope; if (scope == null) return; if (scope.MetadataScopeType != MetadataScopeType.AssemblyNameReference) return; if (scope.Name != "mscorlib") return; if (type.Namespace != "System") return; if (primitive_value_types == null) InitializePrimitives (); Row<ElementType, bool> primitive_data; if (!primitive_value_types.TryGetValue (type.Name, out primitive_data)) return; type.etype = primitive_data.Col1; type.IsValueType = primitive_data.Col2; }
public CallSite (TypeReference returnType) : this () { if (returnType == null) throw new ArgumentNullException ("returnType"); this.signature.ReturnType = returnType; }
public void AddTypeReference (TypeReference type) { TypeReferences [type.token.RID - 1] = type; }
public TypeDefinition(string @namespace, string name, TypeAttributes attributes, TypeReference baseType) : this(@namespace, name, attributes) { this.BaseType = baseType; }
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); }