~ubuntu-branches/ubuntu/trusty/monodevelop/trusty-proposed

expr_tree_variable = TemporaryVariableReference.Create (ResolveParameterExpressionType (ec, Location).Type, ec.CurrentBlock.ParametersBlock, Location);

685

expr_tree_variable = (TemporaryVariableReference) expr_tree_variable.Resolve (ec);

686

687

Arguments arguments = new Arguments (2);

688

arguments.Add (new Argument (new TypeOf (parameter_type, Location)));

689

arguments.Add (new Argument (new StringConstant (ec.BuiltinTypes, Name, Location)));

690

return new SimpleAssign (ExpressionTreeVariableReference (),

691

Expression.CreateExpressionFactoryCall (ec, "Parameter", null, arguments, Location));

692

}

693

694

public void Emit (EmitContext ec)

695

{

696

ec.EmitArgumentLoad (idx);

697

}

698

699

public void EmitAssign (EmitContext ec)

700

{

701

ec.EmitArgumentStore (idx);

702

}

703

704

public void EmitAddressOf (EmitContext ec)

705

{

706

if ((ModFlags & Modifier.RefOutMask) != 0) {

707

ec.EmitArgumentLoad (idx);

708

} else {

709

ec.EmitArgumentAddress (idx);

710

}

711

}

712

713

public TemporaryVariableReference ExpressionTreeVariableReference ()

714

{

715

return expr_tree_variable;

716

}

717

718

719

// System.Linq.Expressions.ParameterExpression type

720

721

public static TypeExpr ResolveParameterExpressionType (IMemberContext ec, Location location)

722

{

723

TypeSpec p_type = ec.Module.PredefinedTypes.ParameterExpression.Resolve ();

724

return new TypeExpression (p_type, location);

725

}

726

727

public void Warning_UselessOptionalParameter (Report Report)

728

{

729

Report.Warning (1066, 1, Location,

730

"The default value specified for optional parameter `{0}' will never be used",

731

Name);

732

}

733

}

734

735

736

// Imported or resolved parameter information

737

738

public class ParameterData : IParameterData

739

{

740

readonly string name;

741

readonly Parameter.Modifier modifiers;

742

readonly Expression default_value;

743

744

public ParameterData (string name, Parameter.Modifier modifiers)

745

{

746

this.name = name;

747

this.modifiers = modifiers;

748

}

749

750

public ParameterData (string name, Parameter.Modifier modifiers, Expression defaultValue)

751

: this (name, modifiers)

752

{

753

this.default_value = defaultValue;

754

}

755

756

#region IParameterData Members

757

758

public Expression DefaultValue {

759

get { return default_value; }

760

}

761

762

public bool HasExtensionMethodModifier {

763

get { return (modifiers & Parameter.Modifier.This) != 0; }

764

}

765

766

public bool HasDefaultValue {

767

get { return default_value != null; }

768

}

769

770

public Parameter.Modifier ModFlags {

771

get { return modifiers; }

772

}

773

774

public string Name {

775

get { return name; }

776

}

777

778

#endregion

779

}

780

781

public abstract class AParametersCollection

782

