protected override bool DoDefineMembers() { var builtin_types = Compiler.BuiltinTypes; var ctor_parameters = ParametersCompiled.CreateFullyResolved( new [] { new Parameter(new TypeExpression(builtin_types.Object, Location), "object", Parameter.Modifier.NONE, null, Location), new Parameter(new TypeExpression(builtin_types.IntPtr, Location), "method", Parameter.Modifier.NONE, null, Location) }, new [] { builtin_types.Object, builtin_types.IntPtr } ); Constructor = new Constructor(this, Constructor.ConstructorName, Modifiers.PUBLIC, null, ctor_parameters, Location); Constructor.Define(); // // Here the various methods like Invoke, BeginInvoke etc are defined // // First, call the `out of band' special method for // defining recursively any types we need: // var p = parameters; if (!p.Resolve(this)) { return(false); } // // Invoke method // // Check accessibility foreach (var partype in p.Types) { if (!IsAccessibleAs(partype)) { Report.SymbolRelatedToPreviousError(partype); Report.Error(59, Location, "Inconsistent accessibility: parameter type `{0}' is less accessible than delegate `{1}'", TypeManager.CSharpName(partype), GetSignatureForError()); } } var ret_type = ReturnType.ResolveAsType(this); if (ret_type == null) { return(false); } // // We don't have to check any others because they are all // guaranteed to be accessible - they are standard types. // if (!IsAccessibleAs(ret_type)) { Report.SymbolRelatedToPreviousError(ret_type); Report.Error(58, Location, "Inconsistent accessibility: return type `" + TypeManager.CSharpName(ret_type) + "' is less " + "accessible than delegate `" + GetSignatureForError() + "'"); return(false); } CheckProtectedModifier(); if (Compiler.Settings.StdLib && ret_type.IsSpecialRuntimeType) { Method.Error1599(Location, ret_type, Report); return(false); } TypeManager.CheckTypeVariance(ret_type, Variance.Covariant, this); var resolved_rt = new TypeExpression(ret_type, Location); InvokeBuilder = new Method(this, resolved_rt, MethodModifiers, new MemberName(InvokeMethodName), p, null); InvokeBuilder.Define(); // // Don't emit async method for compiler generated delegates (e.g. dynamic site containers) // if (!IsCompilerGenerated) { DefineAsyncMethods(Parameters.CallingConvention, resolved_rt); } return(true); }
public virtual Type Resolve(ParseContext rc) { if (ParameterType != null) { return(ParameterType); } var texpr = TypeName.ResolveAsTypeTerminal(rc, false); if (texpr == null) { return(null); } ParameterType = texpr.Type; // Ignore all checks for dummy members if (DefaultValue != null) { DefaultValue = DefaultValue.Resolve(rc); if (DefaultValue != null) { var value = DefaultValue as ConstantExpression; if (value == null) { if (DefaultValue != null) { bool isValid; if (DefaultValue is DefaultValueExpression) { isValid = true; } else if (DefaultValue is NewExpression && ((NewExpression)DefaultValue).IsDefaultValueType) { isValid = TypeManager.IsEqual(ParameterType, DefaultValue.Type) || (TypeManager.IsNullableType(ParameterType) && ConvertExpression.ImplicitNullableConversion( rc, DefaultValue, ParameterType) != EmptyExpression.Null); } else { rc.ReportError( 1736, string.Format( "The expression being assigned to optional parameter '{0}' must be a constant or default value.", Name), DefaultValue.Span); isValid = true; } if (!isValid) { DefaultValue = null; rc.ReportError( 1763, string.Format( "Optional parameter '{0}' of type `{1}' can only be initialized with 'null'.", Name, GetSignatureForError()), Span); } } } else { var c = value.ConvertImplicitly(ParameterType); if (c == null) { if (ParameterType == TypeManager.CoreTypes.Object) { rc.ReportError( 1763, string.Format( "Optional parameter '{0}' of type '{1}' can only be initialized with 'null'.", Name, GetSignatureForError()), Span); } else { rc.ReportError( 1750, string.Format( "Optional parameter value '{0}' cannot be converted to parameter type '{1}'.", value.Value, GetSignatureForError()), Span); } DefaultValue = null; } } } } if ((_modifierFlags & Modifier.IsByRef) != 0 && TypeManager.IsSpecialType(ParameterType)) { rc.ReportError( 1601, string.Format( "Method or delegate parameter cannot be of type '{0}'.", GetSignatureForError()), Span); return(null); } TypeManager.CheckTypeVariance( ParameterType, (_modifierFlags & Modifier.IsByRef) != 0 ? Variance.None : Variance.Contravariant, rc); if (TypeManager.IsGenericParameter(ParameterType)) { return(ParameterType); } if ((_modifierFlags & Modifier.This) != 0 && (ParameterType.IsPointer || TypeManager.IsDynamicType(ParameterType))) { rc.ReportError( 1103, string.Format( "The extension method cannot be of type '{0}'.", TypeManager.GetCSharpName(ParameterType)), Span); } return(ParameterType); }