// // Whether a type is unmanaged. This is used by the unsafe code (25.2) // public static bool IsUnmanagedType(TypeSpec t) { var ds = t.MemberDefinition as DeclSpace; if (ds != null) { return(ds.IsUnmanagedType()); } 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. if (t.IsPointer) { return(IsUnmanagedType(GetElementType(t))); } if (!TypeSpec.IsValueType(t)) { return(false); } if (t.IsNested && t.DeclaringType.IsGenericOrParentIsGeneric) { return(false); } return(true); }
protected override Expression DoResolve (ResolveContext ec) { constructor_method = Delegate.GetConstructor (type); var invoke_method = Delegate.GetInvokeMethod (type); Arguments arguments = CreateDelegateMethodArguments (ec, invoke_method.Parameters, invoke_method.Parameters.Types, loc); method_group = method_group.OverloadResolve (ec, ref arguments, this, OverloadResolver.Restrictions.CovariantDelegate); if (method_group == null) return null; var delegate_method = method_group.BestCandidate; if (delegate_method.DeclaringType.IsNullableType) { ec.Report.Error (1728, loc, "Cannot create delegate from method `{0}' because it is a member of System.Nullable<T> type", delegate_method.GetSignatureForError ()); return null; } if (!AllowSpecialMethodsInvocation) Invocation.IsSpecialMethodInvocation (ec, delegate_method, loc); ExtensionMethodGroupExpr emg = method_group as ExtensionMethodGroupExpr; if (emg != null) { method_group.InstanceExpression = emg.ExtensionExpression; TypeSpec e_type = emg.ExtensionExpression.Type; if (TypeSpec.IsValueType (e_type)) { ec.Report.Error (1113, loc, "Extension method `{0}' of value type `{1}' cannot be used to create delegates", delegate_method.GetSignatureForError (), e_type.GetSignatureForError ()); } } TypeSpec rt = delegate_method.ReturnType; if (rt.BuiltinType == BuiltinTypeSpec.Type.Dynamic) rt = ec.BuiltinTypes.Object; if (!Delegate.IsTypeCovariant (ec, rt, invoke_method.ReturnType)) { Expression ret_expr = new TypeExpression (delegate_method.ReturnType, loc); Error_ConversionFailed (ec, delegate_method, ret_expr); } if (delegate_method.IsConditionallyExcluded (ec, loc)) { ec.Report.SymbolRelatedToPreviousError (delegate_method); MethodOrOperator m = delegate_method.MemberDefinition as MethodOrOperator; if (m != null && m.IsPartialDefinition) { ec.Report.Error (762, loc, "Cannot create delegate from partial method declaration `{0}'", delegate_method.GetSignatureForError ()); } else { ec.Report.Error (1618, loc, "Cannot create delegate with `{0}' because it has a Conditional attribute", TypeManager.CSharpSignature (delegate_method)); } } var expr = method_group.InstanceExpression; if (expr != null && (expr.Type.IsGenericParameter || !TypeSpec.IsReferenceType (expr.Type))) method_group.InstanceExpression = new BoxedCast (expr, ec.BuiltinTypes.Object); eclass = ExprClass.Value; return this; }
public void EmitResultLift(EmitContext ec, TypeSpec type, bool statement) { if (!NullShortCircuit) { throw new InternalErrorException(); } bool value_rt = TypeSpec.IsValueType(type); TypeSpec lifted; if (value_rt) { if (type.IsNullableType) { lifted = type; } else { lifted = Nullable.NullableInfo.MakeType(ec.Module, type); ec.Emit(OpCodes.Newobj, Nullable.NullableInfo.GetConstructor(lifted)); } } else { lifted = null; } var end = ec.DefineLabel(); if (value_on_stack || !statement) { ec.Emit(OpCodes.Br_S, end); } ec.MarkLabel(NullOperatorLabel); if (value_on_stack) { ec.Emit(OpCodes.Pop); } if (!statement) { if (value_rt) { Nullable.LiftedNull.Create(lifted, Location.Null).Emit(ec); } else { ec.EmitNull(); } } ec.MarkLabel(end); }
public override void Error_ValueCannotBeConverted(ResolveContext ec, Location loc, TypeSpec t, bool expl) { if (t.IsGenericParameter) { ec.Report.Error(403, loc, "Cannot convert null to the type parameter `{0}' because it could be a value " + "type. Consider using `default ({0})' instead", t.Name); return; } if (TypeSpec.IsValueType(t)) { ec.Report.Error(37, loc, "Cannot convert null to `{0}' because it is a value type", TypeManager.CSharpName(t)); return; } base.Error_ValueCannotBeConverted(ec, loc, t, expl); }