{

783

protected bool has_arglist;

784

protected bool has_params;

785

786

// Null object pattern

787

protected IParameterData [] parameters;

788

protected TypeSpec [] types;

789

790

public CallingConventions CallingConvention {

791

get {

792

return has_arglist ?

793

CallingConventions.VarArgs :

794

CallingConventions.Standard;

795

}

796

}

797

798

public int Count {

799

get { return parameters.Length; }

800

}

801

802

public TypeSpec ExtensionMethodType {

803

get {

804

if (Count == 0)

805

return null;

806

807

return FixedParameters [0].HasExtensionMethodModifier ?

808

types [0] : null;

809

}

810

}

811

812

public IParameterData [] FixedParameters {

813

get {

814

return parameters;

815

}

816

}

817

818

public static ParameterAttributes GetParameterAttribute (Parameter.Modifier modFlags)

819

{

820

return (modFlags & Parameter.Modifier.OUT) != 0 ?

821

ParameterAttributes.Out : ParameterAttributes.None;

822

}

823

824

// Very expensive operation

825

public MetaType[] GetMetaInfo ()

826

{

827

MetaType[] types;

828

if (has_arglist) {

829

if (Count == 1)

830

return MetaType.EmptyTypes;

831

832

types = new MetaType[Count - 1];

833

} else {

834

if (Count == 0)

835

return MetaType.EmptyTypes;

836

837

types = new MetaType[Count];

838

}

839

840

for (int i = 0; i < types.Length; ++i) {

841

types[i] = Types[i].GetMetaInfo ();

842

843

if ((FixedParameters[i].ModFlags & Parameter.Modifier.RefOutMask) == 0)

844

continue;

845

846

// TODO MemberCache: Should go to MetaInfo getter

847

types [i] = types [i].MakeByRefType ();

848

}

849

850

return types;

851

}

852

853

854

// Returns the parameter information based on the name

855

856

public int GetParameterIndexByName (string name)

857

{

858

for (int idx = 0; idx < Count; ++idx) {

859

if (parameters [idx].Name == name)

860

return idx;

861

}

862

863

return -1;

864

}

865

866

public string GetSignatureForDocumentation ()

867

{

868

if (IsEmpty)

869

return string.Empty;

870

871

StringBuilder sb = new StringBuilder ("(");

872

for (int i = 0; i < Count; ++i) {

873

if (i != 0)

874

sb.Append (",");

875

876

sb.Append (types [i].GetSignatureForDocumentation ());

877

878

if ((parameters[i].ModFlags & Parameter.Modifier.RefOutMask) != 0)

879

sb.Append ("@");

880

}

881

sb.Append (")");

882

883

return sb.ToString ();

884

}

885

886

public string GetSignatureForError ()

887

{

888

return GetSignatureForError ("(", ")", Count);

889

}

890

891

public string GetSignatureForError (string start, string end, int count)

892

{

893

StringBuilder sb = new StringBuilder (start);

894

for (int i = 0; i < count; ++i) {

895

if (i != 0)

896

sb.Append (", ");

897

sb.Append (ParameterDesc (i));

898

}

899

sb.Append (end);

900

return sb.ToString ();

901

}

902

903

public bool HasArglist {

904

get { return has_arglist; }

905

}

906

907

public bool HasExtensionMethodType {

908

get {

909

if (Count == 0)

910

return false;

911

912

return FixedParameters [0].HasExtensionMethodModifier;

913

}

914

}

915

916

public bool HasParams {

917

get { return has_params; }

918

}

919

920

public bool IsEmpty {

921

get { return parameters.Length == 0; }

922

}

923

924

public AParametersCollection Inflate (TypeParameterInflator inflator)

925

{

926

TypeSpec[] inflated_types = null;

927

bool default_value = false;

928

929

for (int i = 0; i < Count; ++i) {

930

var inflated_param = inflator.Inflate (types[i]);

931

if (inflated_types == null) {

932

if (inflated_param == types[i])

933

continue;

934

935

default_value |= FixedParameters[i] is DefaultValueExpression;

936

inflated_types = new TypeSpec[types.Length];

937

Array.Copy (types, inflated_types, types.Length);

938

}

939

940

inflated_types[i] = inflated_param;

941

}

942

943

if (inflated_types == null)

944

return this;

945

946

var clone = (AParametersCollection) MemberwiseClone ();

947

clone.types = inflated_types;

948

if (default_value) {

949

for (int i = 0; i < Count; ++i) {

950

var dve = clone.FixedParameters[i] as DefaultValueExpression;

951

if (dve != null) {

952

throw new NotImplementedException ("net");

953

// clone.FixedParameters [i].DefaultValue = new DefaultValueExpression ();

954

}

955

}

956

}

957

958

return clone;

959

}

960

961

public string ParameterDesc (int pos)

962

{

963

if (types == null || types [pos] == null)

964

return ((Parameter)FixedParameters [pos]).GetSignatureForError ();

965

966

string type = TypeManager.CSharpName (types [pos]);

967

if (FixedParameters [pos].HasExtensionMethodModifier)

968

return "this " + type;

969

970

Parameter.Modifier mod = FixedParameters [pos].ModFlags;

971

if (mod == 0)

972

return type;

973

974

return Parameter.GetModifierSignature (mod) + " " + type;

975

}

976

977

public TypeSpec[] Types {

978

get { return types; }

979

set { types = value; }

980

}

981

}

982

983

984

// A collection of imported or resolved parameters

985

986

public class ParametersImported : AParametersCollection

987

