~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].HasDefaultValue;

936

inflated_types = new TypeSpec[types.Length];

937

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

938

} else {

939

if (inflated_param == types[i])

940

continue;

941

942

default_value |= FixedParameters[i].HasDefaultValue;

943

}

944

945

inflated_types[i] = inflated_param;

946

}

947

948

if (inflated_types == null)

949

return this;

950

951

var clone = (AParametersCollection) MemberwiseClone ();

952

clone.types = inflated_types;

953

954

955

// Default expression is original expression from the parameter

956

// declaration context which can be of nested enum in generic class type.

957

// In such case we end up with expression type of G<T>.E and e.g. parameter

958

// type of G<int>.E and conversion would fail without inflate in this

959

// context.

960

961

if (default_value) {

962

clone.parameters = new IParameterData[Count];

963

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

964

var fp = FixedParameters[i];

965

clone.FixedParameters[i] = fp;

966

967

if (!fp.HasDefaultValue)

968

continue;

969

970

var expr = fp.DefaultValue;

971

972

if (inflated_types[i] == expr.Type)

973

continue;

974

975

if (expr is DefaultValueExpression)

976

expr = new DefaultValueExpression (new TypeExpression (inflated_types[i], expr.Location), expr.Location);

977

else if (expr is Constant)

978

expr = Constant.CreateConstantFromValue (inflated_types[i], ((Constant) expr).GetValue (), expr.Location);

979

980

clone.FixedParameters[i] = new ParameterData (fp.Name, fp.ModFlags, expr);

981

}

982

}

983

984

return clone;

985

}

986

987

public string ParameterDesc (int pos)

988

{

989

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

990

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

991

992

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

993

if (FixedParameters [pos].HasExtensionMethodModifier)

994

return "this " + type;

995

996

var mod = FixedParameters[pos].ModFlags & Parameter.Modifier.ModifierMask;

997

if (mod == 0)

998

return type;

999

1000

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

1001

}

1002

1003

public TypeSpec[] Types {

1004

get { return types; }

1005

set { types = value; }

1006

}

1007

}

1008

1009

1010

// A collection of imported or resolved parameters

1011

1012

public class ParametersImported : AParametersCollection

1013

{

1014

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

1015

{

1016

this.parameters = parameters;

1017

this.types = types;

1018

this.has_arglist = hasArglist;

1019

this.has_params = hasParams;

1020

}

1021

1022

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

1023

{

1024

this.parameters = param;

1025

this.types = types;

1026

this.has_params = hasParams;

1027

}

1028

}

1029

1030

/// <summary>

1031

/// Represents the methods parameters

1032

/// </summary>

1033

public class ParametersCompiled : AParametersCollection

1034

{

1035

public static readonly ParametersCompiled EmptyReadOnlyParameters = new ParametersCompiled ();

1036

1037

// Used by C# 2.0 delegates

1038

public static readonly ParametersCompiled Undefined = new ParametersCompiled ();

1039

1040

private ParametersCompiled ()

1041

{

1042

parameters = new Parameter [0];

1043

types = TypeSpec.EmptyTypes;

1044

}

1045

1046

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

1047

{

1048

this.parameters = parameters;

1049

this.types = types;

1050

}

1051

1052

public ParametersCompiled (params Parameter[] parameters)

1053

{

1054

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

1055

throw new ArgumentException ("Use EmptyReadOnlyParameters");

1056

1057

this.parameters = parameters;

1058

int count = parameters.Length;

1059

1060

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

1061

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

1062

}

1063

}

1064

1065

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

1066

this (parameters)

1067

{

1068

this.has_arglist = has_arglist;

1069

}

1070

1071

public static ParametersCompiled CreateFullyResolved (Parameter p, TypeSpec type)

1072

{

1073

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

1074

}

1075

1076

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

1077

{

1078

return new ParametersCompiled (parameters, types);

1079

}

1080

1081

1082

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

1083

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

1084

1085

public static AParametersCollection CreateFullyResolved (params TypeSpec[] types)

1086

{

1087

var pd = new ParameterData [types.Length];

1088

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

1089

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

1090

1091

return new ParametersCompiled (pd, types);

1092

}

1093

1094

public static ParametersCompiled CreateImplicitParameter (FullNamedExpression texpr, Location loc)

1095

{

1096

return new ParametersCompiled (

1097

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

1098

null);

1099

}

1100

1101

public void CheckConstraints (IMemberContext mc)

1102

{

1103

foreach (Parameter p in parameters) {

1104

1105

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

1106

1107

if (p.TypeExpression != null)

1108

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

1109

}

1110

}

1111

1112

1113

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

1114

1115

public static int IsSameClsSignature (AParametersCollection a, AParametersCollection b)

1116

{

1117

int res = 0;

1118

1119

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

1120

var a_type = a.Types[i];

1121

var b_type = b.Types[i];

1122

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

1123

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

1124

res |= 1;

1125

1126

continue;

1127

}

1128

1129

var ac_a = a_type as ArrayContainer;

1130

if (ac_a == null)

1131

return 0;

1132

1133

var ac_b = b_type as ArrayContainer;

1134

if (ac_b == null)

1135

return 0;

1136

1137

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

1138

res |= 2;

1139

continue;

1140

}

1141

1142

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

1143

res |= 1;

1144

continue;

1145

}

1146

1147

return 0;

1148

}

1149

1150

return res;

1151

}

1152

1153

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

1154

