//
using System;
-using System.IO;
using System.Globalization;
using System.Collections.Generic;
-using System.Reflection;
-using System.Reflection.Emit;
using System.Text;
-using System.Runtime.CompilerServices;
-using System.Diagnostics;
-using System.Linq;
-namespace Mono.CSharp {
+namespace Mono.CSharp
+{
+ //
+ // All compiler build-in types (they have to exist otherwise the compile will not work)
+ //
+ public class BuildinTypes
+ {
+ public readonly BuildinTypeSpec Object;
+ public readonly BuildinTypeSpec ValueType;
+ public readonly BuildinTypeSpec Attribute;
+
+ public readonly BuildinTypeSpec Int;
+ public readonly BuildinTypeSpec UInt;
+ public readonly BuildinTypeSpec Long;
+ public readonly BuildinTypeSpec ULong;
+ public readonly BuildinTypeSpec Float;
+ public readonly BuildinTypeSpec Double;
+ public readonly BuildinTypeSpec Char;
+ public readonly BuildinTypeSpec Short;
+ public readonly BuildinTypeSpec Decimal;
+ public readonly BuildinTypeSpec Bool;
+ public readonly BuildinTypeSpec SByte;
+ public readonly BuildinTypeSpec Byte;
+ public readonly BuildinTypeSpec UShort;
+ public readonly BuildinTypeSpec String;
+
+ public readonly BuildinTypeSpec Enum;
+ public readonly BuildinTypeSpec Delegate;
+ public readonly BuildinTypeSpec MulticastDelegate;
+ public readonly BuildinTypeSpec Void;
+ public readonly BuildinTypeSpec Array;
+ public readonly BuildinTypeSpec Type;
+ public readonly BuildinTypeSpec IEnumerator;
+ public readonly BuildinTypeSpec IEnumerable;
+ public readonly BuildinTypeSpec IDisposable;
+ public readonly BuildinTypeSpec IntPtr;
+ public readonly BuildinTypeSpec UIntPtr;
+ public readonly BuildinTypeSpec RuntimeFieldHandle;
+ public readonly BuildinTypeSpec RuntimeTypeHandle;
+ public readonly BuildinTypeSpec Exception;
+
+ //
+ // These are internal buil-in types which depend on other
+ // build-in type (mostly object)
+ //
+ public readonly BuildinTypeSpec Dynamic;
+ public readonly BuildinTypeSpec Null;
+
+ // Predefined operators tables
+ public readonly Binary.PredefinedOperator[] OperatorsBinaryStandard;
+ public readonly Binary.PredefinedOperator[] OperatorsBinaryEquality;
+ public readonly Binary.PredefinedOperator[] OperatorsBinaryUnsafe;
+ public readonly TypeSpec[][] OperatorsUnary;
+ public readonly TypeSpec[] OperatorsUnaryMutator;
+
+ public readonly TypeSpec[] BinaryPromotionsTypes;
+ public readonly TypeSpec[] SwitchUserTypes;
+
+ readonly BuildinTypeSpec[] types;
+
+ public BuildinTypes ()
+ {
+ Object = new BuildinTypeSpec (MemberKind.Class, "System", "Object", BuildinTypeSpec.Type.Object);
+ ValueType = new BuildinTypeSpec (MemberKind.Class, "System", "ValueType", BuildinTypeSpec.Type.ValueType);
+ Attribute = new BuildinTypeSpec (MemberKind.Class, "System", "Attribute", BuildinTypeSpec.Type.Attribute);
+
+ Int = new BuildinTypeSpec (MemberKind.Struct, "System", "Int32", BuildinTypeSpec.Type.Int);
+ Long = new BuildinTypeSpec (MemberKind.Struct, "System", "Int64", BuildinTypeSpec.Type.Long);
+ UInt = new BuildinTypeSpec (MemberKind.Struct, "System", "UInt32", BuildinTypeSpec.Type.UInt);
+ ULong = new BuildinTypeSpec (MemberKind.Struct, "System", "UInt64", BuildinTypeSpec.Type.ULong);
+ Byte = new BuildinTypeSpec (MemberKind.Struct, "System", "Byte", BuildinTypeSpec.Type.Byte);
+ SByte = new BuildinTypeSpec (MemberKind.Struct, "System", "SByte", BuildinTypeSpec.Type.SByte);
+ Short = new BuildinTypeSpec (MemberKind.Struct, "System", "Int16", BuildinTypeSpec.Type.Short);
+ UShort = new BuildinTypeSpec (MemberKind.Struct, "System", "UInt16", BuildinTypeSpec.Type.UShort);
+
+ IEnumerator = new BuildinTypeSpec (MemberKind.Interface, "System.Collections", "IEnumerator", BuildinTypeSpec.Type.IEnumerator);
+ IEnumerable = new BuildinTypeSpec (MemberKind.Interface, "System.Collections", "IEnumerable", BuildinTypeSpec.Type.IEnumerable);
+ IDisposable = new BuildinTypeSpec (MemberKind.Interface, "System", "IDisposable", BuildinTypeSpec.Type.IDisposable);
+
+ Char = new BuildinTypeSpec (MemberKind.Struct, "System", "Char", BuildinTypeSpec.Type.Char);
+ String = new BuildinTypeSpec (MemberKind.Class, "System", "String", BuildinTypeSpec.Type.String);
+ Float = new BuildinTypeSpec (MemberKind.Struct, "System", "Single", BuildinTypeSpec.Type.Float);
+ Double = new BuildinTypeSpec (MemberKind.Struct, "System", "Double", BuildinTypeSpec.Type.Double);
+ Decimal = new BuildinTypeSpec (MemberKind.Struct, "System", "Decimal", BuildinTypeSpec.Type.Decimal);
+ Bool = new BuildinTypeSpec (MemberKind.Struct, "System", "Boolean", BuildinTypeSpec.Type.Bool);
+ IntPtr = new BuildinTypeSpec (MemberKind.Struct, "System", "IntPtr", BuildinTypeSpec.Type.IntPtr);
+ UIntPtr = new BuildinTypeSpec (MemberKind.Struct, "System", "UIntPtr", BuildinTypeSpec.Type.UIntPtr);
+
+ MulticastDelegate = new BuildinTypeSpec (MemberKind.Class, "System", "MulticastDelegate", BuildinTypeSpec.Type.MulticastDelegate);
+ Delegate = new BuildinTypeSpec (MemberKind.Class, "System", "Delegate", BuildinTypeSpec.Type.Delegate);
+ Enum = new BuildinTypeSpec (MemberKind.Class, "System", "Enum", BuildinTypeSpec.Type.Enum);
+ Array = new BuildinTypeSpec (MemberKind.Class, "System", "Array", BuildinTypeSpec.Type.Array);
+ Void = new BuildinTypeSpec (MemberKind.Void, "System", "Void", BuildinTypeSpec.Type.Other);
+ Type = new BuildinTypeSpec (MemberKind.Class, "System", "Type", BuildinTypeSpec.Type.Type);
+ Exception = new BuildinTypeSpec (MemberKind.Class, "System", "Exception", BuildinTypeSpec.Type.Exception);
+ RuntimeFieldHandle = new BuildinTypeSpec (MemberKind.Struct, "System", "RuntimeFieldHandle", BuildinTypeSpec.Type.Other);
+ RuntimeTypeHandle = new BuildinTypeSpec (MemberKind.Struct, "System", "RuntimeTypeHandle", BuildinTypeSpec.Type.Other);
+
+ Dynamic = new BuildinTypeSpec ("dynamic", BuildinTypeSpec.Type.Dynamic);
+ Null = new BuildinTypeSpec ("null", BuildinTypeSpec.Type.Null);
+ Null.MemberCache = MemberCache.Empty;
+
+ OperatorsBinaryStandard = Binary.CreateStandardOperatorsTable (this);
+ OperatorsBinaryEquality = Binary.CreateEqualityOperatorsTable (this);
+ OperatorsBinaryUnsafe = Binary.CreatePointerOperatorsTable (this);
+ OperatorsUnary = Unary.CreatePredefinedOperatorsTable (this);
+ OperatorsUnaryMutator = UnaryMutator.CreatePredefinedOperatorsTable (this);
+
+ BinaryPromotionsTypes = ConstantFold.CreateBinaryPromotionsTypes (this);
+ SwitchUserTypes = Switch.CreateSwitchUserTypes (this);
+
+ types = new BuildinTypeSpec[] {
+ Object, ValueType, Attribute,
+ Int, UInt, Long, ULong, Float, Double, Char, Short, Decimal, Bool, SByte, Byte, UShort, String,
+ Enum, Delegate, MulticastDelegate, Void, Array, Type, IEnumerator, IEnumerable, IDisposable,
+ IntPtr, UIntPtr, RuntimeFieldHandle, RuntimeTypeHandle, Exception };
+
+ // Deal with obsolete static types
+ // TODO: remove
+ TypeManager.object_type = Object;
+ TypeManager.value_type = ValueType;
+ TypeManager.string_type = String;
+ TypeManager.int32_type = Int;
+ TypeManager.uint32_type = UInt;
+ TypeManager.int64_type = Long;
+ TypeManager.uint64_type = ULong;
+ TypeManager.float_type = Float;
+ TypeManager.double_type = Double;
+ TypeManager.char_type = Char;
+ TypeManager.short_type = Short;
+ TypeManager.decimal_type = Decimal;
+ TypeManager.bool_type = Bool;
+ TypeManager.sbyte_type = SByte;
+ TypeManager.byte_type = Byte;
+ TypeManager.ushort_type = UShort;
+ TypeManager.delegate_type = Delegate;
+ TypeManager.void_type = Void;
+
+ InternalType.Dynamic = Dynamic;
+ InternalType.Null = Null;
+ }
+
+ public BuildinTypeSpec[] AllTypes {
+ get {
+ return types;
+ }
+ }
+
+ public bool CheckDefinitions (ModuleContainer module)
+ {
+ var ctx = module.Compiler;
+ foreach (var p in types) {
+ var found = PredefinedType.Resolve (module, p.Kind, p.Namespace, p.Name, p.Arity, Location.Null);
+ if (found == null || found == p)
+ continue;
+
+ var tc = found.MemberDefinition as TypeContainer;
+ if (tc != null) {
+ var ns = module.GlobalRootNamespace.GetNamespace (p.Namespace, false);
+ ns.ReplaceTypeWithPredefined (found, p);
+
+ tc.SetPredefinedSpec (p);
+ p.SetDefinition (found);
+ }
+ }
+
+ if (ctx.Report.Errors != 0)
+ return false;
+
+ // Set internal build-in types
+ Dynamic.SetDefinition (Object);
+ Null.SetDefinition (Object);
+
+ return true;
+ }
+ }
+
+ //
+ // Compiler predefined types. Usually used for compiler generated
+ // code or for comparison against well known framework type
+ //
+ class PredefinedTypes
+ {
+ // TODO: These two exist only to reject type comparison
+ public readonly PredefinedType TypedReference;
+ public readonly PredefinedType ArgIterator;
+
+ public readonly PredefinedType MarshalByRefObject;
+ public readonly PredefinedType RuntimeHelpers;
+ public readonly PredefinedType IAsyncResult;
+ public readonly PredefinedType AsyncCallback;
+ public readonly PredefinedType RuntimeArgumentHandle;
+ public readonly PredefinedType CharSet;
+ public readonly PredefinedType IsVolatile;
+ public readonly PredefinedType IEnumeratorGeneric;
+ public readonly PredefinedType IListGeneric;
+ public readonly PredefinedType ICollectionGeneric;
+ public readonly PredefinedType IEnumerableGeneric;
+ public readonly PredefinedType Nullable;
+ public readonly PredefinedType Activator;
+ public readonly PredefinedType Interlocked;
+ public readonly PredefinedType Monitor;
+ public readonly PredefinedType NotSupportedException;
+ public readonly PredefinedType RuntimeFieldHandle;
+ public readonly PredefinedType RuntimeMethodHandle;
+ public readonly PredefinedType SecurityAction;
+
+ //
+ // C# 3.0
+ //
+ public readonly PredefinedType Expression;
+ public readonly PredefinedType ExpressionGeneric;
+ public readonly PredefinedType ParameterExpression;
+ public readonly PredefinedType FieldInfo;
+ public readonly PredefinedType MethodBase;
+ public readonly PredefinedType MethodInfo;
+ public readonly PredefinedType ConstructorInfo;
+
+ //
+ // C# 4.0
+ //
+ public readonly PredefinedType Binder;
+ public readonly PredefinedType CallSite;
+ public readonly PredefinedType CallSiteGeneric;
+ public readonly PredefinedType BinderFlags;
+
+ public PredefinedTypes (ModuleContainer module)
+ {
+ TypedReference = new PredefinedType (module, MemberKind.Struct, "System", "TypedReference");
+ ArgIterator = new PredefinedType (module, MemberKind.Struct, "System", "ArgIterator");
+ MarshalByRefObject = new PredefinedType (module, MemberKind.Class, "System", "MarshalByRefObject");
+ RuntimeHelpers = new PredefinedType (module, MemberKind.Class, "System.Runtime.CompilerServices", "RuntimeHelpers");
+ IAsyncResult = new PredefinedType (module, MemberKind.Interface, "System", "IAsyncResult");
+ AsyncCallback = new PredefinedType (module, MemberKind.Delegate, "System", "AsyncCallback");
+ RuntimeArgumentHandle = new PredefinedType (module, MemberKind.Struct, "System", "RuntimeArgumentHandle");
+ CharSet = new PredefinedType (module, MemberKind.Enum, "System.Runtime.InteropServices", "CharSet");
+ IsVolatile = new PredefinedType (module, MemberKind.Class, "System.Runtime.CompilerServices", "IsVolatile");
+ IEnumeratorGeneric = new PredefinedType (module, MemberKind.Interface, "System.Collections.Generic", "IEnumerator", 1);
+ IListGeneric = new PredefinedType (module, MemberKind.Interface, "System.Collections.Generic", "IList", 1);
+ ICollectionGeneric = new PredefinedType (module, MemberKind.Interface, "System.Collections.Generic", "ICollection", 1);
+ IEnumerableGeneric = new PredefinedType (module, MemberKind.Interface, "System.Collections.Generic", "IEnumerable", 1);
+ Nullable = new PredefinedType (module, MemberKind.Struct, "System", "Nullable", 1);
+ Activator = new PredefinedType (module, MemberKind.Class, "System", "Activator");
+ Interlocked = new PredefinedType (module, MemberKind.Class, "System.Threading", "Interlocked");
+ Monitor = new PredefinedType (module, MemberKind.Class, "System.Threading", "Monitor");
+ NotSupportedException = new PredefinedType (module, MemberKind.Class, "System", "NotSupportedException");
+ RuntimeFieldHandle = new PredefinedType (module, MemberKind.Struct, "System", "RuntimeFieldHandle");
+ RuntimeMethodHandle = new PredefinedType (module, MemberKind.Struct, "System", "RuntimeMethodHandle");
+ SecurityAction = new PredefinedType (module, MemberKind.Enum, "System.Security.Permissions", "SecurityAction");
+
+ Expression = new PredefinedType (module, MemberKind.Class, "System.Linq.Expressions", "Expression");
+ ExpressionGeneric = new PredefinedType (module, MemberKind.Class, "System.Linq.Expressions", "Expression", 1);
+ ParameterExpression = new PredefinedType (module, MemberKind.Class, "System.Linq.Expressions", "ParameterExpression");
+ FieldInfo = new PredefinedType (module, MemberKind.Class, "System.Reflection", "FieldInfo");
+ MethodBase = new PredefinedType (module, MemberKind.Class, "System.Reflection", "MethodBase");
+ MethodInfo = new PredefinedType (module, MemberKind.Class, "System.Reflection", "MethodInfo");
+ ConstructorInfo = new PredefinedType (module, MemberKind.Class, "System.Reflection", "ConstructorInfo");
+
+ CallSite = new PredefinedType (module, MemberKind.Class, "System.Runtime.CompilerServices", "CallSite");
+ CallSiteGeneric = new PredefinedType (module, MemberKind.Class, "System.Runtime.CompilerServices", "CallSite", 1);
+ Binder = new PredefinedType (module, MemberKind.Class, "Microsoft.CSharp.RuntimeBinder", "Binder");
+ BinderFlags = new PredefinedType (module, MemberKind.Enum, "Microsoft.CSharp.RuntimeBinder", "CSharpBinderFlags");
+
+ //
+ // Define types which are used for comparison. It does not matter
+ // if they don't exist as no error report is needed
+ //
+ TypedReference.Define ();
+ ArgIterator.Define ();
+ MarshalByRefObject.Define ();
+ CharSet.Define ();
+
+ IEnumerableGeneric.Define ();
+ IListGeneric.Define ();
+ ICollectionGeneric.Define ();
+ IEnumerableGeneric.Define ();
+ IEnumeratorGeneric.Define ();
+ Nullable.Define ();
+ ExpressionGeneric.Define ();
+
+ // Deal with obsolete static types
+ // TODO: remove
+ TypeManager.typed_reference_type = TypedReference.TypeSpec;
+ TypeManager.arg_iterator_type = ArgIterator.TypeSpec;
+ TypeManager.mbr_type = MarshalByRefObject.TypeSpec;
+ TypeManager.generic_ilist_type = IListGeneric.TypeSpec;
+ TypeManager.generic_icollection_type = ICollectionGeneric.TypeSpec;
+ TypeManager.generic_ienumerator_type = IEnumeratorGeneric.TypeSpec;
+ TypeManager.generic_ienumerable_type = IEnumerableGeneric.TypeSpec;
+ TypeManager.generic_nullable_type = Nullable.TypeSpec;
+ TypeManager.expression_type = ExpressionGeneric.TypeSpec;
+ }
+ }
+
+ public class PredefinedType
+ {
+ string name;
+ string ns;
+ int arity;
+ MemberKind kind;
+ protected readonly ModuleContainer module;
+ protected TypeSpec type;
+
+ public PredefinedType (ModuleContainer module, MemberKind kind, string ns, string name, int arity)
+ : this (module, kind, ns, name)
+ {
+ this.arity = arity;
+ }
+
+ public PredefinedType (ModuleContainer module, MemberKind kind, string ns, string name)
+ {
+ this.module = module;
+ this.kind = kind;
+ this.name = name;
+ this.ns = ns;
+ }
+
+ #region Properties
+
+ public int Arity {
+ get {
+ return arity;
+ }
+ }
+
+ public bool IsDefined {
+ get {
+ return type != null;
+ }
+ }
+
+ public string Name {
+ get {
+ return name;
+ }
+ }
+
+ public string Namespace {
+ get {
+ return ns;
+ }
+ }
+
+ public TypeSpec TypeSpec {
+ get {
+ return type;
+ }
+ }
+
+ #endregion
+
+ public bool Define ()
+ {
+ if (type != null)
+ return true;
+
+ Namespace type_ns = module.GlobalRootNamespace.GetNamespace (ns, true);
+ var te = type_ns.LookupType (module, name, arity, true, Location.Null);
+ if (te == null)
+ return false;
+
+ if (te.Type.Kind != kind)
+ return false;
+
+ type = te.Type;
+ return true;
+ }
+
+ public FieldSpec GetField (string name, TypeSpec memberType, Location loc)
+ {
+ return TypeManager.GetPredefinedField (type, name, loc, memberType);
+ }
+
+ public string GetSignatureForError ()
+ {
+ return ns + "." + name;
+ }
+
+ public static TypeSpec Resolve (ModuleContainer module, MemberKind kind, string ns, string name, int arity, Location loc)
+ {
+ Namespace type_ns = module.GlobalRootNamespace.GetNamespace (ns, true);
+ var te = type_ns.LookupType (module, name, arity, false, Location.Null);
+ if (te == null) {
+ module.Compiler.Report.Error (518, loc, "The predefined type `{0}.{1}' is not defined or imported", ns, name);
+ return null;
+ }
+
+ var type = te.Type;
+ if (type.Kind != kind) {
+ if (type.Kind == MemberKind.Struct && kind == MemberKind.Void && type.MemberDefinition is TypeContainer) {
+ // Void is declared as struct but we keep it internally as
+ // special kind, the swap will happen at caller
+ } else {
+ module.Compiler.Report.Error (520, loc, "The predefined type `{0}.{1}' is not declared correctly", ns, name);
+ return null;
+ }
+ }
+
+ return type;
+ }
+
+ public TypeSpec Resolve (Location loc)
+ {
+ if (type == null)
+ type = Resolve (module, kind, ns, name, arity, loc);
+
+ return type;
+ }
+ }
partial class TypeManager {
//
// A list of core types that the compiler requires or uses
//
- static public PredefinedTypeSpec object_type;
- static public PredefinedTypeSpec value_type;
- static public PredefinedTypeSpec string_type;
- static public PredefinedTypeSpec int32_type;
- static public PredefinedTypeSpec uint32_type;
- static public PredefinedTypeSpec int64_type;
- static public PredefinedTypeSpec uint64_type;
- static public PredefinedTypeSpec float_type;
- static public PredefinedTypeSpec double_type;
- static public PredefinedTypeSpec char_type;
- static public PredefinedTypeSpec short_type;
- static public PredefinedTypeSpec decimal_type;
- static public PredefinedTypeSpec bool_type;
- static public PredefinedTypeSpec sbyte_type;
- static public PredefinedTypeSpec byte_type;
- static public PredefinedTypeSpec ushort_type;
- static public PredefinedTypeSpec enum_type;
- static public PredefinedTypeSpec delegate_type;
- static public PredefinedTypeSpec multicast_delegate_type;
- static public PredefinedTypeSpec void_type;
- static public PredefinedTypeSpec array_type;
- static public PredefinedTypeSpec runtime_handle_type;
- static public PredefinedTypeSpec type_type;
- static public PredefinedTypeSpec ienumerator_type;
- static public PredefinedTypeSpec ienumerable_type;
- static public PredefinedTypeSpec idisposable_type;
- static public PredefinedTypeSpec intptr_type;
- static public PredefinedTypeSpec uintptr_type;
- static public PredefinedTypeSpec runtime_field_handle_type;
- static public PredefinedTypeSpec attribute_type;
- static public PredefinedTypeSpec exception_type;
-
-
- static public TypeSpec null_type;
+ static public BuildinTypeSpec object_type;
+ static public BuildinTypeSpec value_type;
+ static public BuildinTypeSpec string_type;
+ static public BuildinTypeSpec int32_type;
+ static public BuildinTypeSpec uint32_type;
+ static public BuildinTypeSpec int64_type;
+ static public BuildinTypeSpec uint64_type;
+ static public BuildinTypeSpec float_type;
+ static public BuildinTypeSpec double_type;
+ static public BuildinTypeSpec char_type;
+ static public BuildinTypeSpec short_type;
+ static public BuildinTypeSpec decimal_type;
+ static public BuildinTypeSpec bool_type;
+ static public BuildinTypeSpec sbyte_type;
+ static public BuildinTypeSpec byte_type;
+ static public BuildinTypeSpec ushort_type;
+ static public BuildinTypeSpec delegate_type;
+ static public BuildinTypeSpec multicast_delegate_type;
+ static public BuildinTypeSpec void_type;
+
static public TypeSpec typed_reference_type;
static public TypeSpec arg_iterator_type;
static public TypeSpec mbr_type;
- public static TypeSpec runtime_helpers_type;
- static public TypeSpec iasyncresult_type;
- static public TypeSpec asynccallback_type;
- static public TypeSpec runtime_argument_handle_type;
- static public TypeSpec void_ptr_type;
-
- //
- // C# 2.0
- //
- static internal TypeSpec isvolatile_type;
static public TypeSpec generic_ilist_type;
static public TypeSpec generic_icollection_type;
static public TypeSpec generic_ienumerator_type;
static public TypeSpec generic_ienumerable_type;
static public TypeSpec generic_nullable_type;
-
- //
- // C# 3.0
- //
static internal TypeSpec expression_type;
- public static TypeSpec parameter_expression_type;
- public static TypeSpec fieldinfo_type;
- public static TypeSpec methodinfo_type;
- public static TypeSpec ctorinfo_type;
-
- //
- // C# 4.0
- //
- public static TypeSpec call_site_type;
- public static TypeSpec generic_call_site_type;
- public static TypeExpr binder_type;
- public static TypeSpec binder_flags;
-
- public static TypeExpr expression_type_expr;
-
//
// These methods are called by code generated by the compiler
static public MethodSpec delegate_remove_delegate_delegate;
static public PropertySpec int_get_offset_to_string_data;
static public MethodSpec int_interlocked_compare_exchange;
+ public static MethodSpec gen_interlocked_compare_exchange;
static public PropertySpec ienumerator_getcurrent;
public static MethodSpec methodbase_get_type_from_handle;
public static MethodSpec methodbase_get_type_from_handle_generic;
static public MethodSpec void_decimal_ctor_int_arg;
public static MethodSpec void_decimal_ctor_long_arg;
- static Dictionary<Assembly, bool> assembly_internals_vis_attrs;
-
static TypeManager ()
{
Reset ();
{
// object_type = null;
- assembly_internals_vis_attrs = new Dictionary<Assembly, bool> ();
-
// TODO: I am really bored by all this static stuff
system_type_get_type_from_handle =
bool_movenext_void =
void_monitor_exit_object =
void_initializearray_array_fieldhandle =
int_interlocked_compare_exchange =
+ gen_interlocked_compare_exchange =
methodbase_get_type_from_handle =
methodbase_get_type_from_handle_generic =
fieldinfo_get_field_from_handle =
string_empty = null;
- call_site_type =
- generic_call_site_type =
- binder_flags = null;
-
- binder_type = null;
-
typed_reference_type = arg_iterator_type = mbr_type =
- runtime_helpers_type = iasyncresult_type = asynccallback_type =
- runtime_argument_handle_type = void_ptr_type = isvolatile_type =
generic_ilist_type = generic_icollection_type = generic_ienumerator_type =
- generic_ienumerable_type = generic_nullable_type = expression_type =
- parameter_expression_type = fieldinfo_type = methodinfo_type = ctorinfo_type = null;
-
- expression_type_expr = null;
+ generic_ienumerable_type = generic_nullable_type = expression_type = null;
}
/// <summary>
return mb.GetSignatureForError ();
}
- //
- // Looks up a type, and aborts if it is not found. This is used
- // by predefined types required by the compiler
- //
- public static TypeSpec CoreLookupType (CompilerContext ctx, string ns_name, string name, MemberKind kind, bool required)
- {
- return CoreLookupType (ctx, ns_name, name, 0, kind, required);
- }
-
- public static TypeSpec CoreLookupType (CompilerContext ctx, string ns_name, string name, int arity, MemberKind kind, bool required)
- {
- Namespace ns = GlobalRootNamespace.Instance.GetNamespace (ns_name, true);
- var te = ns.LookupType (ctx, name, arity, !required, Location.Null);
- var ts = te == null ? null : te.Type;
-
- if (!required)
- return ts;
-
- if (ts == null) {
- ctx.Report.Error (518, "The predefined type `{0}.{1}' is not defined or imported",
- ns_name, name);
- return null;
- }
-
- if (ts.Kind != kind) {
- ctx.Report.Error (520, "The predefined type `{0}.{1}' is not declared correctly",
- ns_name, name);
- return null;
- }
-
- return ts;
- }
-
- static MemberSpec GetPredefinedMember (TypeSpec t, MemberFilter filter, Location loc)
+ static MemberSpec GetPredefinedMember (TypeSpec t, MemberFilter filter, bool optional, Location loc)
{
var member = MemberCache.FindMember (t, filter, BindingRestriction.DeclaredOnly);
if (member != null && member.IsAccessible (InternalType.FakeInternalType))
return member;
+ if (optional)
+ return member;
+
string method_args = null;
if (filter.Parameters != null)
method_args = filter.Parameters.GetSignatureForError ();
public static MethodSpec GetPredefinedConstructor (TypeSpec t, Location loc, params TypeSpec [] args)
{
var pc = ParametersCompiled.CreateFullyResolved (args);
- return GetPredefinedMember (t, MemberFilter.Constructor (pc), loc) as MethodSpec;
+ return GetPredefinedMember (t, MemberFilter.Constructor (pc), false, loc) as MethodSpec;
}
//
public static MethodSpec GetPredefinedMethod (TypeSpec t, string name, Location loc, params TypeSpec [] args)
{
var pc = ParametersCompiled.CreateFullyResolved (args);
- return GetPredefinedMethod (t, MemberFilter.Method (name, 0, pc, null), loc);
+ return GetPredefinedMethod (t, MemberFilter.Method (name, 0, pc, null), false, loc);
}
public static MethodSpec GetPredefinedMethod (TypeSpec t, MemberFilter filter, Location loc)
{
- return GetPredefinedMember (t, filter, loc) as MethodSpec;
- }
-
- public static FieldSpec GetPredefinedField (TypeSpec t, string name, Location loc, TypeSpec type)
- {
- return GetPredefinedMember (t, MemberFilter.Field (name, type), loc) as FieldSpec;
- }
-
- public static PropertySpec GetPredefinedProperty (TypeSpec t, string name, Location loc, TypeSpec type)
- {
- return GetPredefinedMember (t, MemberFilter.Property (name, type), loc) as PropertySpec;
- }
-
- public static IList<PredefinedTypeSpec> InitCoreTypes ()
- {
- var core_types = new PredefinedTypeSpec[] {
- object_type = new PredefinedTypeSpec (MemberKind.Class, "System", "Object"),
- value_type = new PredefinedTypeSpec (MemberKind.Class, "System", "ValueType"),
- attribute_type = new PredefinedTypeSpec (MemberKind.Class, "System", "Attribute"),
-
- int32_type = new PredefinedTypeSpec (MemberKind.Struct, "System", "Int32"),
- int64_type = new PredefinedTypeSpec (MemberKind.Struct, "System", "Int64"),
- uint32_type = new PredefinedTypeSpec (MemberKind.Struct, "System", "UInt32"),
- uint64_type = new PredefinedTypeSpec (MemberKind.Struct, "System", "UInt64"),
- byte_type = new PredefinedTypeSpec (MemberKind.Struct, "System", "Byte"),
- sbyte_type = new PredefinedTypeSpec (MemberKind.Struct, "System", "SByte"),
- short_type = new PredefinedTypeSpec (MemberKind.Struct, "System", "Int16"),
- ushort_type = new PredefinedTypeSpec (MemberKind.Struct, "System", "UInt16"),
-
- ienumerator_type = new PredefinedTypeSpec (MemberKind.Interface, "System.Collections", "IEnumerator"),
- ienumerable_type = new PredefinedTypeSpec (MemberKind.Interface, "System.Collections", "IEnumerable"),
- idisposable_type = new PredefinedTypeSpec (MemberKind.Interface, "System", "IDisposable"),
-
- char_type = new PredefinedTypeSpec (MemberKind.Struct, "System", "Char"),
- string_type = new PredefinedTypeSpec (MemberKind.Class, "System", "String"),
- float_type = new PredefinedTypeSpec (MemberKind.Struct, "System", "Single"),
- double_type = new PredefinedTypeSpec (MemberKind.Struct, "System", "Double"),
- decimal_type = new PredefinedTypeSpec (MemberKind.Struct, "System", "Decimal"),
- bool_type = new PredefinedTypeSpec (MemberKind.Struct, "System", "Boolean"),
- intptr_type = new PredefinedTypeSpec (MemberKind.Struct, "System", "IntPtr"),
- uintptr_type = new PredefinedTypeSpec (MemberKind.Struct, "System", "UIntPtr"),
-
- multicast_delegate_type = new PredefinedTypeSpec (MemberKind.Class, "System", "MulticastDelegate"),
- delegate_type = new PredefinedTypeSpec (MemberKind.Class, "System", "Delegate"),
- enum_type = new PredefinedTypeSpec (MemberKind.Class, "System", "Enum"),
- array_type = new PredefinedTypeSpec (MemberKind.Class, "System", "Array"),
- void_type = new PredefinedTypeSpec (MemberKind.Struct, "System", "Void"),
- type_type = new PredefinedTypeSpec (MemberKind.Class, "System", "Type"),
- exception_type = new PredefinedTypeSpec (MemberKind.Class, "System", "Exception"),
- runtime_field_handle_type = new PredefinedTypeSpec (MemberKind.Struct, "System", "RuntimeFieldHandle"),
- runtime_handle_type = new PredefinedTypeSpec (MemberKind.Struct, "System", "RuntimeTypeHandle"),
- };
-
- return core_types;
- }
-
- /// <remarks>
- /// The types have to be initialized after the initial
- /// population of the type has happened (for example, to
- /// bootstrap the corlib.dll
- /// </remarks>
- public static bool InitCoreTypes (CompilerContext ctx, IList<PredefinedTypeSpec> predefined)
- {
- foreach (var p in predefined) {
- var found = CoreLookupType (ctx, p.Namespace, p.Name, p.Kind, true);
- if (found == null || found == p)
- continue;
-
- if (!RootContext.StdLib) {
- var ns = GlobalRootNamespace.Instance.GetNamespace (p.Namespace, false);
- ns.ReplaceTypeWithPredefined (found, p);
-
- var tc = found.MemberDefinition as TypeContainer;
- tc.SetPredefinedSpec (p);
- p.SetDefinition (found);
- }
- }
-
- PredefinedAttributes.Get.ParamArray.Initialize (ctx, false);
- PredefinedAttributes.Get.Out.Initialize (ctx, false);
-
- return ctx.Report.Errors == 0;
+ return GetPredefinedMethod (t, filter, false, loc);
}
- //
- // Initializes optional core types
- //
- public static void InitOptionalCoreTypes (CompilerContext ctx)
+ public static MethodSpec GetPredefinedMethod (TypeSpec t, MemberFilter filter, bool optional, Location loc)
{
- //
- // These are only used for compare purposes
- //
- null_type = InternalType.Null;
-
- void_ptr_type = PointerContainer.MakeType (void_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.
- //
- PredefinedAttributes.Get.Initialize (ctx);
-
- runtime_argument_handle_type = CoreLookupType (ctx, "System", "RuntimeArgumentHandle", MemberKind.Struct, false);
- asynccallback_type = CoreLookupType (ctx, "System", "AsyncCallback", MemberKind.Delegate, false);
- iasyncresult_type = CoreLookupType (ctx, "System", "IAsyncResult", MemberKind.Interface, false);
- typed_reference_type = CoreLookupType (ctx, "System", "TypedReference", MemberKind.Struct, false);
- arg_iterator_type = CoreLookupType (ctx, "System", "ArgIterator", MemberKind.Struct, false);
- mbr_type = CoreLookupType (ctx, "System", "MarshalByRefObject", MemberKind.Class, false);
-
- generic_ienumerator_type = CoreLookupType (ctx, "System.Collections.Generic", "IEnumerator", 1, MemberKind.Interface, false);
- generic_ilist_type = CoreLookupType (ctx, "System.Collections.Generic", "IList", 1, MemberKind.Interface, false);
- generic_icollection_type = CoreLookupType (ctx, "System.Collections.Generic", "ICollection", 1, MemberKind.Interface, false);
- generic_ienumerable_type = CoreLookupType (ctx, "System.Collections.Generic", "IEnumerable", 1, MemberKind.Interface, false);
- generic_nullable_type = CoreLookupType (ctx, "System", "Nullable", 1, MemberKind.Struct, false);
-
- //
- // Optional types which are used as types and for member lookup
- //
- runtime_helpers_type = CoreLookupType (ctx, "System.Runtime.CompilerServices", "RuntimeHelpers", MemberKind.Class, false);
-
- // New in .NET 3.5
- // Note: extension_attribute_type is already loaded
- expression_type = CoreLookupType (ctx, "System.Linq.Expressions", "Expression", 1, MemberKind.Class, false);
+ return GetPredefinedMember (t, filter, optional, loc) as MethodSpec;
}
- public static bool IsBuiltinType (TypeSpec t)
+ public static FieldSpec GetPredefinedField (TypeSpec t, string name, Location loc, TypeSpec type)
{
- if (t == object_type || t == string_type || t == int32_type || t == uint32_type ||
- t == int64_type || t == uint64_type || t == float_type || t == double_type ||
- t == char_type || t == short_type || t == decimal_type || t == bool_type ||
- t == sbyte_type || t == byte_type || t == ushort_type || t == void_type)
- return true;
- else
- return false;
+ return GetPredefinedMember (t, MemberFilter.Field (name, type), false, loc) as FieldSpec;
}
- //
- // This is like IsBuiltinType, but lacks decimal_type, we should also clean up
- // the pieces in the code where we use IsBuiltinType and special case decimal_type.
- //
- public static bool IsPrimitiveType (TypeSpec t)
+ public static PropertySpec GetPredefinedProperty (TypeSpec t, string name, Location loc, TypeSpec type)
{
- return (t == int32_type || t == uint32_type ||
- t == int64_type || t == uint64_type || t == float_type || t == double_type ||
- t == char_type || t == short_type || t == bool_type ||
- t == sbyte_type || t == byte_type || t == ushort_type);
+ return GetPredefinedMember (t, MemberFilter.Property (name, type), false, loc) as PropertySpec;
}
// Obsolete
{
return t.IsDelegate;
}
-
- //
- // When any element of the type is a dynamic type
- //
- // This method builds a transformation array for dynamic types
- // used in places where DynamicAttribute cannot be applied to.
- // It uses bool flag when type is of dynamic type and each
- // section always starts with "false" for some reason.
- //
- // LAMESPEC: This should be part of C# specification !
- //
- // Example: Func<dynamic, int, dynamic[]>
- // Transformation: { false, true, false, false, true }
- //
- public static bool[] HasDynamicTypeUsed (TypeSpec t)
- {
- var ac = t as ArrayContainer;
- if (ac != null) {
- if (HasDynamicTypeUsed (ac.Element) != null)
- return new bool[] { false, true };
-
- return null;
- }
-
- if (t == null)
- return null;
-
- if (IsGenericType (t)) {
- List<bool> transform = null;
- var targs = GetTypeArguments (t);
- for (int i = 0; i < targs.Length; ++i) {
- var element = HasDynamicTypeUsed (targs [i]);
- if (element != null) {
- if (transform == null) {
- transform = new List<bool> ();
- for (int ii = 0; ii <= i; ++ii)
- transform.Add (false);
- }
-
- transform.AddRange (element);
- } else if (transform != null) {
- transform.Add (false);
- }
- }
-
- if (transform != null)
- return transform.ToArray ();
- }
-
- if (object.ReferenceEquals (InternalType.Dynamic, t))
- return new bool [] { true };
-
- return null;
- }
// Obsolete
public static bool IsEnumType (TypeSpec t)
return t.IsEnum;
}
- public static bool IsBuiltinOrEnum (TypeSpec t)
- {
- if (IsBuiltinType (t))
- return true;
-
- if (IsEnumType (t))
- return true;
-
- return false;
- }
-
//
// Whether a type is unmanaged. This is used by the unsafe code (25.2)
//
if (ds != null)
return ds.IsUnmanagedType ();
- // some builtins that are not unmanaged types
- if (t == TypeManager.object_type || t == TypeManager.string_type)
- return false;
-
- if (IsBuiltinOrEnum (t))
+ if (t.Kind == MemberKind.Void)
return true;
// Someone did the work of checking if the ElementType of t is unmanaged. Let's not repeat it.
return t.IsStruct;
}
- public static bool IsSubclassOf (TypeSpec type, TypeSpec base_type)
- {
- do {
- if (type == base_type)
- return true;
-
- type = type.BaseType;
- } while (type != null);
-
- return false;
- }
-
public static bool IsFamilyAccessible (TypeSpec type, TypeSpec parent)
{
// TypeParameter tparam = LookupTypeParameter (type);
//
// Checks whether `type' is a nested child of `parent'.
//
- public static bool IsNestedChildOf (TypeSpec type, TypeSpec parent)
+ public static bool IsNestedChildOf (TypeSpec type, ITypeDefinition parent)
{
if (type == null)
return false;
- type = type.GetDefinition (); // DropGenericTypeArguments (type);
- parent = parent.GetDefinition (); // DropGenericTypeArguments (parent);
-
- if (IsEqual (type, parent))
+ if (type.MemberDefinition == parent)
return false;
type = type.DeclaringType;
while (type != null) {
- if (IsEqual (type.GetDefinition (), parent))
+ if (type.MemberDefinition == parent)
return true;
type = type.DeclaringType;
return t == arg_iterator_type || t == typed_reference_type;
}
- //
- // Checks whether `invocationAssembly' is same or a friend of the assembly
- //
- public static bool IsThisOrFriendAssembly (Assembly invocationAssembly, Assembly assembly)
- {
- if (assembly == null)
- throw new ArgumentNullException ("assembly");
-
- // TODO: This can happen for constants used at assembly level and
- // predefined members
- // But there is no way to test for it for now, so it could be abused
- // elsewhere too.
- if (invocationAssembly == null)
- invocationAssembly = CodeGen.Assembly.Builder;
-
- if (invocationAssembly == assembly)
- return true;
-
- bool value;
- if (assembly_internals_vis_attrs.TryGetValue (assembly, out value))
- return value;
-
- object[] attrs = assembly.GetCustomAttributes (typeof (InternalsVisibleToAttribute), false);
- if (attrs.Length == 0) {
- assembly_internals_vis_attrs.Add (assembly, false);
- return false;
- }
-
- bool is_friend = false;
-
- AssemblyName this_name = CodeGen.Assembly.Name;
- if (this_name == null)
- return false;
-
- byte [] this_token = this_name.GetPublicKeyToken ();
- foreach (InternalsVisibleToAttribute attr in attrs) {
- if (attr.AssemblyName == null || attr.AssemblyName.Length == 0)
- continue;
-
- AssemblyName aname = null;
- try {
- aname = new AssemblyName (attr.AssemblyName);
- } catch (FileLoadException) {
- } catch (ArgumentException) {
- }
-
- if (aname == null || aname.Name != this_name.Name)
- continue;
-
- byte [] key_token = aname.GetPublicKeyToken ();
- if (key_token != null) {
- if (this_token.Length == 0) {
- // Same name, but assembly is not strongnamed
- Error_FriendAccessNameNotMatching (aname.FullName, RootContext.ToplevelTypes.Compiler.Report);
- break;
- }
-
- if (!CompareKeyTokens (this_token, key_token))
- continue;
- }
-
- is_friend = true;
- break;
- }
-
- assembly_internals_vis_attrs.Add (assembly, is_friend);
- return is_friend;
- }
-
- static bool CompareKeyTokens (byte [] token1, byte [] token2)
- {
- for (int i = 0; i < token1.Length; i++)
- if (token1 [i] != token2 [i])
- return false;
-
- return true;
- }
-
- static void Error_FriendAccessNameNotMatching (string other_name, Report Report)
- {
- 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);
- }
-
public static TypeSpec GetElementType (TypeSpec t)
{
return ((ElementTypeSpec)t).Element;
return t is ElementTypeSpec;
}
- static NumberFormatInfo nf_provider = CultureInfo.CurrentCulture.NumberFormat;
-
- // This is a custom version of Convert.ChangeType() which works
- // with the TypeBuilder defined types when compiling corlib.
- public static object ChangeType (object value, TypeSpec targetType, out bool error)
- {
- IConvertible convert_value = value as IConvertible;
-
- if (convert_value == null){
- error = true;
- return null;
- }
-
- //
- // We cannot rely on build-in type conversions as they are
- // more limited than what C# supports.
- // See char -> float/decimal/double conversion
- //
- error = false;
- try {
- if (targetType == TypeManager.bool_type)
- return convert_value.ToBoolean (nf_provider);
- if (targetType == TypeManager.byte_type)
- return convert_value.ToByte (nf_provider);
- if (targetType == TypeManager.char_type)
- return convert_value.ToChar (nf_provider);
- if (targetType == TypeManager.short_type)
- return convert_value.ToInt16 (nf_provider);
- if (targetType == TypeManager.int32_type)
- return convert_value.ToInt32 (nf_provider);
- if (targetType == TypeManager.int64_type)
- return convert_value.ToInt64 (nf_provider);
- if (targetType == TypeManager.sbyte_type)
- return convert_value.ToSByte (nf_provider);
-
- if (targetType == TypeManager.decimal_type) {
- if (convert_value.GetType () == typeof (char))
- return (decimal) convert_value.ToInt32 (nf_provider);
- return convert_value.ToDecimal (nf_provider);
- }
-
- if (targetType == TypeManager.double_type) {
- if (convert_value.GetType () == typeof (char))
- return (double) convert_value.ToInt32 (nf_provider);
- return convert_value.ToDouble (nf_provider);
- }
-
- if (targetType == TypeManager.float_type) {
- if (convert_value.GetType () == typeof (char))
- return (float)convert_value.ToInt32 (nf_provider);
- return convert_value.ToSingle (nf_provider);
- }
-
- if (targetType == TypeManager.string_type)
- return convert_value.ToString (nf_provider);
- if (targetType == TypeManager.ushort_type)
- return convert_value.ToUInt16 (nf_provider);
- if (targetType == TypeManager.uint32_type)
- return convert_value.ToUInt32 (nf_provider);
- if (targetType == TypeManager.uint64_type)
- return convert_value.ToUInt64 (nf_provider);
- if (targetType == TypeManager.object_type)
- return value;
-
- error = true;
- } catch {
- error = true;
- }
- return null;
- }
-
/// <summary>
/// Utility function that can be used to probe whether a type
/// is managed or not.
/// </summary>
- public static bool VerifyUnmanaged (CompilerContext ctx, TypeSpec t, Location loc)
+ public static bool VerifyUnmanaged (ModuleContainer rc, TypeSpec t, Location loc)
{
while (t.IsPointer)
t = GetElementType (t);
if (IsUnmanagedType (t))
return true;
- ctx.Report.SymbolRelatedToPreviousError (t);
- ctx.Report.Error (208, loc,
+ rc.Compiler.Report.SymbolRelatedToPreviousError (t);
+ rc.Compiler.Report.Error (208, loc,
"Cannot take the address of, get the size of, or declare a pointer to a managed type `{0}'",
CSharpName (t));
return type.IsGeneric;
}
- // TODO: Implement correctly
- public static bool ContainsGenericParameters (TypeSpec type)
- {
- return type.GetMetaInfo ().ContainsGenericParameters;
- }
-
- public static bool IsEqual (TypeSpec a, TypeSpec b)
- {
- return a == b && !(a is InternalType);
- }
-
public static TypeSpec[] GetTypeArguments (TypeSpec t)
{
// TODO: return empty array !!
projects / mono.git / blobdiff