{

988

public ParametersImported (IParameterData [] parameters, TypeSpec [] types, bool hasArglist, bool hasParams)

989

{

990

this.parameters = parameters;

991

this.types = types;

992

this.has_arglist = hasArglist;

993

this.has_params = hasParams;

994

}

995

996

public ParametersImported (IParameterData[] param, TypeSpec[] types, bool hasParams)

997

{

998

this.parameters = param;

999

this.types = types;

1000

this.has_params = hasParams;

1001

}

1002

}

1003

1004

/// <summary>

1005

/// Represents the methods parameters

1006

/// </summary>

1007

public class ParametersCompiled : AParametersCollection

1008

{

1009

public static readonly ParametersCompiled EmptyReadOnlyParameters = new ParametersCompiled ();

1010

1011

// Used by C# 2.0 delegates

1012

public static readonly ParametersCompiled Undefined = new ParametersCompiled ();

1013

1014

private ParametersCompiled ()

1015

{

1016

parameters = new Parameter [0];

1017

types = TypeSpec.EmptyTypes;

1018

}

1019

1020

private ParametersCompiled (IParameterData[] parameters, TypeSpec[] types)

1021

{

1022

this.parameters = parameters;

1023

this.types = types;

1024

}

1025

1026

public ParametersCompiled (params Parameter[] parameters)

1027

{

1028

if (parameters == null || parameters.Length == 0)

1029

throw new ArgumentException ("Use EmptyReadOnlyParameters");

1030

1031

this.parameters = parameters;

1032

int count = parameters.Length;

1033

1034

for (int i = 0; i < count; i++){

1035

has_params |= (parameters [i].ModFlags & Parameter.Modifier.PARAMS) != 0;

1036

}

1037

}

1038

1039

public ParametersCompiled (Parameter [] parameters, bool has_arglist) :

1040

this (parameters)

1041

{

1042

this.has_arglist = has_arglist;

1043

}

1044

1045

public static ParametersCompiled CreateFullyResolved (Parameter p, TypeSpec type)

1046

{

1047

return new ParametersCompiled (new Parameter [] { p }, new TypeSpec [] { type });

1048

}

1049

1050

public static ParametersCompiled CreateFullyResolved (Parameter[] parameters, TypeSpec[] types)

1051

{

1052

return new ParametersCompiled (parameters, types);

1053

}

1054

1055

1056

// TODO: This does not fit here, it should go to different version of AParametersCollection

1057

// as the underlying type is not Parameter and some methods will fail to cast

1058

1059

public static AParametersCollection CreateFullyResolved (params TypeSpec[] types)

1060

{

1061

var pd = new ParameterData [types.Length];

1062

for (int i = 0; i < pd.Length; ++i)

1063

pd[i] = new ParameterData (null, Parameter.Modifier.NONE, null);

1064

1065

return new ParametersCompiled (pd, types);

1066

}

1067

1068

public static ParametersCompiled CreateImplicitParameter (FullNamedExpression texpr, Location loc)

1069

{

1070

return new ParametersCompiled (

1071

new[] { new Parameter (texpr, "value", Parameter.Modifier.NONE, null, loc) },

1072

null);

1073

}

1074

1075

public void CheckConstraints (IMemberContext mc)

1076

{

1077

foreach (Parameter p in parameters) {

1078

1079

// It's null for compiler generated types or special types like __arglist

1080

1081

if (p.TypeExpression != null)

1082

ConstraintChecker.Check (mc, p.Type, p.TypeExpression.Location);

1083

}

1084

}

1085

1086

1087

// Returns non-zero value for equal CLS parameter signatures

1088

1089

public static int IsSameClsSignature (AParametersCollection a, AParametersCollection b)

1090

{

1091

int res = 0;

1092

1093

for (int i = 0; i < a.Count; ++i) {

1094

var a_type = a.Types[i];

1095

var b_type = b.Types[i];

1096

if (TypeSpecComparer.Override.IsEqual (a_type, b_type)) {

1097

if ((a.FixedParameters[i].ModFlags & Parameter.Modifier.RefOutMask) != (b.FixedParameters[i].ModFlags & Parameter.Modifier.RefOutMask))

1098

res |= 1;

1099

1100

continue;

1101

}

1102

1103

var ac_a = a_type as ArrayContainer;

1104

if (ac_a == null)

1105

return 0;

1106

1107

var ac_b = b_type as ArrayContainer;

1108

if (ac_b == null)

1109

return 0;

1110

1111

if (ac_a.Element is ArrayContainer || ac_b.Element is ArrayContainer) {

1112

res |= 2;

1113

continue;

1114

}

1115

1116

if (ac_a.Rank != ac_b.Rank && TypeSpecComparer.Override.IsEqual (ac_a.Element, ac_b.Element)) {

1117

res |= 1;

1118

continue;

1119

}

1120

1121

return 0;

1122

}

1123

1124

return res;

1125

}

1126

1127

public static ParametersCompiled MergeGenerated (CompilerContext ctx, ParametersCompiled userParams, bool checkConflicts, Parameter compilerParams, TypeSpec compilerTypes)

1128

{

1129

return MergeGenerated (ctx, userParams, checkConflicts,

1130

new Parameter [] { compilerParams },

1131

new TypeSpec [] { compilerTypes });

1132

}

1133

1134

1135

// Use this method when you merge compiler generated parameters with user parameters

1136

1137

public static ParametersCompiled MergeGenerated (CompilerContext ctx, ParametersCompiled userParams, bool checkConflicts, Parameter[] compilerParams, TypeSpec[] compilerTypes)

1138

{

1139

Parameter[] all_params = new Parameter [userParams.Count + compilerParams.Length];

1140

userParams.FixedParameters.CopyTo(all_params, 0);

1141

1142

TypeSpec [] all_types;

1143

if (userParams.types != null) {

1144

all_types = new TypeSpec [all_params.Length];

1145

userParams.Types.CopyTo (all_types, 0);

1146

} else {

1147

all_types = null;

1148

}

1149

1150

int last_filled = userParams.Count;

1151

int index = 0;

1152

foreach (Parameter p in compilerParams) {

1153

for (int i = 0; i < last_filled; ++i) {

1154

while (p.Name == all_params [i].Name) {

1155

if (checkConflicts && i < userParams.Count) {

1156

ctx.Report.Error (316, userParams[i].Location,

1157

"The parameter name `{0}' conflicts with a compiler generated name", p.Name);

1158

}

1159

p.Name = '_' + p.Name;

1160

}

1161

}

1162

all_params [last_filled] = p;

1163

if (all_types != null)

1164

all_types [last_filled] = compilerTypes [index++];

1165

++last_filled;

1166

}

1167

1168

ParametersCompiled parameters = new ParametersCompiled (all_params, all_types);

1169

parameters.has_params = userParams.has_params;

1170

return parameters;

1171

}

1172

1173

1174

// Parameters checks for members which don't have a block

1175

1176

public void CheckParameters (MemberCore member)

1177

{

1178

for (int i = 0; i < parameters.Length; ++i) {

1179

var name = parameters[i].Name;

1180

for (int ii = i + 1; ii < parameters.Length; ++ii) {

1181

if (parameters[ii].Name == name)

1182

this[ii].Error_DuplicateName (member.Compiler.Report);

1183

}

1184

}

1185

}

1186

1187

public bool Resolve (IMemberContext ec)

1188

{

1189

if (types != null)

1190

return true;

1191

1192

types = new TypeSpec [Count];

1193

1194

bool ok = true;

1195

Parameter p;

1196

for (int i = 0; i < FixedParameters.Length; ++i) {

1197

p = this [i];

1198

TypeSpec t = p.Resolve (ec, i);

1199

if (t == null) {

1200

ok = false;

1201

continue;

1202

}

1203

1204

types [i] = t;

1205

}

1206

1207

return ok;

1208

}

1209

1210

public void ResolveDefaultValues (MemberCore m)

1211

{

1212

ResolveContext rc = null;

1213

for (int i = 0; i < parameters.Length; ++i) {

1214

Parameter p = (Parameter) parameters [i];

1215

1216

1217

// Try not to enter default values resolution if there are is not any default value possible

1218

1219

if (p.HasDefaultValue || p.OptAttributes != null) {

1220

if (rc == null)

1221

rc = new ResolveContext (m);

1222

1223

p.ResolveDefaultValue (rc);

1224

}

1225

}

1226

}

1227

1228

// Define each type attribute (in/out/ref) and

1229

// the argument names.

1230

public void ApplyAttributes (IMemberContext mc, MethodBase builder)

1231

{

1232

if (Count == 0)

1233

return;

1234

1235

MethodBuilder mb = builder as MethodBuilder;

1236

ConstructorBuilder cb = builder as ConstructorBuilder;

1237

var pa = mc.Module.PredefinedAttributes;

1238

1239

for (int i = 0; i < Count; i++) {

1240

this [i].ApplyAttributes (mb, cb, i + 1, pa);

1241

}

1242

}

1243

1244

public void VerifyClsCompliance (IMemberContext ctx)

1245

{

1246

foreach (Parameter p in FixedParameters)

1247

p.IsClsCompliant (ctx);

1248

}

1249

1250

public Parameter this [int pos] {

1251

get { return (Parameter) parameters [pos]; }

1252

}

1253

1254

public Expression CreateExpressionTree (BlockContext ec, Location loc)

1255

{

1256

var initializers = new ArrayInitializer (Count, loc);

1257

foreach (Parameter p in FixedParameters) {

1258

1259

// Each parameter expression is stored to local variable

1260

// to save some memory when referenced later.

1261

1262

StatementExpression se = new StatementExpression (p.CreateExpressionTreeVariable (ec), Location.Null);

1263

if (se.Resolve (ec)) {

1264

ec.CurrentBlock.AddScopeStatement (new TemporaryVariableReference.Declarator (p.ExpressionTreeVariableReference ()));

1265

ec.CurrentBlock.AddScopeStatement (se);

1266

}

1267

1268

initializers.Add (p.ExpressionTreeVariableReference ());

1269

}

1270

1271

return new ArrayCreation (

1272

Parameter.ResolveParameterExpressionType (ec, loc),

1273

initializers, loc);

1274

}

1275

1276

public ParametersCompiled Clone ()

1277

{

1278

ParametersCompiled p = (ParametersCompiled) MemberwiseClone ();

1279

1280

p.parameters = new IParameterData [parameters.Length];

1281

for (int i = 0; i < Count; ++i)

1282

p.parameters [i] = this [i].Clone ();

1283

1284

return p;

1285

}

1286

}

