public void SymbolRelatedToPreviousError(Type type)
{
if (reporting_disabled > 0 || !printer.HasRelatedSymbolSupport)
{
return;
}
type = TypeManager.DropGenericTypeArguments(type);
if (TypeManager.IsGenericParameter(type))
{
TypeParameter tp = TypeManager.LookupTypeParameter(type);
if (tp != null)
{
SymbolRelatedToPreviousError(tp.Location, "");
return;
}
}
if (type is TypeBuilder)
{
DeclSpace temp_ds = TypeManager.LookupDeclSpace(type);
SymbolRelatedToPreviousError(temp_ds.Location, TypeManager.CSharpName(type));
}
else if (TypeManager.HasElementType(type))
{
SymbolRelatedToPreviousError(TypeManager.GetElementType(type));
}
else
{
SymbolRelatedToPreviousError(type.Assembly.Location, TypeManager.CSharpName(type));
}
}
public HoistedStoreyClass (TypeContainer parent, MemberName name, TypeParameter[] tparams, Modifiers mod)
: base (parent, name, mod | Modifiers.PRIVATE)
{
if (tparams != null) {
type_params = new TypeParameter[tparams.Length];
var src = new TypeParameterSpec[tparams.Length];
var dst = new TypeParameterSpec[tparams.Length];
for (int i = 0; i < type_params.Length; ++i) {
type_params[i] = tparams[i].CreateHoistedCopy (this, spec);
src[i] = tparams[i].Type;
dst[i] = type_params[i].Type;
}
// A copy is not enough, inflate any type parameter constraints
// using a new type parameters
var inflator = new TypeParameterInflator (this, null, src, dst);
for (int i = 0; i < type_params.Length; ++i) {
src[i].InflateConstraints (inflator, dst[i]);
}
mutator = new TypeParameterMutator (tparams, type_params);
}
}
public HoistedStoreyClass (DeclSpace parent, MemberName name, TypeParameter[] tparams, Modifiers mod)
: base (parent, name, mod | Modifiers.PRIVATE)
{
if (tparams != null) {
type_params = new TypeParameter[tparams.Length];
for (int i = 0; i < type_params.Length; ++i) {
type_params[i] = tparams[i].CreateHoistedCopy (this, spec);
}
}
}
protected static MemberName MakeMemberName (MemberBase host, string name, int unique_id, TypeParameter[] tparams, Location loc)
{
string host_name = host == null ? null : host.Name;
string tname = MakeName (host_name, "c", name, unique_id);
TypeArguments args = null;
if (tparams != null) {
args = new TypeArguments ();
foreach (TypeParameter tparam in tparams)
args.Add (new TypeParameterName (tparam.Name, null, loc));
}
return new MemberName (tname, args, loc);
}
public TypeParameterExpr(TypeParameter type_parameter, Location loc)
{
throw new NotImplementedException();
}
void case_355()
#line 2902 "cs-parser.jay"
{
var lt = (Tokenizer.LocatedToken)yyVals[0+yyTop];
yyVal = new TypeParameter (new MemberName (lt.Value, lt.Location), (Attributes)yyVals[-2+yyTop], (Variance) yyVals[-1+yyTop]);
}
public SimpleName (string name, TypeParameter[] type_params, Location l)
: base (name, l)
{
targs = new TypeArguments ();
foreach (TypeParameter type_param in type_params)
targs.Add (new TypeParameterExpr (type_param, l));
}
public static TypeParameter FindTypeParameter (TypeParameter[] all, string name)
{
throw new NotImplementedException ();
}
static AstType ConvertToType(TypeParameter spec)
{
AstType result;
result = new SimpleType { IdentifierToken = Identifier.Create(spec.Name, Convert(spec.Location)) };
return result;
}
public virtual void SetParameterInfo (List<Constraints> constraints_list)
{
#if FULL_AST
if (constraints_list != null) {
this.PlainConstraints = constraints_list;
constraints_list = this.Constraints = new List<Constraints> (constraints_list);
}
#else
this.Constraints = constraints_list;
#endif
if (!is_generic) {
if (constraints_list != null) {
Report.Error (
80, Location, "Constraints are not allowed " +
"on non-generic declarations");
}
return;
}
TypeParameterName[] names = MemberName.TypeArguments.GetDeclarations ();
type_params = new TypeParameter [names.Length];
//
// Register all the names
//
for (int i = 0; i < type_params.Length; i++) {
TypeParameterName name = names [i];
Constraints constraints = null;
if (constraints_list != null) {
int total = constraints_list.Count;
for (int ii = 0; ii < total; ++ii) {
Constraints constraints_at = (Constraints)constraints_list[ii];
// TODO: it is used by iterators only
if (constraints_at == null) {
constraints_list.RemoveAt (ii);
--total;
continue;
}
if (constraints_at.TypeParameter.Value == name.Name) {
constraints = constraints_at;
constraints_list.RemoveAt(ii);
break;
}
}
}
Variance variance = name.Variance;
if (name.Variance != Variance.None && !(this is Delegate || this is Interface)) {
Report.Error (1960, name.Location, "Variant type parameters can only be used with interfaces and delegates");
variance = Variance.None;
}
type_params [i] = new TypeParameter (
Parent, i, new MemberName (name.Name, Location), constraints, name.OptAttributes, variance);
AddToContainer (type_params [i], name.Name);
}
if (constraints_list != null && constraints_list.Count > 0) {
foreach (Constraints constraint in constraints_list) {
Report.Error(699, constraint.Location, "`{0}': A constraint references nonexistent type parameter `{1}'",
GetSignatureForError (), constraint.TypeParameter.Value);
}
}
}
public PredefinedMembers (ModuleContainer module)
{
var types = module.PredefinedTypes;
var atypes = module.PredefinedAttributes;
var btypes = module.Compiler.BuiltinTypes;
var tp = new TypeParameter (0, new MemberName ("T"), null, null, Variance.None);
ActivatorCreateInstance = new PredefinedMember<MethodSpec> (module, types.Activator,
MemberFilter.Method ("CreateInstance", 1, ParametersCompiled.EmptyReadOnlyParameters, null));
AsyncTaskMethodBuilderCreate = new PredefinedMember<MethodSpec> (module, types.AsyncTaskMethodBuilder,
MemberFilter.Method ("Create", 0, ParametersCompiled.EmptyReadOnlyParameters, types.AsyncTaskMethodBuilder.TypeSpec));
AsyncTaskMethodBuilderSetResult = new PredefinedMember<MethodSpec> (module, types.AsyncTaskMethodBuilder,
MemberFilter.Method ("SetResult", 0, ParametersCompiled.EmptyReadOnlyParameters, btypes.Void));
AsyncTaskMethodBuilderSetStateMachine = new PredefinedMember<MethodSpec> (module, types.AsyncTaskMethodBuilder,
"SetStateMachine", MemberKind.Method, () => new[] {
types.IAsyncStateMachine.TypeSpec
}, btypes.Void);
AsyncTaskMethodBuilderSetException = new PredefinedMember<MethodSpec> (module, types.AsyncTaskMethodBuilder,
MemberFilter.Method ("SetException", 0,
ParametersCompiled.CreateFullyResolved (btypes.Exception), btypes.Void));
AsyncTaskMethodBuilderOnCompleted = new PredefinedMember<MethodSpec> (module, types.AsyncTaskMethodBuilder,
MemberFilter.Method ("AwaitOnCompleted", 2,
new ParametersImported (
new[] {
new ParameterData (null, Parameter.Modifier.REF),
new ParameterData (null, Parameter.Modifier.REF)
},
new[] {
new TypeParameterSpec (0, tp, SpecialConstraint.None, Variance.None, null),
new TypeParameterSpec (1, tp, SpecialConstraint.None, Variance.None, null)
}, false),
btypes.Void));
AsyncTaskMethodBuilderOnCompletedUnsafe = new PredefinedMember<MethodSpec> (module, types.AsyncTaskMethodBuilder,
MemberFilter.Method ("AwaitUnsafeOnCompleted", 2,
new ParametersImported (
new[] {
new ParameterData (null, Parameter.Modifier.REF),
new ParameterData (null, Parameter.Modifier.REF)
},
new[] {
new TypeParameterSpec (0, tp, SpecialConstraint.None, Variance.None, null),
new TypeParameterSpec (1, tp, SpecialConstraint.None, Variance.None, null)
}, false),
btypes.Void));
AsyncTaskMethodBuilderStart = new PredefinedMember<MethodSpec> (module, types.AsyncTaskMethodBuilder,
MemberFilter.Method ("Start", 1,
new ParametersImported (
new[] {
new ParameterData (null, Parameter.Modifier.REF),
},
new[] {
new TypeParameterSpec (0, tp, SpecialConstraint.None, Variance.None, null),
}, false),
btypes.Void));
AsyncTaskMethodBuilderTask = new PredefinedMember<PropertySpec> (module, types.AsyncTaskMethodBuilder,
MemberFilter.Property ("Task", null));
AsyncTaskMethodBuilderGenericCreate = new PredefinedMember<MethodSpec> (module, types.AsyncTaskMethodBuilderGeneric,
MemberFilter.Method ("Create", 0, ParametersCompiled.EmptyReadOnlyParameters, types.AsyncVoidMethodBuilder.TypeSpec));
AsyncTaskMethodBuilderGenericSetResult = new PredefinedMember<MethodSpec> (module, types.AsyncTaskMethodBuilderGeneric,
"SetResult", MemberKind.Method, () => new TypeSpec[] {
types.AsyncTaskMethodBuilderGeneric.TypeSpec.MemberDefinition.TypeParameters[0]
}, btypes.Void);
AsyncTaskMethodBuilderGenericSetStateMachine = new PredefinedMember<MethodSpec> (module, types.AsyncTaskMethodBuilderGeneric,
"SetStateMachine", MemberKind.Method, () => new[] {
types.IAsyncStateMachine.TypeSpec
}, btypes.Void);
AsyncTaskMethodBuilderGenericSetException = new PredefinedMember<MethodSpec> (module, types.AsyncTaskMethodBuilderGeneric,
MemberFilter.Method ("SetException", 0,
ParametersCompiled.CreateFullyResolved (btypes.Exception), btypes.Void));
AsyncTaskMethodBuilderGenericOnCompleted = new PredefinedMember<MethodSpec> (module, types.AsyncTaskMethodBuilderGeneric,
MemberFilter.Method ("AwaitOnCompleted", 2,
new ParametersImported (
new[] {
new ParameterData (null, Parameter.Modifier.REF),
new ParameterData (null, Parameter.Modifier.REF)
},
new[] {
new TypeParameterSpec (0, tp, SpecialConstraint.None, Variance.None, null),
new TypeParameterSpec (1, tp, SpecialConstraint.None, Variance.None, null)
}, false),
btypes.Void));
AsyncTaskMethodBuilderGenericOnCompletedUnsafe = new PredefinedMember<MethodSpec> (module, types.AsyncTaskMethodBuilderGeneric,
MemberFilter.Method ("AwaitUnsafeOnCompleted", 2,
new ParametersImported (
new[] {
new ParameterData (null, Parameter.Modifier.REF),
new ParameterData (null, Parameter.Modifier.REF)
},
new[] {
new TypeParameterSpec (0, tp, SpecialConstraint.None, Variance.None, null),
new TypeParameterSpec (1, tp, SpecialConstraint.None, Variance.None, null)
}, false),
btypes.Void));
AsyncTaskMethodBuilderGenericStart = new PredefinedMember<MethodSpec> (module, types.AsyncTaskMethodBuilderGeneric,
MemberFilter.Method ("Start", 1,
new ParametersImported (
new[] {
new ParameterData (null, Parameter.Modifier.REF),
},
new[] {
new TypeParameterSpec (0, tp, SpecialConstraint.None, Variance.None, null),
}, false),
btypes.Void));
AsyncTaskMethodBuilderGenericTask = new PredefinedMember<PropertySpec> (module, types.AsyncTaskMethodBuilderGeneric,
MemberFilter.Property ("Task", null));
AsyncVoidMethodBuilderCreate = new PredefinedMember<MethodSpec> (module, types.AsyncVoidMethodBuilder,
MemberFilter.Method ("Create", 0, ParametersCompiled.EmptyReadOnlyParameters, types.AsyncVoidMethodBuilder.TypeSpec));
AsyncVoidMethodBuilderSetException = new PredefinedMember<MethodSpec> (module, types.AsyncVoidMethodBuilder,
MemberFilter.Method ("SetException", 0, null, btypes.Void));
AsyncVoidMethodBuilderSetResult = new PredefinedMember<MethodSpec> (module, types.AsyncVoidMethodBuilder,
MemberFilter.Method ("SetResult", 0, ParametersCompiled.EmptyReadOnlyParameters, btypes.Void));
AsyncVoidMethodBuilderSetStateMachine = new PredefinedMember<MethodSpec> (module, types.AsyncVoidMethodBuilder,
"SetStateMachine", MemberKind.Method, () => new[] {
types.IAsyncStateMachine.TypeSpec
}, btypes.Void);
AsyncVoidMethodBuilderOnCompleted = new PredefinedMember<MethodSpec> (module, types.AsyncVoidMethodBuilder,
MemberFilter.Method ("AwaitOnCompleted", 2,
new ParametersImported (
new[] {
new ParameterData (null, Parameter.Modifier.REF),
new ParameterData (null, Parameter.Modifier.REF)
},
new[] {
new TypeParameterSpec (0, tp, SpecialConstraint.None, Variance.None, null),
new TypeParameterSpec (1, tp, SpecialConstraint.None, Variance.None, null)
}, false),
btypes.Void));
AsyncVoidMethodBuilderOnCompletedUnsafe = new PredefinedMember<MethodSpec> (module, types.AsyncVoidMethodBuilder,
MemberFilter.Method ("AwaitUnsafeOnCompleted", 2,
new ParametersImported (
new[] {
new ParameterData (null, Parameter.Modifier.REF),
new ParameterData (null, Parameter.Modifier.REF)
},
new[] {
new TypeParameterSpec (0, tp, SpecialConstraint.None, Variance.None, null),
new TypeParameterSpec (1, tp, SpecialConstraint.None, Variance.None, null)
}, false),
btypes.Void));
AsyncVoidMethodBuilderStart = new PredefinedMember<MethodSpec> (module, types.AsyncVoidMethodBuilder,
MemberFilter.Method ("Start", 1,
new ParametersImported (
new[] {
new ParameterData (null, Parameter.Modifier.REF),
},
new[] {
new TypeParameterSpec (0, tp, SpecialConstraint.None, Variance.None, null),
}, false),
btypes.Void));
AsyncStateMachineAttributeCtor = new PredefinedMember<MethodSpec> (module, atypes.AsyncStateMachine,
MemberFilter.Constructor (ParametersCompiled.CreateFullyResolved (
btypes.Type)));
DebuggerBrowsableAttributeCtor = new PredefinedMember<MethodSpec> (module, atypes.DebuggerBrowsable,
MemberFilter.Constructor (null));
DecimalCtor = new PredefinedMember<MethodSpec> (module, btypes.Decimal,
MemberFilter.Constructor (ParametersCompiled.CreateFullyResolved (
btypes.Int, btypes.Int, btypes.Int, btypes.Bool, btypes.Byte)));
DecimalCtorInt = new PredefinedMember<MethodSpec> (module, btypes.Decimal,
MemberFilter.Constructor (ParametersCompiled.CreateFullyResolved (btypes.Int)));
DecimalCtorLong = new PredefinedMember<MethodSpec> (module, btypes.Decimal,
MemberFilter.Constructor (ParametersCompiled.CreateFullyResolved (btypes.Long)));
DecimalConstantAttributeCtor = new PredefinedMember<MethodSpec> (module, atypes.DecimalConstant,
MemberFilter.Constructor (ParametersCompiled.CreateFullyResolved (
btypes.Byte, btypes.Byte, btypes.UInt, btypes.UInt, btypes.UInt)));
DefaultMemberAttributeCtor = new PredefinedMember<MethodSpec> (module, atypes.DefaultMember,
MemberFilter.Constructor (ParametersCompiled.CreateFullyResolved (btypes.String)));
DelegateCombine = new PredefinedMember<MethodSpec> (module, btypes.Delegate, "Combine", btypes.Delegate, btypes.Delegate);
DelegateRemove = new PredefinedMember<MethodSpec> (module, btypes.Delegate, "Remove", btypes.Delegate, btypes.Delegate);
DelegateEqual = new PredefinedMember<MethodSpec> (module, btypes.Delegate,
new MemberFilter (Operator.GetMetadataName (Operator.OpType.Equality), 0, MemberKind.Operator, null, btypes.Bool));
DelegateInequal = new PredefinedMember<MethodSpec> (module, btypes.Delegate,
new MemberFilter (Operator.GetMetadataName (Operator.OpType.Inequality), 0, MemberKind.Operator, null, btypes.Bool));
DynamicAttributeCtor = new PredefinedMember<MethodSpec> (module, atypes.Dynamic,
MemberFilter.Constructor (ParametersCompiled.CreateFullyResolved (
ArrayContainer.MakeType (module, btypes.Bool))));
FieldInfoGetFieldFromHandle = new PredefinedMember<MethodSpec> (module, types.FieldInfo,
"GetFieldFromHandle", MemberKind.Method, types.RuntimeFieldHandle);
FieldInfoGetFieldFromHandle2 = new PredefinedMember<MethodSpec> (module, types.FieldInfo,
"GetFieldFromHandle", MemberKind.Method, types.RuntimeFieldHandle, new PredefinedType (btypes.RuntimeTypeHandle));
FixedBufferAttributeCtor = new PredefinedMember<MethodSpec> (module, atypes.FixedBuffer,
MemberFilter.Constructor (ParametersCompiled.CreateFullyResolved (btypes.Type, btypes.Int)));
IDisposableDispose = new PredefinedMember<MethodSpec> (module, btypes.IDisposable, "Dispose", TypeSpec.EmptyTypes);
IEnumerableGetEnumerator = new PredefinedMember<MethodSpec> (module, btypes.IEnumerable,
"GetEnumerator", TypeSpec.EmptyTypes);
InterlockedCompareExchange = new PredefinedMember<MethodSpec> (module, types.Interlocked,
MemberFilter.Method ("CompareExchange", 0,
new ParametersImported (
new[] {
new ParameterData (null, Parameter.Modifier.REF),
new ParameterData (null, Parameter.Modifier.NONE),
new ParameterData (null, Parameter.Modifier.NONE)
},
new[] {
btypes.Int, btypes.Int, btypes.Int
},
false),
btypes.Int));
InterlockedCompareExchange_T = new PredefinedMember<MethodSpec> (module, types.Interlocked,
MemberFilter.Method ("CompareExchange", 1,
new ParametersImported (
new[] {
new ParameterData (null, Parameter.Modifier.REF),
new ParameterData (null, Parameter.Modifier.NONE),
new ParameterData (null, Parameter.Modifier.NONE)
},
new[] {
new TypeParameterSpec (0, tp, SpecialConstraint.None, Variance.None, null),
new TypeParameterSpec (0, tp, SpecialConstraint.None, Variance.None, null),
new TypeParameterSpec (0, tp, SpecialConstraint.None, Variance.None, null),
}, false),
null));
MethodInfoGetMethodFromHandle = new PredefinedMember<MethodSpec> (module, types.MethodBase,
"GetMethodFromHandle", MemberKind.Method, types.RuntimeMethodHandle);
MethodInfoGetMethodFromHandle2 = new PredefinedMember<MethodSpec> (module, types.MethodBase,
"GetMethodFromHandle", MemberKind.Method, types.RuntimeMethodHandle, new PredefinedType (btypes.RuntimeTypeHandle));
MonitorEnter = new PredefinedMember<MethodSpec> (module, types.Monitor, "Enter", btypes.Object);
MonitorEnter_v4 = new PredefinedMember<MethodSpec> (module, types.Monitor,
MemberFilter.Method ("Enter", 0,
new ParametersImported (new[] {
new ParameterData (null, Parameter.Modifier.NONE),
new ParameterData (null, Parameter.Modifier.REF)
},
new[] {
btypes.Object, btypes.Bool
}, false), null));
MonitorExit = new PredefinedMember<MethodSpec> (module, types.Monitor, "Exit", btypes.Object);
RuntimeCompatibilityWrapNonExceptionThrows = new PredefinedMember<PropertySpec> (module, atypes.RuntimeCompatibility,
MemberFilter.Property ("WrapNonExceptionThrows", btypes.Bool));
RuntimeHelpersInitializeArray = new PredefinedMember<MethodSpec> (module, types.RuntimeHelpers,
"InitializeArray", btypes.Array, btypes.RuntimeFieldHandle);
RuntimeHelpersOffsetToStringData = new PredefinedMember<PropertySpec> (module, types.RuntimeHelpers,
MemberFilter.Property ("OffsetToStringData", btypes.Int));
SecurityActionRequestMinimum = new PredefinedMember<ConstSpec> (module, types.SecurityAction, "RequestMinimum",
MemberKind.Field, types.SecurityAction);
StringEmpty = new PredefinedMember<FieldSpec> (module, btypes.String, MemberFilter.Field ("Empty", btypes.String));
StringEqual = new PredefinedMember<MethodSpec> (module, btypes.String,
new MemberFilter (Operator.GetMetadataName (Operator.OpType.Equality), 0, MemberKind.Operator, null, btypes.Bool));
StringInequal = new PredefinedMember<MethodSpec> (module, btypes.String,
new MemberFilter (Operator.GetMetadataName (Operator.OpType.Inequality), 0, MemberKind.Operator, null, btypes.Bool));
StructLayoutAttributeCtor = new PredefinedMember<MethodSpec> (module, atypes.StructLayout,
MemberFilter.Constructor (ParametersCompiled.CreateFullyResolved (btypes.Short)));
StructLayoutCharSet = new PredefinedMember<FieldSpec> (module, atypes.StructLayout, "CharSet",
MemberKind.Field, types.CharSet);
StructLayoutSize = new PredefinedMember<FieldSpec> (module, atypes.StructLayout,
MemberFilter.Field ("Size", btypes.Int));
TypeGetTypeFromHandle = new PredefinedMember<MethodSpec> (module, btypes.Type, "GetTypeFromHandle", btypes.RuntimeTypeHandle);
}
//
// Creates a host for the anonymous method
//
AnonymousMethodMethod DoCreateMethodHost (EmitContext ec)
{
//
// Anonymous method body can be converted to
//
// 1, an instance method in current scope when only `this' is hoisted
// 2, a static method in current scope when neither `this' nor any variable is hoisted
// 3, an instance method in compiler generated storey when any hoisted variable exists
//
Modifiers modifiers;
if (Block.HasCapturedVariable || Block.HasCapturedThis) {
storey = FindBestMethodStorey ();
modifiers = storey != null ? Modifiers.INTERNAL : Modifiers.PRIVATE;
} else {
if (ec.CurrentAnonymousMethod != null)
storey = ec.CurrentAnonymousMethod.Storey;
modifiers = Modifiers.STATIC | Modifiers.PRIVATE;
}
TypeContainer parent = storey != null ? storey : ec.CurrentTypeDefinition.Parent.PartialContainer;
MemberCore mc = ec.MemberContext as MemberCore;
string name = CompilerGeneratedClass.MakeName (parent != storey ? block_name : null,
"m", null, unique_id++);
MemberName member_name;
GenericMethod generic_method;
if (storey == null && mc.MemberName.TypeArguments != null) {
member_name = new MemberName (name, mc.MemberName.TypeArguments.Clone (), Location);
var hoisted_tparams = ec.CurrentTypeParameters;
var type_params = new TypeParameter[hoisted_tparams.Length];
for (int i = 0; i < type_params.Length; ++i) {
type_params[i] = hoisted_tparams[i].CreateHoistedCopy (parent, null);
}
generic_method = new GenericMethod (parent.NamespaceEntry, parent, member_name, type_params,
new TypeExpression (ReturnType, Location), parameters);
} else {
member_name = new MemberName (name, Location);
generic_method = null;
}
string real_name = String.Format (
"{0}~{1}{2}", mc.GetSignatureForError (), GetSignatureForError (),
parameters.GetSignatureForError ());
return new AnonymousMethodMethod (parent,
this, storey, generic_method, new TypeExpression (ReturnType, Location), modifiers,
real_name, member_name, parameters);
}
//
// Resolve the constraints types with only possible early checks, return
// value `false' is reserved for recursive failure
//
public bool Resolve (IMemberContext context, TypeParameter tp)
{
if (resolved)
return true;
if (resolving)
return false;
resolving = true;
var spec = tp.Type;
List<TypeParameterSpec> tparam_types = null;
bool iface_found = false;
spec.BaseType = TypeManager.object_type;
for (int i = 0; i < constraints.Count; ++i) {
var constraint = constraints[i];
if (constraint is SpecialContraintExpr) {
spec.SpecialConstraint |= ((SpecialContraintExpr) constraint).Constraint;
if (spec.HasSpecialStruct)
spec.BaseType = TypeManager.value_type;
// Set to null as it does not have a type
constraints[i] = null;
continue;
}
var type_expr = constraints[i] = constraint.ResolveAsTypeTerminal (context, false);
if (type_expr == null)
continue;
var gexpr = type_expr as GenericTypeExpr;
if (gexpr != null && gexpr.HasDynamicArguments ()) {
context.Compiler.Report.Error (1968, constraint.Location,
"A constraint cannot be the dynamic type `{0}'", gexpr.GetSignatureForError ());
continue;
}
var type = type_expr.Type;
if (!context.CurrentMemberDefinition.IsAccessibleAs (type)) {
context.Compiler.Report.SymbolRelatedToPreviousError (type);
context.Compiler.Report.Error (703, loc,
"Inconsistent accessibility: constraint type `{0}' is less accessible than `{1}'",
type.GetSignatureForError (), context.GetSignatureForError ());
}
if (type.IsInterface) {
if (!spec.AddInterface (type)) {
context.Compiler.Report.Error (405, constraint.Location,
"Duplicate constraint `{0}' for type parameter `{1}'", type.GetSignatureForError (), tparam.Value);
}
iface_found = true;
continue;
}
var constraint_tp = type as TypeParameterSpec;
if (constraint_tp != null) {
if (tparam_types == null) {
tparam_types = new List<TypeParameterSpec> (2);
} else if (tparam_types.Contains (constraint_tp)) {
context.Compiler.Report.Error (405, constraint.Location,
"Duplicate constraint `{0}' for type parameter `{1}'", type.GetSignatureForError (), tparam.Value);
continue;
}
//
// Checks whether each generic method parameter constraint type
// is valid with respect to T
//
if (tp.IsMethodTypeParameter) {
TypeManager.CheckTypeVariance (type, Variance.Contravariant, context);
}
var tp_def = constraint_tp.MemberDefinition as TypeParameter;
if (tp_def != null && !tp_def.ResolveConstraints (context)) {
context.Compiler.Report.Error (454, constraint.Location,
"Circular constraint dependency involving `{0}' and `{1}'",
constraint_tp.GetSignatureForError (), tp.GetSignatureForError ());
continue;
}
//
// Checks whether there are no conflicts between type parameter constraints
//
// class Foo<T, U>
// where T : A
// where U : B, T
//
// A and B are not convertible and only 1 class constraint is allowed
//
if (constraint_tp.HasTypeConstraint) {
if (spec.HasTypeConstraint || spec.HasSpecialStruct) {
if (!CheckConflictingInheritedConstraint (spec.BaseType, constraint_tp.BaseType, context, constraint.Location))
continue;
} else {
for (int ii = 0; ii < tparam_types.Count; ++ii) {
if (!tparam_types[ii].HasTypeConstraint)
continue;
if (!CheckConflictingInheritedConstraint (tparam_types[ii].BaseType, constraint_tp.BaseType, context, constraint.Location))
break;
}
}
}
if (constraint_tp.HasSpecialStruct) {
context.Compiler.Report.Error (456, constraint.Location,
"Type parameter `{0}' has the `struct' constraint, so it cannot be used as a constraint for `{1}'",
constraint_tp.GetSignatureForError (), tp.GetSignatureForError ());
continue;
}
tparam_types.Add (constraint_tp);
continue;
}
if (iface_found || spec.HasTypeConstraint) {
context.Compiler.Report.Error (406, constraint.Location,
"The class type constraint `{0}' must be listed before any other constraints. Consider moving type constraint to the beginning of the constraint list",
type.GetSignatureForError ());
}
if (spec.HasSpecialStruct || spec.HasSpecialClass) {
context.Compiler.Report.Error (450, type_expr.Location,
"`{0}': cannot specify both a constraint class and the `class' or `struct' constraint",
type.GetSignatureForError ());
}
if (type == InternalType.Dynamic) {
context.Compiler.Report.Error (1967, constraint.Location, "A constraint cannot be the dynamic type");
continue;
}
if (type.IsSealed || !type.IsClass) {
context.Compiler.Report.Error (701, loc,
"`{0}' is not a valid constraint. A constraint must be an interface, a non-sealed class or a type parameter",
TypeManager.CSharpName (type));
continue;
}
if (type.IsStatic) {
context.Compiler.Report.Error (717, constraint.Location,
"`{0}' is not a valid constraint. Static classes cannot be used as constraints",
type.GetSignatureForError ());
} else if (type == TypeManager.array_type || type == TypeManager.delegate_type ||
type == TypeManager.enum_type || type == TypeManager.value_type ||
type == TypeManager.object_type || type == TypeManager.multicast_delegate_type) {
context.Compiler.Report.Error (702, constraint.Location,
"A constraint cannot be special class `{0}'", type.GetSignatureForError ());
continue;
}
spec.BaseType = type;
}
if (tparam_types != null)
spec.TypeArguments = tparam_types.ToArray ();
resolving = false;
resolved = true;
return true;
}
public TypeParameterExpr (TypeParameter type_parameter, Location loc)
{
this.type = type_parameter.Type;
this.eclass = ExprClass.TypeParameter;
this.loc = loc;
}
public TypeParameterMutator (TypeParameter[] mvar, TypeParameter[] var)
{
if (mvar.Length != var.Length)
throw new ArgumentException ();
this.mvar = mvar;
this.var = var;
}
/// <summary>
/// Resolve the constraints - but only resolve things into Expression's, not
/// into actual types.
/// </summary>
public bool Resolve (MemberCore ec, TypeParameter tp, Report Report)
{
if (resolved)
return true;
if (ec == null)
return false;
iface_constraints = new ArrayList (2); // TODO: Too expensive allocation
type_param_constraints = new ArrayList ();
foreach (object obj in constraints) {
if (HasConstructorConstraint) {
Report.Error (401, loc,
"The new() constraint must be the last constraint specified");
return false;
}
if (obj is SpecialConstraint) {
SpecialConstraint sc = (SpecialConstraint) obj;
if (sc == SpecialConstraint.Constructor) {
if (!HasValueTypeConstraint) {
attrs |= GenericParameterAttributes.DefaultConstructorConstraint;
continue;
}
Report.Error (451, loc, "The `new()' constraint " +
"cannot be used with the `struct' constraint");
return false;
}
if ((num_constraints > 0) || HasReferenceTypeConstraint || HasValueTypeConstraint) {
Report.Error (449, loc, "The `class' or `struct' " +
"constraint must be the first constraint specified");
return false;
}
if (sc == SpecialConstraint.ReferenceType)
attrs |= GenericParameterAttributes.ReferenceTypeConstraint;
else
attrs |= GenericParameterAttributes.NotNullableValueTypeConstraint;
continue;
}
int errors = Report.Errors;
FullNamedExpression fn = ((Expression) obj).ResolveAsTypeStep (ec, false);
if (fn == null) {
if (errors != Report.Errors)
return false;
NamespaceEntry.Error_NamespaceNotFound (loc, ((Expression)obj).GetSignatureForError (), Report);
return false;
}
TypeExpr expr;
GenericTypeExpr cexpr = fn as GenericTypeExpr;
if (cexpr != null) {
expr = cexpr.ResolveAsBaseTerminal (ec, false);
} else
expr = ((Expression) obj).ResolveAsTypeTerminal (ec, false);
if ((expr == null) || (expr.Type == null))
return false;
if (!ec.IsAccessibleAs (fn.Type)) {
Report.SymbolRelatedToPreviousError (fn.Type);
Report.Error (703, loc,
"Inconsistent accessibility: constraint type `{0}' is less accessible than `{1}'",
fn.GetSignatureForError (), ec.GetSignatureForError ());
return false;
}
if (TypeManager.IsGenericParameter (expr.Type))
type_param_constraints.Add (expr);
else if (expr.IsInterface)
iface_constraints.Add (expr);
else if (class_constraint != null || iface_constraints.Count != 0) {
Report.Error (406, loc,
"The class type constraint `{0}' must be listed before any other constraints. Consider moving type constraint to the beginning of the constraint list",
expr.GetSignatureForError ());
return false;
} else if (HasReferenceTypeConstraint || HasValueTypeConstraint) {
Report.Error (450, loc, "`{0}': cannot specify both " +
"a constraint class and the `class' " +
"or `struct' constraint", expr.GetSignatureForError ());
return false;
} else
class_constraint = expr;
//
// Checks whether each generic method parameter constraint type
// is valid with respect to T
//
if (tp != null && tp.Type.DeclaringMethod != null) {
TypeManager.CheckTypeVariance (expr.Type, Variance.Contravariant, ec as MemberCore);
}
num_constraints++;
}
ArrayList list = new ArrayList ();
foreach (TypeExpr iface_constraint in iface_constraints) {
foreach (Type type in list) {
if (!type.Equals (iface_constraint.Type))
continue;
Report.Error (405, loc,
"Duplicate constraint `{0}' for type " +
"parameter `{1}'.", iface_constraint.GetSignatureForError (),
name);
return false;
}
list.Add (iface_constraint.Type);
}
foreach (TypeExpr expr in type_param_constraints) {
foreach (Type type in list) {
if (!type.Equals (expr.Type))
continue;
Report.Error (405, loc,
"Duplicate constraint `{0}' for type " +
"parameter `{1}'.", expr.GetSignatureForError (), name);
return false;
}
list.Add (expr.Type);
}
iface_constraint_types = new Type [list.Count];
list.CopyTo (iface_constraint_types, 0);
if (class_constraint != null) {
class_constraint_type = class_constraint.Type;
if (class_constraint_type == null)
return false;
if (class_constraint_type.IsSealed) {
if (class_constraint_type.IsAbstract)
{
Report.Error (717, loc, "`{0}' is not a valid constraint. Static classes cannot be used as constraints",
TypeManager.CSharpName (class_constraint_type));
}
else
{
Report.Error (701, loc, "`{0}' is not a valid constraint. A constraint must be an interface, " +
"a non-sealed class or a type parameter", TypeManager.CSharpName(class_constraint_type));
}
return false;
}
if ((class_constraint_type == TypeManager.array_type) ||
(class_constraint_type == TypeManager.delegate_type) ||
(class_constraint_type == TypeManager.enum_type) ||
(class_constraint_type == TypeManager.value_type) ||
(class_constraint_type == TypeManager.object_type) ||
class_constraint_type == TypeManager.multicast_delegate_type) {
Report.Error (702, loc,
"A constraint cannot be special class `{0}'",
TypeManager.CSharpName (class_constraint_type));
return false;
}
if (TypeManager.IsDynamicType (class_constraint_type)) {
Report.Error (1967, loc, "A constraint cannot be the dynamic type");
return false;
}
}
if (class_constraint_type != null)
effective_base_type = class_constraint_type;
else if (HasValueTypeConstraint)
effective_base_type = TypeManager.value_type;
else
effective_base_type = TypeManager.object_type;
if ((attrs & GenericParameterAttributes.NotNullableValueTypeConstraint) != 0)
attrs |= GenericParameterAttributes.DefaultConstructorConstraint;
resolved = true;
return true;
}
public virtual void SetParameterInfo (ArrayList constraints_list)
{
if (!is_generic) {
if (constraints_list != null) {
Report.Error (
80, Location, "Constraints are not allowed " +
"on non-generic declarations");
}
return;
}
TypeParameterName[] names = MemberName.TypeArguments.GetDeclarations ();
type_params = new TypeParameter [names.Length];
//
// Register all the names
//
for (int i = 0; i < type_params.Length; i++) {
TypeParameterName name = names [i];
Constraints constraints = null;
if (constraints_list != null) {
int total = constraints_list.Count;
for (int ii = 0; ii < total; ++ii) {
Constraints constraints_at = (Constraints)constraints_list[ii];
// TODO: it is used by iterators only
if (constraints_at == null) {
constraints_list.RemoveAt (ii);
--total;
continue;
}
if (constraints_at.TypeParameter == name.Name) {
constraints = constraints_at;
constraints_list.RemoveAt(ii);
break;
}
}
}
type_params [i] = new TypeParameter (
Parent, this, name.Name, constraints, name.OptAttributes,
Location);
AddToContainer (type_params [i], name.Name);
}
if (constraints_list != null && constraints_list.Count > 0) {
foreach (Constraints constraint in constraints_list) {
Report.Error(699, constraint.Location, "`{0}': A constraint references nonexistent type parameter `{1}'",
GetSignatureForError (), constraint.TypeParameter);
}
}
}
public TypeParameterExpr (TypeParameter type_parameter, Location loc)
{
throw new NotImplementedException ();
}
void case_366()
#line 3016 "cs-parser.jay"
{
var lt = (LocatedToken)yyVals[0+yyTop];
var variance = (Variance) yyVals[-1+yyTop];
yyVal = new TypeParameter (new MemberName (lt.Value, lt.Location), (Attributes)yyVals[-2+yyTop], variance);
if (variance != Variance.None)
lbag.AddLocation (yyVal, savedLocation);
}
public GenericMethod (NamespaceEntry ns, DeclSpace parent, MemberName name, TypeParameter[] tparams,
FullNamedExpression return_type, ParametersCompiled parameters)
: this (ns, parent, name, return_type, parameters)
{
this.type_params = tparams;
}
//
// This is called for each part of a partial generic type definition.
//
// If partial type parameters constraints are not null and we don't
// already have constraints they become our constraints. If we already
// have constraints, we must check that they're the same.
//
public bool AddPartialConstraints(TypeContainer part, TypeParameter tp)
{
if (builder == null)
throw new InvalidOperationException ();
var new_constraints = tp.constraints;
if (new_constraints == null)
return true;
// TODO: could create spec only
//tp.Define (null, -1, part.Definition);
tp.spec.DeclaringType = part.Definition;
if (!tp.ResolveConstraints (part))
return false;
if (constraints != null)
return spec.HasSameConstraintsDefinition (tp.Type);
constraints = new_constraints;
return true;
}
public AnonymousMethodStorey (Block block, TypeContainer parent, MemberBase host, TypeParameter[] tparams, string name)
: base (parent, MakeMemberName (host, name, unique_id, tparams, block.StartLocation),
tparams, Modifiers.SEALED)
{
OriginalSourceBlock = block;
ID = unique_id++;
}
//
// This is called for each part of a partial generic type definition.
//
// If partial type parameters constraints are not null and we don't
// already have constraints they become our constraints. If we already
// have constraints, we must check that they're the same.
//
public bool AddPartialConstraints (TypeContainer part, TypeParameter tp)
{
if (builder == null)
throw new InvalidOperationException ();
var new_constraints = tp.constraints;
if (new_constraints == null)
return true;
// TODO: could create spec only
//tp.Define (null, -1, part.Definition);
tp.spec.DeclaringType = part.Definition;
if (!tp.ResolveConstraints (part))
return false;
if (constraints != null)
return spec.HasSameConstraintsDefinition (tp.Type);
// Copy constraint from resolved part to partial container
spec.SpecialConstraint = tp.spec.SpecialConstraint;
spec.InterfacesDefined = tp.spec.InterfacesDefined;
spec.TypeArguments = tp.spec.TypeArguments;
spec.BaseType = tp.spec.BaseType;
return true;
}
public static TypeParameter FindTypeParameter (TypeParameter[] tparams, string name)
{
foreach (var tp in tparams) {
if (tp.Name == name)
return tp;
}
return null;
}
public TypeParameterExpr (TypeParameter type_parameter, Location loc)
{
this.type_parameter = type_parameter;
this.loc = loc;
}
void case_367()
#line 3024 "cs-parser.jay"
{
if (GetTokenName (yyToken) == "type")
report.Error (81, GetLocation (yyVals[0+yyTop]), "Type parameter declaration must be an identifier not a type");
else
Error_SyntaxError (yyToken);
yyVal = new TypeParameter (MemberName.Null, null, Variance.None);
}
bool CheckTypeParameterConstraints (TypeParameter tparam, ref TypeExpr prevConstraint, ArrayList seen)
{
seen.Add (tparam);
Constraints constraints = tparam.Constraints;
if (constraints == null)
return true;
if (constraints.HasValueTypeConstraint) {
Report.Error (456, loc,
"Type parameter `{0}' has the `struct' constraint, so it cannot be used as a constraint for `{1}'",
tparam.Name, name);
return false;
}
//
// Checks whether there are no conflicts between type parameter constraints
//
// class Foo<T, U>
// where T : A
// where U : A, B // A and B are not convertible
//
if (constraints.HasClassConstraint) {
if (prevConstraint != null) {
Type t2 = constraints.ClassConstraint;
TypeExpr e2 = constraints.class_constraint;
if (!Convert.ImplicitReferenceConversionExists (prevConstraint, t2) &&
!Convert.ImplicitReferenceConversionExists (e2, prevConstraint.Type)) {
Report.Error (455, loc,
"Type parameter `{0}' inherits conflicting constraints `{1}' and `{2}'",
name, TypeManager.CSharpName (prevConstraint.Type), TypeManager.CSharpName (t2));
return false;
}
}
prevConstraint = constraints.class_constraint;
}
if (constraints.type_param_constraints == null)
return true;
foreach (TypeParameterExpr expr in constraints.type_param_constraints) {
if (seen.Contains (expr.TypeParameter)) {
Report.Error (454, loc, "Circular constraint " +
"dependency involving `{0}' and `{1}'",
tparam.Name, expr.GetSignatureForError ());
return false;
}
if (!CheckTypeParameterConstraints (expr.TypeParameter, ref prevConstraint, seen))
return false;
}
return true;
}
//
// Creates a proxy base method call inside this container for hoisted base member calls
//
public MethodSpec CreateHoistedBaseCallProxy (ResolveContext rc, MethodSpec method)
{
Method proxy_method;
//
// One proxy per base method is enough
//
if (hoisted_base_call_proxies == null) {
hoisted_base_call_proxies = new Dictionary<MethodSpec, Method> ();
proxy_method = null;
} else {
hoisted_base_call_proxies.TryGetValue (method, out proxy_method);
}
if (proxy_method == null) {
string name = CompilerGeneratedClass.MakeName (method.Name, null, "BaseCallProxy", hoisted_base_call_proxies.Count);
var base_parameters = new Parameter[method.Parameters.Count];
for (int i = 0; i < base_parameters.Length; ++i) {
var base_param = method.Parameters.FixedParameters[i];
base_parameters[i] = new Parameter (new TypeExpression (method.Parameters.Types[i], Location),
base_param.Name, base_param.ModFlags, null, Location);
base_parameters[i].Resolve (this, i);
}
var cloned_params = ParametersCompiled.CreateFullyResolved (base_parameters, method.Parameters.Types);
if (method.Parameters.HasArglist) {
cloned_params.FixedParameters[0] = new Parameter (null, "__arglist", Parameter.Modifier.NONE, null, Location);
cloned_params.Types[0] = Module.PredefinedTypes.RuntimeArgumentHandle.Resolve (Location);
}
GenericMethod generic_method;
MemberName member_name;
if (method.IsGeneric) {
//
// Copy all base generic method type parameters info
//
var hoisted_tparams = method.GenericDefinition.TypeParameters;
var targs = new TypeArguments ();
var type_params = new TypeParameter[hoisted_tparams.Length];
for (int i = 0; i < type_params.Length; ++i) {
var tp = hoisted_tparams[i];
targs.Add (new TypeParameterName (tp.Name, null, Location));
type_params[i] = new TypeParameter (tp, this, null, new MemberName (tp.Name), null);
}
member_name = new MemberName (name, targs, Location);
generic_method = new GenericMethod (NamespaceEntry, this, member_name, type_params,
new TypeExpression (method.ReturnType, Location), cloned_params);
} else {
member_name = new MemberName (name);
generic_method = null;
}
// Compiler generated proxy
proxy_method = new Method (this, generic_method, new TypeExpression (method.ReturnType, Location),
Modifiers.PRIVATE | Modifiers.COMPILER_GENERATED | Modifiers.DEBUGGER_HIDDEN,
member_name, cloned_params, null);
var block = new ToplevelBlock (Compiler, proxy_method.ParameterInfo, Location);
var mg = MethodGroupExpr.CreatePredefined (method, method.DeclaringType, Location);
mg.InstanceExpression = new BaseThis (method.DeclaringType, Location);
// Get all the method parameters and pass them as arguments
var real_base_call = new Invocation (mg, block.GetAllParametersArguments ());
Statement statement;
if (method.ReturnType == TypeManager.void_type)
statement = new StatementExpression (real_base_call);
else
statement = new Return (real_base_call, Location);
block.AddStatement (statement);
proxy_method.Block = block;
methods.Add (proxy_method);
proxy_method.Define ();
hoisted_base_call_proxies.Add (method, proxy_method);
}
return proxy_method.Spec;
}
public AnonymousMethodStorey (Block block, TypeContainer parent, MemberBase host, GenericMethod generic, string name)
: base (parent, MakeMemberName (host, name, generic, block.StartLocation), Modifiers.PRIVATE | Modifiers.SEALED)
{
Parent = parent;
OriginalSourceBlock = block;
ID = unique_id++;
if (generic != null) {
var hoisted_tparams = generic.CurrentTypeParameters;
type_params = new TypeParameter [hoisted_tparams.Length];
for (int i = 0; i < type_params.Length; ++i) {
type_params[i] = hoisted_tparams[i].CreateHoistedCopy (this, spec);
}
}
}
//
// Creates a proxy base method call inside this container for hoisted base member calls
//
public MethodSpec CreateHoistedBaseCallProxy (ResolveContext rc, MethodSpec method)
{
Method proxy_method;
//
// One proxy per base method is enough
//
if (hoisted_base_call_proxies == null) {
hoisted_base_call_proxies = new Dictionary<MethodSpec, Method> ();
proxy_method = null;
} else {
hoisted_base_call_proxies.TryGetValue (method, out proxy_method);
}
if (proxy_method == null) {
string name = CompilerGeneratedContainer.MakeName (method.Name, null, "BaseCallProxy", hoisted_base_call_proxies.Count);
MemberName member_name;
TypeArguments targs = null;
TypeSpec return_type = method.ReturnType;
var local_param_types = method.Parameters.Types;
if (method.IsGeneric) {
//
// Copy all base generic method type parameters info
//
var hoisted_tparams = method.GenericDefinition.TypeParameters;
var tparams = new TypeParameters ();
targs = new TypeArguments ();
targs.Arguments = new TypeSpec[hoisted_tparams.Length];
for (int i = 0; i < hoisted_tparams.Length; ++i) {
var tp = hoisted_tparams[i];
var local_tp = new TypeParameter (tp, null, new MemberName (tp.Name, Location), null);
tparams.Add (local_tp);
targs.Add (new SimpleName (tp.Name, Location));
targs.Arguments[i] = local_tp.Type;
}
member_name = new MemberName (name, tparams, Location);
//
// Mutate any method type parameters from original
// to newly created hoisted version
//
var mutator = new TypeParameterMutator (hoisted_tparams, tparams);
return_type = mutator.Mutate (return_type);
local_param_types = mutator.Mutate (local_param_types);
} else {
member_name = new MemberName (name);
}
var base_parameters = new Parameter[method.Parameters.Count];
for (int i = 0; i < base_parameters.Length; ++i) {
var base_param = method.Parameters.FixedParameters[i];
base_parameters[i] = new Parameter (new TypeExpression (local_param_types [i], Location),
base_param.Name, base_param.ModFlags, null, Location);
base_parameters[i].Resolve (this, i);
}
var cloned_params = ParametersCompiled.CreateFullyResolved (base_parameters, method.Parameters.Types);
if (method.Parameters.HasArglist) {
cloned_params.FixedParameters[0] = new Parameter (null, "__arglist", Parameter.Modifier.NONE, null, Location);
cloned_params.Types[0] = Module.PredefinedTypes.RuntimeArgumentHandle.Resolve ();
}
// Compiler generated proxy
proxy_method = new Method (this, new TypeExpression (return_type, Location),
Modifiers.PRIVATE | Modifiers.COMPILER_GENERATED | Modifiers.DEBUGGER_HIDDEN,
member_name, cloned_params, null);
var block = new ToplevelBlock (Compiler, proxy_method.ParameterInfo, Location) {
IsCompilerGenerated = true
};
var mg = MethodGroupExpr.CreatePredefined (method, method.DeclaringType, Location);
mg.InstanceExpression = new BaseThis (method.DeclaringType, Location);
if (targs != null)
mg.SetTypeArguments (rc, targs);
// Get all the method parameters and pass them as arguments
var real_base_call = new Invocation (mg, block.GetAllParametersArguments ());
Statement statement;
if (method.ReturnType.Kind == MemberKind.Void)
statement = new StatementExpression (real_base_call);
else
statement = new Return (real_base_call, Location);
block.AddStatement (statement);
proxy_method.Block = block;
members.Add (proxy_method);
proxy_method.Define ();
proxy_method.PrepareEmit ();
hoisted_base_call_proxies.Add (method, proxy_method);
}
return proxy_method.Spec;
}
public static string GetSignatureForError (TypeParameter[] tp)
{
throw new NotImplementedException ();
}