{

1155

return MergeGenerated (ctx, userParams, checkConflicts,

1156

new Parameter [] { compilerParams },

1157

new TypeSpec [] { compilerTypes });

1158

}

1159

1160

1161

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

1162

1163

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

1164

{

1165

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

1166

userParams.FixedParameters.CopyTo(all_params, 0);

1167

1168

TypeSpec [] all_types;

1169

if (userParams.types != null) {

1170

all_types = new TypeSpec [all_params.Length];

1171

userParams.Types.CopyTo (all_types, 0);

1172

} else {

1173

all_types = null;

1174

}

1175

1176

int last_filled = userParams.Count;

1177

int index = 0;

1178

foreach (Parameter p in compilerParams) {

1179

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

1180

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

1181

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

1182

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

1183

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

1184

}

1185

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

1186

}

1187

}

1188

all_params [last_filled] = p;

1189

if (all_types != null)

1190

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

1191

++last_filled;

1192

}

1193

1194

ParametersCompiled parameters = new ParametersCompiled (all_params, all_types);

1195

parameters.has_params = userParams.has_params;

1196

return parameters;

1197

}

1198

1199

1200

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

1201

1202

public void CheckParameters (MemberCore member)

1203

{

1204

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

1205

var name = parameters[i].Name;

1206

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

1207

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

1208

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

1209

}

1210

}

1211

}

1212

1213

public bool Resolve (IMemberContext ec)

1214

{

1215

if (types != null)

1216

return true;

1217

1218

types = new TypeSpec [Count];

1219

1220

bool ok = true;

1221

Parameter p;

1222

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

1223

p = this [i];

1224

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

1225

if (t == null) {

1226

ok = false;

1227

continue;

1228

}

1229

1230

types [i] = t;

1231

}

1232

1233

return ok;

1234

}

1235

1236

public void ResolveDefaultValues (MemberCore m)

1237

{

1238

ResolveContext rc = null;

1239

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

1240

Parameter p = (Parameter) parameters [i];

1241

1242

1243

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

1244

1245

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

1246

if (rc == null)

1247

rc = new ResolveContext (m);

1248

1249

p.ResolveDefaultValue (rc);

1250

}

1251

}

1252

}

1253

1254

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

1255

// the argument names.

1256

public void ApplyAttributes (IMemberContext mc, MethodBase builder)

1257

{

1258

if (Count == 0)

1259

return;

1260

1261

MethodBuilder mb = builder as MethodBuilder;

1262

ConstructorBuilder cb = builder as ConstructorBuilder;

1263

var pa = mc.Module.PredefinedAttributes;

1264

1265

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

1266

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

1267

}

1268

}

1269

1270

public void VerifyClsCompliance (IMemberContext ctx)

1271

{

1272

foreach (Parameter p in FixedParameters)

1273

p.IsClsCompliant (ctx);

1274

}

1275

1276

public Parameter this [int pos] {

1277

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

1278

}

1279

1280

public Expression CreateExpressionTree (BlockContext ec, Location loc)

1281

{

1282

var initializers = new ArrayInitializer (Count, loc);

1283

foreach (Parameter p in FixedParameters) {

1284

1285

// Each parameter expression is stored to local variable

1286

// to save some memory when referenced later.

1287

1288

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

1289

if (se.Resolve (ec)) {

1290

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

1291

ec.CurrentBlock.AddScopeStatement (se);

1292

}

1293

1294

initializers.Add (p.ExpressionTreeVariableReference ());

1295

}

1296

1297

return new ArrayCreation (

1298

Parameter.ResolveParameterExpressionType (ec, loc),

1299

initializers, loc);

1300

}

1301

1302

public ParametersCompiled Clone ()

1303

{

1304

ParametersCompiled p = (ParametersCompiled) MemberwiseClone ();

1305

1306

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

1307

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

1308

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

1309

1310

return p;

1311

}

1312

}

1313

1314

1315

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

1316

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

1317

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

1318

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

1319

// this expression always returns same instance

1320

1321

public class DefaultParameterValueExpression : CompositeExpression

1322

{

1323

public DefaultParameterValueExpression (Expression expr)

1324

: base (expr)

1325

{

1326

}

1327

1328

protected override Expression DoResolve (ResolveContext rc)

1329

{

1330

return base.DoResolve (rc);

1331

}

1332

1333

public void Resolve (ResolveContext rc, Parameter p)

1334

{

1335

var expr = Resolve (rc);

1336

if (expr == null)

1337

return;

1338

1339

expr = Child;

1340

1341

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

1342

rc.Report.Error (1736, Location,

1343

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

1344

p.Name);

1345

1346

return;

1347

}

1348

1349

var parameter_type = p.Type;

1350

if (type == parameter_type)

1351

return;

1352

1353

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

1354

if (res != null) {

1355

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

1356

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

1357

res = wrap.Child;

1358

if (!(res is Constant)) {

1359

rc.Report.Error (1770, Location,

1360

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

1361

p.Name);

1362

return;

1363

}

1364

}

1365

1366

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

1367

rc.Report.Error (1763, Location,

1368

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

1369

p.Name, parameter_type.GetSignatureForError ());

1370

1371

return;

1372

}

1373

1374

this.expr = res;

1375

return;

1376

}

1377

1378

rc.Report.Error (1750, Location,

1379

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

1380

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

1381

}

1382

1383

public override object Accept (StructuralVisitor visitor)

1384

{

1385

return visitor.Visit (this);

1386

}

1387

}

1388

}

Older »