1287

1288

1289

// Default parameter value expression. We need this wrapper to handle

1290

// default parameter values of folded constants (e.g. indexer parameters).

1291

// The expression is resolved only once but applied to two methods which

1292

// both share reference to this expression and we ensure that resolving

1293

// this expression always returns same instance

1294

1295

public class DefaultParameterValueExpression : CompositeExpression

1296

{

1297

public DefaultParameterValueExpression (Expression expr)

1298

: base (expr)

1299

{

1300

}

1301

1302

protected override Expression DoResolve (ResolveContext rc)

1303

{

1304

return base.DoResolve (rc);

1305

}

1306

1307

public void Resolve (ResolveContext rc, Parameter p)

1308

{

1309

var expr = Resolve (rc);

1310

if (expr == null)

1311

return;

1312

1313

expr = Child;

1314

1315

if (!(expr is Constant || expr is DefaultValueExpression || (expr is New && ((New) expr).IsDefaultStruct))) {

1316

rc.Report.Error (1736, Location,

1317

"The expression being assigned to optional parameter `{0}' must be a constant or default value",

1318

p.Name);

1319

1320

return;

1321

}

1322

1323

var parameter_type = p.Type;

1324

if (type == parameter_type)

1325

return;

1326

1327

var res = Convert.ImplicitConversionStandard (rc, expr, parameter_type, Location);

1328

if (res != null) {

1329

if (parameter_type.IsNullableType && res is Nullable.Wrap) {

1330

Nullable.Wrap wrap = (Nullable.Wrap) res;

1331

res = wrap.Child;

1332

if (!(res is Constant)) {

1333

rc.Report.Error (1770, Location,

1334

"The expression being assigned to nullable optional parameter `{0}' must be default value",

1335

p.Name);

1336

return;

1337

}

1338

}

1339

1340

if (!expr.IsNull && TypeSpec.IsReferenceType (parameter_type) && parameter_type.BuiltinType != BuiltinTypeSpec.Type.String) {

1341

rc.Report.Error (1763, Location,

1342

"Optional parameter `{0}' of type `{1}' can only be initialized with `null'",

1343

p.Name, parameter_type.GetSignatureForError ());

1344

1345

return;

1346

}

1347

1348

this.expr = res;

1349

return;

1350

}

1351

1352

rc.Report.Error (1750, Location,

1353

"Optional parameter expression of type `{0}' cannot be converted to parameter type `{1}'",

1354

type.GetSignatureForError (), parameter_type.GetSignatureForError ());

1355

}

1356

1357

public override object Accept (StructuralVisitor visitor)

1358

{

1359

return visitor.Visit (this);

1360

}

1361

}

1362

}

Older »