static public Type float_type;
static public Type double_type;
static public Type char_type;
- static public Type char_ptr_type;
static public Type short_type;
static public Type decimal_type;
static public Type bool_type;
static public Type ienumerator_type;
static public Type ienumerable_type;
static public Type idisposable_type;
- static public Type default_member_type;
static public Type iasyncresult_type;
static public Type asynccallback_type;
static public Type intptr_type;
static public Type runtime_field_handle_type;
static public Type runtime_argument_handle_type;
static public Type attribute_type;
- static public Type attribute_usage_type;
- static public Type decimal_constant_attribute_type;
- static public Type dllimport_type;
- static public Type methodimpl_attr_type;
-#if !NET_2_0
- static public Type marshal_as_attr_type;
-#endif
- static public Type param_array_type;
static public Type void_ptr_type;
- static public Type indexer_name_type;
static public Type exception_type;
- static public Type obsolete_attribute_type;
- static public Type conditional_attribute_type;
- static public Type in_attribute_type;
- static public Type out_attribute_type;
- static public Type extension_attribute_type;
- static public Type default_parameter_value_attribute_type;
static public Type anonymous_method_type;
- static public Type cls_compliant_attribute_type;
static public Type typed_reference_type;
static public Type arg_iterator_type;
static public Type mbr_type;
- static public Type struct_layout_attribute_type;
- static public Type field_offset_attribute_type;
- static public Type security_attr_type;
- static public Type required_attr_type;
- static public Type guid_attr_type;
- static public Type assembly_culture_attribute_type;
- static public Type assembly_version_attribute_type;
- static public Type coclass_attr_type;
- static public Type comimport_attr_type;
public static Type runtime_helpers_type;
- public static Type internals_visible_attr_type;
//
// C# 2.0
//
- static internal Type fixed_buffer_attr_type;
- static internal Type default_charset_type;
- static internal Type type_forwarder_attr_type;
static internal Type isvolatile_type;
- static public Type activator_type;
static public Type generic_ilist_type;
static public Type generic_icollection_type;
static public Type generic_ienumerator_type;
static public MethodInfo void_initializearray_array_fieldhandle;
static public MethodInfo delegate_combine_delegate_delegate;
static public MethodInfo delegate_remove_delegate_delegate;
- static public MethodInfo int_get_offset_to_string_data;
+ static public PropertyInfo int_get_offset_to_string_data;
static public MethodInfo int_interlocked_compare_exchange;
static public PropertyInfo ienumerator_getcurrent;
public static MethodInfo methodbase_get_type_from_handle;
public static MethodInfo methodbase_get_type_from_handle_generic;
public static MethodInfo fieldinfo_get_field_from_handle;
static public MethodInfo activator_create_instance;
-
+
//
- // The attribute constructors.
+ // The constructors.
//
static public ConstructorInfo void_decimal_ctor_five_args;
static public ConstructorInfo void_decimal_ctor_int_arg;
- static public ConstructorInfo default_member_ctor;
- static public ConstructorInfo decimal_constant_attribute_ctor;
- static internal ConstructorInfo struct_layout_attribute_ctor;
- static public ConstructorInfo field_offset_attribute_ctor;
- public static ConstructorInfo invalid_operation_exception_ctor;
-
- static public CustomAttributeBuilder param_array_attr;
- static CustomAttributeBuilder compiler_generated_attr;
- static CustomAttributeBuilder debugger_hidden_attr;
-
- // C# 2.0
- static internal ConstructorInfo fixed_buffer_attr_ctor;
-
- // C# 3.0
- static internal CustomAttributeBuilder extension_attribute_attr;
static PtrHashtable builder_to_declspace;
events = null;
type_hash = null;
propertybuilder_to_property = null;
- assembly_internals_vis_attrs = null;
TypeHandle.CleanUp ();
}
//
static void InitExpressionTypes ()
{
- system_object_expr = new TypeLookupExpression ("System.Object");
- system_string_expr = new TypeLookupExpression ("System.String");
- system_boolean_expr = new TypeLookupExpression ("System.Boolean");
- system_decimal_expr = new TypeLookupExpression ("System.Decimal");
- system_single_expr = new TypeLookupExpression ("System.Single");
- system_double_expr = new TypeLookupExpression ("System.Double");
- system_sbyte_expr = new TypeLookupExpression ("System.SByte");
- system_byte_expr = new TypeLookupExpression ("System.Byte");
- system_int16_expr = new TypeLookupExpression ("System.Int16");
- system_uint16_expr = new TypeLookupExpression ("System.UInt16");
- system_int32_expr = new TypeLookupExpression ("System.Int32");
- system_uint32_expr = new TypeLookupExpression ("System.UInt32");
- system_int64_expr = new TypeLookupExpression ("System.Int64");
- system_uint64_expr = new TypeLookupExpression ("System.UInt64");
- system_char_expr = new TypeLookupExpression ("System.Char");
- system_void_expr = new TypeLookupExpression ("System.Void");
- system_valuetype_expr = new TypeLookupExpression ("System.ValueType");
- system_intptr_expr = new TypeLookupExpression ("System.IntPtr");
+ system_object_expr = new TypeLookupExpression ("System", "Object");
+ system_string_expr = new TypeLookupExpression ("System", "String");
+ system_boolean_expr = new TypeLookupExpression ("System", "Boolean");
+ system_decimal_expr = new TypeLookupExpression ("System", "Decimal");
+ system_single_expr = new TypeLookupExpression ("System", "Single");
+ system_double_expr = new TypeLookupExpression ("System", "Double");
+ system_sbyte_expr = new TypeLookupExpression ("System", "SByte");
+ system_byte_expr = new TypeLookupExpression ("System", "Byte");
+ system_int16_expr = new TypeLookupExpression ("System", "Int16");
+ system_uint16_expr = new TypeLookupExpression ("System", "UInt16");
+ system_int32_expr = new TypeLookupExpression ("System", "Int32");
+ system_uint32_expr = new TypeLookupExpression ("System", "UInt32");
+ system_int64_expr = new TypeLookupExpression ("System", "Int64");
+ system_uint64_expr = new TypeLookupExpression ("System", "UInt64");
+ system_char_expr = new TypeLookupExpression ("System", "Char");
+ system_void_expr = new TypeLookupExpression ("System", "Void");
+ system_valuetype_expr = new TypeLookupExpression ("System", "ValueType");
+ system_intptr_expr = new TypeLookupExpression ("System", "IntPtr");
}
static TypeManager ()
{
Reset ();
-
- InitExpressionTypes ();
}
static public void Reset ()
{
+ InitExpressionTypes ();
+
builder_to_declspace = new PtrHashtable ();
builder_to_member_cache = new PtrHashtable ();
builder_to_method = new PtrHashtable ();
fields = new Hashtable ();
type_hash = new DoubleHash ();
assembly_internals_vis_attrs = new PtrHashtable ();
+ iface_cache = new PtrHashtable ();
+
+ closure = new Closure ();
+ FilterWithClosure_delegate = new MemberFilter (closure.Filter);
// TODO: I am really bored by all this static stuff
system_type_get_type_from_handle =
void_initializearray_array_fieldhandle =
delegate_combine_delegate_delegate =
delegate_remove_delegate_delegate =
- int_get_offset_to_string_data =
int_interlocked_compare_exchange =
methodbase_get_type_from_handle =
methodbase_get_type_from_handle_generic =
fieldinfo_get_field_from_handle =
activator_create_instance = null;
+ int_get_offset_to_string_data =
ienumerator_getcurrent = null;
void_decimal_ctor_five_args =
- void_decimal_ctor_int_arg =
- default_member_ctor =
- decimal_constant_attribute_ctor =
- struct_layout_attribute_ctor =
- field_offset_attribute_ctor =
- invalid_operation_exception_ctor =
- fixed_buffer_attr_ctor = null;
-
- param_array_attr =
- compiler_generated_attr =
- extension_attribute_attr = null;
+ void_decimal_ctor_int_arg = null;
isvolatile_type = null;
public static MemberCache LookupMemberCache (Type t)
{
- if (t.Module == CodeGen.Module.Builder) {
+ if (t.Module == RootContext.ToplevelTypes.Builder) {
DeclSpace container = (DeclSpace)builder_to_declspace [t];
if (container != null)
return container.MemberCache;
return null;
}
- public static CustomAttributeBuilder GetCompilerGeneratedAttribute (Location loc)
- {
- if (compiler_generated_attr != null)
- return compiler_generated_attr;
-
- Type t = TypeManager.CoreLookupType (
- "System.Runtime.CompilerServices", "CompilerGeneratedAttribute", Kind.Class, true);
-
- // TODO: it cannot be null
- if (t == null)
- return null;
-
- compiler_generated_attr = new CustomAttributeBuilder (
- GetPredefinedConstructor (t, loc, Type.EmptyTypes), new object[0]);
-
- return compiler_generated_attr;
- }
-
- public static CustomAttributeBuilder GetDebuggerHiddenAttribute (Location loc)
- {
- if (debugger_hidden_attr != null)
- return debugger_hidden_attr;
-
- Type t = TypeManager.CoreLookupType (
- "System.Diagnostics", "DebuggerHiddenAttribute", Kind.Class, true);
-
- // TODO: it cannot be null
- if (t == null)
- return null;
-
- debugger_hidden_attr = new CustomAttributeBuilder (
- GetPredefinedConstructor (t, loc, Type.EmptyTypes), new object[0]);
-
- return debugger_hidden_attr;
- }
-
public static Type GetNestedType (Type t, string name)
{
object ret = null;
public static void LoadAllImportedTypes ()
{
AllClsTopLevelTypes = new Hashtable (1500);
- foreach (Assembly a in RootNamespace.Global.Assemblies) {
+ foreach (Assembly a in GlobalRootNamespace.Instance.Assemblies) {
foreach (Type t in a.GetExportedTypes ()) {
AllClsTopLevelTypes [t.FullName.ToLower (System.Globalization.CultureInfo.InvariantCulture)] = null;
}
public static bool NamespaceClash (string name, Location loc)
{
- if (! RootNamespace.Global.IsNamespace (name))
+ if (!GlobalRootNamespace.Instance.IsNamespace (name))
return false;
Report.Error (519, loc, String.Format ("`{0}' clashes with a predefined namespace", name));
if (t == typeof (AnonymousMethodBody))
return "anonymous method";
- return CSharpName (GetFullName (t));
- }
+ if (t == typeof (MethodGroupExpr))
+ return "method group";
+
+ if (t == null)
+ return "internal error";
+
+ return CSharpName (GetFullName (t), t);
+ }
static readonly char [] elements = new char [] { '*', '[' };
- public static string CSharpName (string name)
+ public static string CSharpName (string name, Type type)
{
if (name.Length > 10) {
+ string s;
switch (name) {
- case "System.Int32": return "int";
- case "System.Int64": return "long";
- case "System.String": return "string";
- case "System.Boolean": return "bool";
- case "System.Void": return "void";
- case "System.Object": return "object";
- case "System.UInt32": return "uint";
- case "System.Int16": return "short";
- case "System.UInt16": return "ushort";
- case "System.UInt64": return "ulong";
- case "System.Single": return "float";
- case "System.Double": return "double";
- case "System.Decimal": return "decimal";
- case "System.Char": return "char";
- case "System.Byte": return "byte";
- case "System.SByte": return "sbyte";
+ case "System.Int32": s = "int"; break;
+ case "System.Int64": s = "long"; break;
+ case "System.String": s = "string"; break;
+ case "System.Boolean": s = "bool"; break;
+ case "System.Void": s = "void"; break;
+ case "System.Object": s = "object"; break;
+ case "System.UInt32": s = "uint"; break;
+ case "System.Int16": s = "short"; break;
+ case "System.UInt16": s = "ushort"; break;
+ case "System.UInt64": s = "ulong"; break;
+ case "System.Single": s = "float"; break;
+ case "System.Double": s = "double"; break;
+ case "System.Decimal": s = "decimal"; break;
+ case "System.Char": s = "char"; break;
+ case "System.Byte": s = "byte"; break;
+ case "System.SByte": s = "sbyte"; break;
+ default: s = null; break;
+ }
+
+ if (s != null) {
+ //
+ // Predefined names can come from mscorlib only
+ //
+ if (type == null || type.Module.Name == "mscorlib.dll" || !RootContext.StdLib)
+ return s;
+
+ return name;
}
+ if (name [0] == AnonymousTypeClass.ClassNamePrefix [0] && name.StartsWith (AnonymousTypeClass.ClassNamePrefix))
+ return AnonymousTypeClass.SignatureForError;
+
int idx = name.IndexOfAny (elements, 10);
if (idx > 0)
- return CSharpName (name.Substring (0, idx)) + name.Substring (idx);
+ return CSharpName (name.Substring (0, idx), type) + name.Substring (idx);
}
- if (name [0] == AnonymousTypeClass.ClassNamePrefix [0] && name.StartsWith (AnonymousTypeClass.ClassNamePrefix))
- return AnonymousTypeClass.SignatureForError;
-
return name.Replace ('+', '.');
}
}
return sb.ToString ();
}
-
- // Used for error reporting to show symbolic name instead of underlying value
- public static string CSharpEnumValue (Type t, object value)
- {
- t = DropGenericTypeArguments (t);
- Enum e = LookupDeclSpace (t) as Enum;
- if (e == null)
- return System.Enum.GetName (t, value);
-
- return e.GetDefinition (value).GetSignatureForError ();
- }
- /// <summary>
+ /// <summary>
/// Returns the signature of the method with full namespace classification
/// </summary>
static public string GetFullNameSignature (MemberInfo mi)
{
if (t.IsArray) {
string dimension = t.Name.Substring (t.Name.LastIndexOf ('['));
- return GetFullName (t.GetElementType ()) + dimension;
+ return GetFullName (GetElementType (t)) + dimension;
}
if (IsNullableType (t) && !t.IsGenericTypeDefinition) {
if (!mb.IsConstructor && TypeManager.IsSpecialMethod (mb)) {
string op_name = Operator.GetName (mb.Name);
if (op_name != null) {
- sig.Append ("operator ");
- sig.Append (op_name);
+ if (op_name == "explicit" || op_name == "implicit") {
+ sig.Append (op_name);
+ sig.Append (" operator ");
+ sig.Append (CSharpName (((MethodInfo)mb).ReturnType));
+ } else {
+ sig.Append ("operator ");
+ sig.Append (op_name);
+ }
sig.Append (parameters);
return sig.ToString ();
}
else {
sig.Append (mb.Name);
-#if GMCS_SOURCE
- if (TypeManager.IsGenericMethod (mb)) {
- Type[] args = mb.GetGenericArguments ();
+ if (IsGenericMethod (mb)) {
+ Type[] args = GetGenericArguments (mb);
sig.Append ('<');
for (int i = 0; i < args.Length; i++) {
if (i > 0)
}
sig.Append ('>');
}
-#endif
}
sig.Append (parameters);
public static string GetMethodName (MethodInfo m)
{
-#if GMCS_SOURCE
if (!IsGenericMethodDefinition (m) && !IsGenericMethod (m))
return m.Name;
- return MemberName.MakeName (m.Name, m.GetGenericArguments ().Length);
-#else
- return m.Name;
-#endif
+ return MemberName.MakeName (m.Name, TypeManager.GetGenericArguments (m).Length);
}
static public string CSharpSignature (EventInfo ei)
//
public static Type CoreLookupType (string ns_name, string name, Kind type_kind, bool required)
{
- Expression expr;
- if (RootContext.StdLib) {
- Namespace ns = RootNamespace.Global.GetNamespace (ns_name, true);
- expr = ns.Lookup (RootContext.ToplevelTypes, name, Location.Null);
- } else {
- if (!required)
- Report.DisableReporting ();
-
- TypeLookupExpression tle = new TypeLookupExpression (ns_name + "." + name);
- expr = tle.ResolveAsTypeTerminal (RootContext.ToplevelTypes, false);
-
- if (!required)
- Report.EnableReporting ();
- }
+ Namespace ns = GlobalRootNamespace.Instance.GetNamespace (ns_name, true);
+ Expression expr = ns.Lookup (RootContext.ToplevelTypes, name, Location.Null);
if (expr == null) {
if (required) {
return t;
// TODO: All predefined imported types have to have correct signature
- if (t.Module != CodeGen.Module.Builder)
+ if (t.Module != RootContext.ToplevelTypes.Builder)
return t;
DeclSpace ds = (DeclSpace)RootContext.ToplevelTypes.GetDefinition (t.FullName);
attribute_type = CoreLookupType ("System", "Attribute", Kind.Class, true);
int32_type = CoreLookupType ("System", "Int32", Kind.Struct, true);
+ system_int32_expr.Type = int32_type;
int64_type = CoreLookupType ("System", "Int64", Kind.Struct, true);
- uint32_type = CoreLookupType ("System", "UInt32", Kind.Struct, true);
- uint64_type = CoreLookupType ("System", "UInt64", Kind.Struct, true);
+ system_int64_expr.Type = int64_type;
+ uint32_type = CoreLookupType ("System", "UInt32", Kind.Struct, true);
+ system_uint32_expr.Type = uint32_type;
+ uint64_type = CoreLookupType ("System", "UInt64", Kind.Struct, true);
+ system_uint64_expr.Type = uint64_type;
byte_type = CoreLookupType ("System", "Byte", Kind.Struct, true);
+ system_byte_expr.Type = byte_type;
sbyte_type = CoreLookupType ("System", "SByte", Kind.Struct, true);
+ system_sbyte_expr.Type = sbyte_type;
short_type = CoreLookupType ("System", "Int16", Kind.Struct, true);
+ system_int16_expr.Type = short_type;
ushort_type = CoreLookupType ("System", "UInt16", Kind.Struct, true);
+ system_uint16_expr.Type = ushort_type;
ienumerator_type = CoreLookupType ("System.Collections", "IEnumerator", Kind.Interface, true);
ienumerable_type = CoreLookupType ("System.Collections", "IEnumerable", Kind.Interface, true);
generic_ienumerator_type = CoreLookupType ("System.Collections.Generic", "IEnumerator`1", Kind.Interface, false);
char_type = CoreLookupType ("System", "Char", Kind.Struct, true);
+ system_char_expr.Type = char_type;
string_type = CoreLookupType ("System", "String", Kind.Class, true);
+ system_string_expr.Type = string_type;
float_type = CoreLookupType ("System", "Single", Kind.Struct, true);
+ system_single_expr.Type = float_type;
double_type = CoreLookupType ("System", "Double", Kind.Struct, true);
+ system_double_expr.Type = double_type;
decimal_type = CoreLookupType ("System", "Decimal", Kind.Struct, true);
+ system_decimal_expr.Type = decimal_type;
bool_type = CoreLookupType ("System", "Boolean", Kind.Struct, true);
+ system_boolean_expr.Type = bool_type;
intptr_type = CoreLookupType ("System", "IntPtr", Kind.Struct, true);
+ system_intptr_expr.Type = intptr_type;
uintptr_type = CoreLookupType ("System", "UIntPtr", Kind.Struct, true);
multicast_delegate_type = CoreLookupType ("System", "MulticastDelegate", Kind.Class, true);
enum_type = CoreLookupType ("System", "Enum", Kind.Class, true);
array_type = CoreLookupType ("System", "Array", Kind.Class, true);
void_type = CoreLookupType ("System", "Void", Kind.Struct, true);
+ system_void_expr.Type = void_type;
type_type = CoreLookupType ("System", "Type", Kind.Class, true);
exception_type = CoreLookupType ("System", "Exception", Kind.Class, true);
runtime_field_handle_type = CoreLookupType ("System", "RuntimeFieldHandle", Kind.Struct, true);
runtime_handle_type = CoreLookupType ("System", "RuntimeTypeHandle", Kind.Struct, true);
- param_array_type = CoreLookupType ("System", "ParamArrayAttribute", Kind.Class, true);
- out_attribute_type = CoreLookupType ("System.Runtime.InteropServices", "OutAttribute", Kind.Class, true);
+ PredefinedAttributes.Get.ParamArray.Resolve (false);
+ PredefinedAttributes.Get.Out.Resolve (false);
return Report.Errors == 0;
}
//
public static void InitOptionalCoreTypes ()
{
+ //
+ // These are only used for compare purposes
+ //
+ anonymous_method_type = typeof (AnonymousMethodBody);
+ null_type = typeof (NullLiteral);
+
void_ptr_type = GetPointerType (void_type);
- char_ptr_type = GetPointerType (char_type);
//
// Initialize InternalsVisibleTo as the very first optional type. Otherwise we would populate
// types cache with incorrect accessiblity when any of optional types is internal.
//
- internals_visible_attr_type = CoreLookupType ("System.Runtime.CompilerServices", "InternalsVisibleToAttribute", Kind.Class, false);
+ PredefinedAttributes.Get.Initialize ();
runtime_argument_handle_type = CoreLookupType ("System", "RuntimeArgumentHandle", Kind.Struct, false);
asynccallback_type = CoreLookupType ("System", "AsyncCallback", Kind.Delegate, false);
//
// Optional attributes, used for error reporting only
//
- obsolete_attribute_type = CoreLookupType ("System", "ObsoleteAttribute", Kind.Class, false);
- if (obsolete_attribute_type != null) {
- Class c = TypeManager.LookupClass (obsolete_attribute_type);
- if (c != null)
- c.DefineMembers ();
- }
+ //if (PredefinedAttributes.Get.Obsolete.IsDefined) {
+ // Class c = TypeManager.LookupClass (PredefinedAttributes.Get.Obsolete.Type);
+ // if (c != null)
+ // c.Define ();
+ //}
- dllimport_type = CoreLookupType ("System.Runtime.InteropServices", "DllImportAttribute", Kind.Class, false);
- methodimpl_attr_type = CoreLookupType ("System.Runtime.CompilerServices", "MethodImplAttribute", Kind.Class, false);
-#if !NET_2_0
- marshal_as_attr_type = CoreLookupType ("System.Runtime.InteropServices", "MarshalAsAttribute", Kind.Class, false);
-#endif
- in_attribute_type = CoreLookupType ("System.Runtime.InteropServices", "InAttribute", Kind.Class, false);
- indexer_name_type = CoreLookupType ("System.Runtime.CompilerServices", "IndexerNameAttribute", Kind.Class, false);
- conditional_attribute_type = CoreLookupType ("System.Diagnostics", "ConditionalAttribute", Kind.Class, false);
- cls_compliant_attribute_type = CoreLookupType ("System", "CLSCompliantAttribute", Kind.Class, false);
- security_attr_type = CoreLookupType ("System.Security.Permissions", "SecurityAttribute", Kind.Class, false);
- required_attr_type = CoreLookupType ("System.Runtime.CompilerServices", "RequiredAttributeAttribute", Kind.Class, false);
- guid_attr_type = CoreLookupType ("System.Runtime.InteropServices", "GuidAttribute", Kind.Class, false);
- assembly_culture_attribute_type = CoreLookupType ("System.Reflection", "AssemblyCultureAttribute", Kind.Class, false);
- assembly_version_attribute_type = CoreLookupType ("System.Reflection", "AssemblyVersionAttribute", Kind.Class, false);
- comimport_attr_type = CoreLookupType ("System.Runtime.InteropServices", "ComImportAttribute", Kind.Class, false);
- coclass_attr_type = CoreLookupType ("System.Runtime.InteropServices", "CoClassAttribute", Kind.Class, false);
- attribute_usage_type = CoreLookupType ("System", "AttributeUsageAttribute", Kind.Class, false);
- default_parameter_value_attribute_type = CoreLookupType ("System.Runtime.InteropServices", "DefaultParameterValueAttribute", Kind.Class, false);
-
- // New in .NET 2.0
- default_charset_type = CoreLookupType ("System.Runtime.InteropServices", "DefaultCharSetAttribute", Kind.Class, false);
- type_forwarder_attr_type = CoreLookupType ("System.Runtime.CompilerServices", "TypeForwardedToAttribute", Kind.Class, false);
generic_ilist_type = CoreLookupType ("System.Collections.Generic", "IList`1", Kind.Interface, false);
generic_icollection_type = CoreLookupType ("System.Collections.Generic", "ICollection`1", Kind.Interface, false);
generic_ienumerable_type = CoreLookupType ("System.Collections.Generic", "IEnumerable`1", Kind.Interface, false);
//
// Optional types which are used as types and for member lookup
//
- default_member_type = CoreLookupType ("System.Reflection", "DefaultMemberAttribute", Kind.Class, false);
runtime_helpers_type = CoreLookupType ("System.Runtime.CompilerServices", "RuntimeHelpers", Kind.Class, false);
- decimal_constant_attribute_type = CoreLookupType ("System.Runtime.CompilerServices", "DecimalConstantAttribute", Kind.Class, false);
- struct_layout_attribute_type = CoreLookupType ("System.Runtime.InteropServices", "StructLayoutAttribute", Kind.Class, false);
- field_offset_attribute_type = CoreLookupType ("System.Runtime.InteropServices", "FieldOffsetAttribute", Kind.Class, false);
-
- // New in .NET 2.0
- fixed_buffer_attr_type = CoreLookupType ("System.Runtime.CompilerServices", "FixedBufferAttribute", Kind.Class, false);
// New in .NET 3.5
- extension_attribute_type = CoreLookupType ("System.Runtime.CompilerServices", "ExtensionAttribute", Kind.Class, false);
+ // Note: extension_attribute_type is already loaded
expression_type = CoreLookupType ("System.Linq.Expressions", "Expression`1", Kind.Class, false);
if (!RootContext.StdLib) {
TypeManager.CSharpName (system_4_type_arg));
}
}
-
- system_string_expr.Type = string_type;
- system_boolean_expr.Type = bool_type;
- system_decimal_expr.Type = decimal_type;
- system_single_expr.Type = float_type;
- system_double_expr.Type = double_type;
- system_sbyte_expr.Type = sbyte_type;
- system_byte_expr.Type = byte_type;
- system_int16_expr.Type = short_type;
- system_uint16_expr.Type = ushort_type;
- system_int32_expr.Type = int32_type;
- system_uint32_expr.Type = uint32_type;
- system_int64_expr.Type = int64_type;
- system_uint64_expr.Type = uint64_type;
- system_char_expr.Type = char_type;
- system_void_expr.Type = void_type;
-
- //
- // These are only used for compare purposes
- //
- anonymous_method_type = typeof (AnonymousMethodBody);
- null_type = typeof (NullLiteral);
}
const BindingFlags instance_and_static = BindingFlags.Static | BindingFlags.Instance;
mt, bf, name, FilterWithClosure_delegate, null);
}
+ //
+ // We have to take care of arrays specially, because GetType on
+ // a TypeBuilder array will return a Type, not a TypeBuilder,
+ // and we can not call FindMembers on this type.
+ //
+ if (t.IsArray) {
+ used_cache = true;
+ return TypeHandle.ArrayType.MemberCache.FindMembers (
+ mt, bf, name, FilterWithClosure_delegate, null);
+ }
+
if (t.IsGenericType && !t.IsGenericTypeDefinition)
t = t.GetGenericTypeDefinition ();
#else
public static bool IsDelegateType (Type t)
{
-#if GMCS_SOURCE
- if (t.IsGenericParameter)
+ if (TypeManager.IsGenericParameter (t))
return false;
-#endif
if (t == TypeManager.delegate_type || t == TypeManager.multicast_delegate_type)
return false;
return t == attribute_type && t.BaseType != null || IsSubclassOf (t, attribute_type);
}
- static Stack unmanaged_enclosing_types = new Stack (4);
-
//
// Whether a type is unmanaged. This is used by the unsafe code (25.2)
//
+ // mcs4: delete, DeclSpace.IsUnmanagedType is replacement
public static bool IsUnmanagedType (Type t)
{
- // Avoid infloops in the case of: unsafe struct Foo { Foo *x; }
- if (unmanaged_enclosing_types.Contains (t))
- return true;
+ DeclSpace ds = TypeManager.LookupDeclSpace (t);
+ if (ds != null)
+ return ds.IsUnmanagedType ();
// builtins that are not unmanaged types
if (t == TypeManager.object_type || t == TypeManager.string_type)
// Someone did the work of checking if the ElementType of t is unmanaged. Let's not repeat it.
if (t.IsPointer)
- return true;
+ return IsUnmanagedType (GetElementType (t));
// Arrays are disallowed, even if we mark them with [MarshalAs(UnmanagedType.ByValArray, ...)]
if (t.IsArray)
if (!IsValueType (t))
return false;
-#if GMCS_SOURCE
for (Type p = t.DeclaringType; p != null; p = p.DeclaringType) {
- if (p.IsGenericTypeDefinition)
+ if (IsGenericTypeDefinition (p))
return false;
}
-#endif
-
- unmanaged_enclosing_types.Push (t);
bool retval = true;
-
- if (t is TypeBuilder) {
- TypeContainer tc = LookupTypeContainer (t);
- if (tc.Fields != null){
- foreach (FieldBase f in tc.Fields){
- // Avoid using f.FieldBuilder: f.Define () may not yet have been invoked.
- if ((f.ModFlags & Modifiers.STATIC) != 0)
- continue;
- if (f.MemberType == null)
- continue;
- if (!IsUnmanagedType (f.MemberType)){
- Report.SymbolRelatedToPreviousError (f.Location, CSharpName (t) + "." + f.Name);
- retval = false;
- }
- }
- }
- } else {
+ {
FieldInfo [] fields = t.GetFields (BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
foreach (FieldInfo f in fields){
if (!IsUnmanagedType (f.FieldType)){
- Report.SymbolRelatedToPreviousError (f);
retval = false;
}
}
}
- unmanaged_enclosing_types.Pop ();
-
return retval;
}
return constraints.IsReferenceType;
}
- return !t.IsValueType;
+ return !IsStruct (t) && !IsEnumType (t);
}
public static bool IsValueType (Type t)
{
- return t.IsValueType || IsGenericParameter (t);
+ if (TypeManager.IsGenericParameter (t)) {
+ GenericConstraints constraints = TypeManager.GetTypeParameterConstraints (t);
+ if (constraints == null)
+ return false;
+
+ return constraints.IsValueType;
+ }
+
+ return IsStruct (t) || IsEnumType (t);
+ }
+
+ public static bool IsStruct (Type t)
+ {
+ return t.BaseType == value_type && t != enum_type && t.IsSealed;
}
public static bool IsInterfaceType (Type t)
return false;
}
+ public static bool IsSpecialType (Type t)
+ {
+ return t == arg_iterator_type || t == typed_reference_type;
+ }
+
//
// Checks whether `extern_type' is friend of the output assembly
//
if (assembly_internals_vis_attrs.Contains (assembly))
return (bool)(assembly_internals_vis_attrs [assembly]);
-
- if (internals_visible_attr_type == null)
+
+ PredefinedAttribute pa = PredefinedAttributes.Get.InternalsVisibleTo;
+ // HACK: Do very early resolve of SRE type checking
+ if (pa.Type == null)
+ pa.Resolve (true);
+
+ if (!pa.IsDefined)
return false;
- object [] attrs = assembly.GetCustomAttributes (internals_visible_attr_type, false);
+ object [] attrs = assembly.GetCustomAttributes (pa.Type, false);
if (attrs.Length == 0) {
assembly_internals_vis_attrs.Add (assembly, false);
return false;
}
bool is_friend = false;
-#if GMCS_SOURCE
+
AssemblyName this_name = CodeGen.Assembly.Name;
byte [] this_token = this_name.GetPublicKeyToken ();
foreach (InternalsVisibleToAttribute attr in attrs) {
AssemblyName aname = null;
try {
+#if GMCS_SOURCE
aname = new AssemblyName (attr.AssemblyName);
+#else
+ throw new NotSupportedException ();
+#endif
} catch (FileLoadException) {
} catch (ArgumentException) {
}
is_friend = true;
break;
}
-#endif
+
assembly_internals_vis_attrs.Add (assembly, is_friend);
return is_friend;
}
-#if GMCS_SOURCE
static bool CompareKeyTokens (byte [] token1, byte [] token2)
{
for (int i = 0; i < token1.Length; i++)
static void Error_FriendAccessNameNotMatching (string other_name)
{
- Report.Error (281, "Friend access was granted to `" + other_name +
- "', but the output assembly is named `" + CodeGen.Assembly.Name.FullName +
- "'. Try adding a reference to `" + other_name +
- "' or change the output assembly name to match it");
+ Report.Error (281,
+ "Friend access was granted to `{0}', but the output assembly is named `{1}'. Try adding a reference to `{0}' or change the output assembly name to match it",
+ other_name, CodeGen.Assembly.Name.FullName);
}
-#endif
//
// Do the right thing when returning the element type of an
TypeManager.CSharpName (mb.DeclaringType) + "." + mb.Name);
}
- pd = ParametersCollection.Create (mb);
+ pd = ParametersImported.Create (mb);
#else
MethodBase generic = TypeManager.DropGenericMethodArguments (mb);
if (generic != mb) {
pd = TypeManager.GetParameterData (generic);
- pd = ParametersCollection.Create (pd, mb);
+ pd = ParametersImported.Create (pd, mb);
} else {
- pd = ParametersCollection.Create (mb);
+ pd = ParametersImported.Create (mb);
}
#endif
method_params.Add (mb, pd);
AParametersCollection pd = (AParametersCollection)method_params [pi];
if (pd == null) {
if (pi is PropertyBuilder)
- return Parameters.EmptyReadOnlyParameters;
+ return ParametersCompiled.EmptyReadOnlyParameters;
ParameterInfo [] p = pi.GetIndexParameters ();
if (p == null)
- return Parameters.EmptyReadOnlyParameters;
+ return ParametersCompiled.EmptyReadOnlyParameters;
- pd = ParametersCollection.Create (p, null);
+ pd = ParametersImported.Create (p, null);
method_params.Add (pi, pd);
}
return ret;
}
- static PtrHashtable iface_cache = new PtrHashtable ();
+ static PtrHashtable iface_cache;
/// <summary>
/// This function returns the interfaces in the type `t'. Works with
iface_cache [t] = result;
return result;
-#if GMCS_SOURCE
} else if (t is GenericTypeParameterBuilder){
Type[] type_ifaces = (Type []) builder_to_ifaces [t];
if (type_ifaces == null || type_ifaces.Length == 0)
iface_cache [t] = type_ifaces;
return type_ifaces;
-#endif
} else {
Type[] ifaces = t.GetInterfaces ();
iface_cache [t] = ifaces;
if (interfaces != null){
foreach (Type i in interfaces){
- if (i == iface)
+ if (i == iface || IsVariantOf (i, iface))
return true;
}
}
return false;
}
+ public static bool IsVariantOf (Type type1, Type type2)
+ {
+#if GMCS_SOURCE
+ if (type1.IsGenericType && type2.IsGenericType) {
+ Type generic_target_type = type2.GetGenericTypeDefinition ();
+ if (type1.GetGenericTypeDefinition () == generic_target_type) {
+ Type [] t1 = type1.GetGenericArguments ();
+ Type [] t2 = type2.GetGenericArguments ();
+ int i = 0;
+ foreach (Type t in generic_target_type.GetGenericArguments ()) {
+ if ((t.GenericParameterAttributes & GenericParameterAttributes.VarianceMask) != 0) {
+ // FIXME this is not right
+ if (IsValueType (t1[i]) || IsValueType (t2[i])) {
+ return false;
+ }
+ if ((t.GenericParameterAttributes & GenericParameterAttributes.Covariant) != 0 && !t2[i].IsAssignableFrom (t1[i])) {
+ return false;
+ }
+ if ((t.GenericParameterAttributes & GenericParameterAttributes.Contravariant) != 0 && !t1[i].IsAssignableFrom (t2[i])) {
+ return false;
+ }
+ } else if (t1[i] != t2[i]) {
+ return false;
+ }
+ i++;
+ }
+ return true;
+ }
+ }
+#endif
+ return false;
+ }
+
static NumberFormatInfo nf_provider = CultureInfo.CurrentCulture.NumberFormat;
// This is a custom version of Convert.ChangeType() which works
if (IsUnmanagedType (t))
return true;
+ while (t.IsPointer)
+ t = GetElementType (t);
+
+ Report.SymbolRelatedToPreviousError (t);
Report.Error (208, loc, "Cannot take the address of, get the size of, or declare a pointer to a managed type `{0}'",
CSharpName (t));
TypeContainer tc = t.IsInterface ? LookupInterface (t) : LookupTypeContainer (t);
return tc == null ? TypeContainer.DefaultIndexerName : tc.IndexerName;
}
-
- System.Attribute attr = System.Attribute.GetCustomAttribute (
- t, TypeManager.default_member_type);
- if (attr != null){
- DefaultMemberAttribute dma = (DefaultMemberAttribute) attr;
- return dma.MemberName;
+
+ PredefinedAttribute pa = PredefinedAttributes.Get.DefaultMember;
+ if (pa.IsDefined) {
+ System.Attribute attr = System.Attribute.GetCustomAttribute (
+ t, pa.Type);
+ if (attr != null) {
+ DefaultMemberAttribute dma = (DefaultMemberAttribute) attr;
+ return dma.MemberName;
+ }
}
return TypeContainer.DefaultIndexerName;
if (a.GetArrayRank () != b.GetArrayRank ())
return false;
- return IsSignatureEqual (a.GetElementType (), b.GetElementType ());
+ return IsSignatureEqual (GetElementType (a), GetElementType (b));
}
if (a.IsByRef && b.IsByRef)
- return IsSignatureEqual (a.GetElementType (), b.GetElementType ());
+ return IsSignatureEqual (GetElementType (a), GetElementType (b));
-#if GMCS_SOURCE
- if (a.IsGenericType && b.IsGenericType) {
- if (a.GetGenericTypeDefinition () != b.GetGenericTypeDefinition ())
+ if (IsGenericType (a) && IsGenericType (b)) {
+ if (DropGenericTypeArguments (a) != DropGenericTypeArguments (b))
return false;
- Type[] aargs = a.GetGenericArguments ();
- Type[] bargs = b.GetGenericArguments ();
+ Type[] aargs = GetTypeArguments (a);
+ Type[] bargs = GetTypeArguments (b);
if (aargs.Length != bargs.Length)
return false;
return true;
}
-#endif
return false;
}
return true;
}
-#if GMCS_SOURCE
- if (a.IsGenericParameter && b.IsGenericParameter) {
+ if (IsGenericParameter (a) && IsGenericParameter (b)) {
// TODO: needs more testing before cleaning up
//if (a.DeclaringMethod != b.DeclaringMethod &&
// (a.DeclaringMethod == null || b.DeclaringMethod == null))
// return false;
+#if GMCS_SOURCE
return a.GenericParameterPosition == b.GenericParameterPosition;
+#else
+ throw new NotSupportedException ();
+#endif
}
if (a.IsArray && b.IsArray) {
if (a.GetArrayRank () != b.GetArrayRank ())
return false;
- return IsEqual (a.GetElementType (), b.GetElementType ());
+ return IsEqual (GetElementType (a), GetElementType (b));
}
if (a.IsByRef && b.IsByRef)
return IsEqual (a.GetElementType (), b.GetElementType ());
- if (a.IsGenericType && b.IsGenericType) {
- Type adef = a.GetGenericTypeDefinition ();
- Type bdef = b.GetGenericTypeDefinition ();
+ if (IsGenericType (a) && IsGenericType (b)) {
+ Type adef = DropGenericTypeArguments (a);
+ Type bdef = DropGenericTypeArguments (b);
if (adef != bdef)
return false;
if (adef.IsEnum && bdef.IsEnum)
return true;
- Type[] aargs = a.GetGenericArguments ();
- Type[] bargs = b.GetGenericArguments ();
+ Type[] aargs = GetTypeArguments (a);
+ Type[] bargs = GetTypeArguments (b);
if (aargs.Length != bargs.Length)
return false;
return true;
}
-#endif
return false;
}
return generic_nullable_type == DropGenericTypeArguments (t);
#else
return false;
-#endif
- }
-
- public static bool IsNullableTypeOf (Type t, Type nullable)
- {
-#if GMCS_SOURCE
- if (!IsNullableType (t))
- return false;
-
- return GetTypeArguments (t) [0] == nullable;
-#else
- return false;
-#endif
- }
-
- public static bool IsNullableValueType (Type t)
- {
-#if GMCS_SOURCE
- if (!IsNullableType (t))
- return false;
-
- return GetTypeArguments (t) [0].IsValueType;
-#else
- return false;
#endif
}
#endregion
}
}
- static Closure closure = new Closure ();
- static MemberFilter FilterWithClosure_delegate = new MemberFilter (closure.Filter);
+ static Closure closure;
+ static MemberFilter FilterWithClosure_delegate;
//
// Looks up a member called `name' in the `queried_type'. This lookup
//
// DefaultMemberName and indexer name has to match to identify valid C# indexer
//
- if ((s_count > 1 || g_count > 0) && TypeManager.default_member_type != null) {
- object[] o = pi.DeclaringType.GetCustomAttributes (TypeManager.default_member_type, false);
+ PredefinedAttribute pa = PredefinedAttributes.Get.DefaultMember;
+ if ((s_count > 1 || g_count > 0) && pa.IsDefined) {
+ object[] o = pi.DeclaringType.GetCustomAttributes (pa.Type, false);
if (o.Length == 0)
return false;
{
MemberInfo [] members;
-#if GMCS_SOURCE
if (type is GenericTypeParameterBuilder)
return MemberList.Empty;
-#endif
+#if MS_COMPATIBLE
+ type = TypeManager.DropGenericTypeArguments (type);
+#endif
if (mt == MemberTypes.Event)
members = type.GetEvents (bf | BindingFlags.DeclaredOnly);
else
projects / mono.git / blobdiff