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

"An automatically implemented property `{0}' must be fully assigned before control leaves the constructor. Consider calling the default struct contructor from a constructor initializer",

1195

field.GetSignatureForError ());

1196

} else {

1197

ec.Report.Error (171, loc,

1198

"Field `{0}' must be fully assigned before control leaves the constructor",

1199

field.GetSignatureForError ());

1200

}

1201

ok = false;

1202

}

1203

}

1204

1205

return ok;

1206

}

1207

1208

public override string ToString ()

1209

{

1210

return String.Format ("TypeInfo ({0}:{1}:{2})",

1211

Offset, Length, TotalLength);

1212

}

1213

1214

class StructInfo

1215

{

1216

readonly List<FieldSpec> fields;

1217

public readonly TypeInfo[] StructFields;

1218

public readonly int Length;

1219

public readonly int TotalLength;

1220

1221

public static Dictionary<TypeSpec, StructInfo> field_type_hash;

1222

private Dictionary<string, TypeInfo> struct_field_hash;

1223

private Dictionary<string, int> field_hash;

1224

1225

bool InTransit;

1226

1227

1228

// We only need one instance per type

1229

1230

StructInfo (TypeSpec type)

1231

{

1232

field_type_hash.Add (type, this);

1233

1234

fields = MemberCache.GetAllFieldsForDefiniteAssignment (type);

1235

1236

struct_field_hash = new Dictionary<string, TypeInfo> ();

1237

field_hash = new Dictionary<string, int> (fields.Count);

1238

1239

StructFields = new TypeInfo[fields.Count];

1240

StructInfo[] sinfo = new StructInfo[fields.Count];

1241

1242

InTransit = true;

1243

1244

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

1245

var field = fields [i];

1246

1247

if (field.MemberType.IsStruct)

1248

sinfo [i] = GetStructInfo (field.MemberType);

1249

1250

if (sinfo [i] == null)

1251

field_hash.Add (field.Name, ++Length);

1252

else if (sinfo [i].InTransit) {

1253

sinfo [i] = null;

1254

return;

1255

}

1256

}

1257

1258

InTransit = false;

1259

1260

TotalLength = Length + 1;

1261

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

1262

var field = fields [i];

1263

1264

if (sinfo [i] == null)

1265

continue;

1266

1267

field_hash.Add (field.Name, TotalLength);

1268

1269

StructFields [i] = new TypeInfo (sinfo [i], TotalLength);

1270

struct_field_hash.Add (field.Name, StructFields [i]);

1271

TotalLength += sinfo [i].TotalLength;

1272

}

1273

}

1274

1275

public int Count {

1276

get {

1277

return fields.Count;

1278

}

1279

}

1280

1281

public List<FieldSpec> Fields {

1282

get {

1283

return fields;

1284

}

1285

}

1286

1287

public int this [string name] {

1288

get {

1289

int val;

1290

if (!field_hash.TryGetValue (name, out val))

1291

return 0;

1292

1293

return val;

1294

}

1295

}

1296

1297

public TypeInfo GetStructField (string name)

1298

{

1299

TypeInfo ti;

1300

if (struct_field_hash.TryGetValue (name, out ti))

1301

return ti;

1302

1303

return null;

1304

}

1305

1306

public static StructInfo GetStructInfo (TypeSpec type)

1307

{

1308

if (type.BuiltinType > 0)

1309

return null;

1310

1311

StructInfo info;

1312

if (field_type_hash.TryGetValue (type, out info))

1313

return info;

1314

1315

return new StructInfo (type);

1316

}

1317

}

1318

}

1319

1320

// <summary>

1321

// This is used by the flow analysis code to store information about a single local variable

1322

// or parameter. Depending on the variable's type, we need to allocate one or more elements

1323

// in the BitVector - if it's a fundamental or reference type, we just need to know whether

1324

// it has been assigned or not, but for structs, we need this information for each of its fields.

1325

// </summary>

1326

public class VariableInfo {

1327

readonly string Name;

1328

readonly TypeInfo TypeInfo;

1329

1330

// <summary>

1331

// The bit offset of this variable in the flow vector.

1332

// </summary>

1333

readonly int Offset;

1334

1335

// <summary>

1336

// The number of bits this variable needs in the flow vector.

1337

// The first bit always specifies whether the variable as such has been assigned while

1338

// the remaining bits contain this information for each of a struct's fields.

1339

// </summary>

1340

public readonly int Length;

1341

1342

// <summary>

1343

// If this is a parameter of local variable.

1344

// </summary>

1345

public readonly bool IsParameter;

1346

1347

VariableInfo[] sub_info;

1348

1349

VariableInfo (string name, TypeSpec type, int offset)

1350

{

1351

this.Name = name;

1352

this.Offset = offset;

1353

this.TypeInfo = TypeInfo.GetTypeInfo (type);

1354

1355

Length = TypeInfo.TotalLength;

1356

1357

Initialize ();

1358

}

1359

1360

VariableInfo (VariableInfo parent, TypeInfo type)

1361

{

1362

this.Name = parent.Name;

1363

this.TypeInfo = type;

1364

this.Offset = parent.Offset + type.Offset;

1365

this.Length = type.TotalLength;

1366

1367

this.IsParameter = parent.IsParameter;

1368

1369

Initialize ();

1370

}

1371

1372

protected void Initialize ()

1373

{

1374

TypeInfo[] sub_fields = TypeInfo.SubStructInfo;

1375

if (sub_fields != null) {

1376

sub_info = new VariableInfo [sub_fields.Length];

1377

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

1378

if (sub_fields [i] != null)

1379

sub_info [i] = new VariableInfo (this, sub_fields [i]);

1380

}

1381

} else

1382

sub_info = new VariableInfo [0];

1383

}

1384

1385

public VariableInfo (LocalVariable local_info, int offset)

1386

: this (local_info.Name, local_info.Type, offset)

1387

{

1388

this.IsParameter = false;

1389

}

1390

1391

public VariableInfo (ParametersCompiled ip, int i, int offset)

1392

: this (ip.FixedParameters [i].Name, ip.Types [i], offset)

1393

{

1394

this.IsParameter = true;

1395

}

1396

1397

public bool IsAssigned (ResolveContext ec)

1398

{

1399

return !ec.DoFlowAnalysis || ec.CurrentBranching.IsAssigned (this);

1400

}

1401

1402

public bool IsAssigned (MyBitVector vector)

1403

{

1404

if (vector == null)

1405

return true;

1406

1407

if (vector [Offset])

1408

return true;

1409

1410

// Unless this is a struct

1411

if (!TypeInfo.IsStruct)

1412

return false;

1413

1414

1415

// Following case cannot be handled fully by SetStructFieldAssigned

1416

// because we may encounter following case

1417

1418

// struct A { B b }

1419

// struct B { int value; }

1420

1421

// setting a.b.value is propagated only to B's vector and not upwards to possible parents

1422

1423

1424

// Each field must be assigned

1425

1426

for (int i = Offset + 1; i <= TypeInfo.Length + Offset; i++) {

1427

if (!vector[i])

1428

return false;

1429

}

1430

1431

// Ok, now check all fields which are structs.

1432

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

1433

VariableInfo sinfo = sub_info[i];

1434

if (sinfo == null)

1435

continue;

1436

1437

if (!sinfo.IsAssigned (vector))

1438

return false;

1439

}

1440

1441

vector [Offset] = true;

1442

return true;

1443

}

1444

1445

public bool IsEverAssigned { get; set; }

1446

1447

public bool IsStructFieldAssigned (ResolveContext ec, string name)

1448

{

1449

return !ec.DoFlowAnalysis || ec.CurrentBranching.IsStructFieldAssigned (this, name);

1450

}

1451

1452

public bool IsFullyInitialized (BlockContext bc, Location loc)

1453

{

1454

return TypeInfo.IsFullyInitialized (bc, this, loc);

1455

}

1456

1457

public bool IsStructFieldAssigned (MyBitVector vector, string field_name)

1458

{

1459

int field_idx = TypeInfo.GetFieldIndex (field_name);

1460

1461

if (field_idx == 0)

1462

return true;

1463

1464

return vector [Offset + field_idx];

1465

}

1466

1467

public void SetStructFieldAssigned (ResolveContext ec, string name)

1468

{

1469

if (ec.DoFlowAnalysis)

1470

ec.CurrentBranching.SetFieldAssigned (this, name);

1471

}

1472

1473

public void SetAssigned (ResolveContext ec)

1474

{

1475

if (ec.DoFlowAnalysis)

1476

ec.CurrentBranching.SetAssigned (this);

1477

}

1478

1479

public void SetAssigned (MyBitVector vector)

1480

{

1481

if (Length == 1)

1482

vector[Offset] = true;

1483

else

1484

vector.SetRange (Offset, Length);

1485

1486

IsEverAssigned = true;

1487

}

1488

1489

public void SetStructFieldAssigned (MyBitVector vector, string field_name)

1490

{

1491

if (vector[Offset])

1492

return;

1493

1494

int field_idx = TypeInfo.GetFieldIndex (field_name);

1495

1496

if (field_idx == 0)

1497

return;

1498

1499

var complex_field = TypeInfo.GetStructField (field_name);

1500

if (complex_field != null) {

1501

vector.SetRange (Offset + complex_field.Offset, complex_field.TotalLength);

1502

} else {

1503

vector[Offset + field_idx] = true;

1504

}

1505

1506

IsEverAssigned = true;

1507

1508

1509

// Each field must be assigned

1510

1511

for (int i = Offset + 1; i < TypeInfo.TotalLength + Offset; i++) {

1512

if (!vector[i])

1513

return;

1514

}

1515

1516

1517

// Set master struct flag to assigned when all tested struct

1518

// fields have been assigned

1519

1520

vector[Offset] = true;

1521

}

1522

1523

public VariableInfo GetStructFieldInfo (string fieldName)

1524

{

1525

TypeInfo type = TypeInfo.GetStructField (fieldName);

1526

1527

if (type == null)

1528

return null;

1529

1530

return new VariableInfo (this, type);

1531

}

1532

1533

public override string ToString ()

1534

{

1535

return String.Format ("VariableInfo ({0}:{1}:{2}:{3}:{4})",

1536

Name, TypeInfo, Offset, Length, IsParameter);

1537

}

1538

}

1539

1540

// <summary>

1541

// This is a special bit vector which can inherit from another bit vector doing a

1542

// copy-on-write strategy. The inherited vector may have a smaller size than the

1543

// current one.

1544

// </summary>

1545

public class MyBitVector {

1546

public readonly int Count;

1547

public static readonly MyBitVector Empty = new MyBitVector ();

1548

1549

// Invariant: vector != null => vector.Count == Count

1550

// Invariant: vector == null || shared == null

1551

// i.e., at most one of 'vector' and 'shared' can be non-null. They can both be null -- that means all-ones

1552

// The object in 'shared' cannot be modified, while 'vector' can be freely modified

1553

System.Collections.BitArray vector, shared;

1554

1555

MyBitVector ()

1556

{

1557

shared = new System.Collections.BitArray (0, false);

1558

}

1559

1560

public MyBitVector (MyBitVector InheritsFrom, int Count)

1561

{

1562

if (InheritsFrom != null)

1563

shared = InheritsFrom.MakeShared (Count);

1564

1565

this.Count = Count;

1566

}

1567

1568

System.Collections.BitArray MakeShared (int new_count)

1569

{

1570

// Post-condition: vector == null

1571

1572

// ensure we don't leak out dirty bits from the BitVector we inherited from

1573

if (new_count > Count &&

1574

((shared != null && shared.Count > Count) ||

1575

(shared == null && vector == null)))

1576

initialize_vector ();

1577

1578

if (vector != null) {

1579

shared = vector;

1580

vector = null;

1581

}

1582

1583

return shared;

1584

}

1585

1586

// <summary>

1587

// Get/set bit `index' in the bit vector.

1588

// </summary>

1589

public bool this [int index] {

1590

get {

1591

if (index >= Count)

1592

// FIXME: Disabled due to missing anonymous method flow analysis

1593

// throw new ArgumentOutOfRangeException ();

1594

return true;

1595

1596

if (vector != null)

1597

return vector [index];

1598

if (shared == null)

1599

return true;

1600

if (index < shared.Count)

1601

return shared [index];

1602

return false;

1603

}

1604

1605

set {

1606

// Only copy the vector if we're actually modifying it.

1607

if (this [index] != value) {

1608

if (vector == null)

1609

initialize_vector ();

1610

vector [index] = value;

1611

}

1612

}

1613

}

1614

1615

// <summary>

1616

// Performs an `or' operation on the bit vector. The `new_vector' may have a

1617

// different size than the current one.

1618

// </summary>

1619

private MyBitVector Or (MyBitVector new_vector)

1620

{

1621

if (Count == 0 || new_vector.Count == 0)

1622

return this;

1623

1624

var o = new_vector.vector != null ? new_vector.vector : new_vector.shared;

1625

1626

if (o == null) {

1627

int n = new_vector.Count;

1628

if (n < Count) {

1629

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

1630

this [i] = true;

1631

} else {

1632

SetAll (true);

1633

}

1634

return this;

1635

}

1636

1637

if (Count == o.Count) {

1638

if (vector == null) {

1639

if (shared == null)

1640

return this;

1641

initialize_vector ();

1642

}

1643

vector.Or (o);

1644

return this;

1645

}

1646

1647

int min = o.Count;

1648

if (Count < min)

1649

min = Count;

1650

1651

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

1652

if (o [i])

1653

this [i] = true;

1654

}

1655

1656

return this;

1657

}

1658

1659

// <summary>

1660

// Performs an `and' operation on the bit vector. The `new_vector' may have

1661

// a different size than the current one.

1662

// </summary>

1663

private MyBitVector And (MyBitVector new_vector)

1664

{

1665

if (Count == 0)

1666

return this;

1667

1668

var o = new_vector.vector != null ? new_vector.vector : new_vector.shared;

1669

1670

if (o == null) {

1671

for (int i = new_vector.Count; i < Count; ++i)

1672

this [i] = false;

1673

return this;

1674

}

1675

1676

if (o.Count == 0) {

1677

SetAll (false);

1678

return this;

1679

}

1680

1681

if (Count == o.Count) {

1682

if (vector == null) {

1683

if (shared == null) {

1684

shared = new_vector.MakeShared (Count);

1685

return this;

1686

}

1687

initialize_vector ();

1688

}

1689

vector.And (o);

1690

return this;

1691

}

1692

1693

int min = o.Count;

1694

if (Count < min)

1695

min = Count;

1696

1697

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

1698

if (! o [i])

1699

this [i] = false;

1700

}

1701

1702

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

1703

this [i] = false;

1704

1705

return this;

1706

}

1707

1708

public static MyBitVector operator & (MyBitVector a, MyBitVector b)

1709

{

1710

if (a == b)

1711

return a;

1712

if (a == null)

1713

return b.Clone ();

1714

if (b == null)

1715

return a.Clone ();

1716

if (a.Count > b.Count)

1717

return a.Clone ().And (b);

1718

else

1719

return b.Clone ().And (a);

1720

}

1721

1722

public static MyBitVector operator | (MyBitVector a, MyBitVector b)

1723

{

1724

if (a == b)

1725

return a;

1726

if (a == null)

1727

return new MyBitVector (null, b.Count);

1728

if (b == null)

1729

return new MyBitVector (null, a.Count);

1730

if (a.Count > b.Count)

1731

return a.Clone ().Or (b);

1732

else

1733

return b.Clone ().Or (a);

1734

}

1735

1736

public MyBitVector Clone ()

1737

{

1738

return Count == 0 ? Empty : new MyBitVector (this, Count);

1739

}

1740

1741

public void SetRange (int offset, int length)

1742

{

1743

if (offset > Count || offset + length > Count)

1744

throw new ArgumentOutOfRangeException ("flow-analysis");

1745

1746

if (shared == null && vector == null)

1747

return;

1748

1749

int i = 0;

1750

if (shared != null) {

1751

if (offset + length <= shared.Count) {

1752

for (; i < length; ++i)

1753

if (!shared [i+offset])

1754

break;

1755

if (i == length)

1756

return;

1757

}

1758

initialize_vector ();

1759

}

1760

for (; i < length; ++i)

1761

vector [i+offset] = true;

1762

1763

}

1764

1765

public void SetAll (bool value)

1766

{

1767

// Don't clobber Empty

1768

if (Count == 0)

1769

return;

1770

shared = value ? null : Empty.MakeShared (Count);

1771

vector = null;

1772

}

1773

1774

void initialize_vector ()

1775

{

1776

// Post-condition: vector != null

1777

if (shared == null) {

1778

vector = new System.Collections.BitArray (Count, true);

1779

return;

1780

}

1781

1782

vector = new System.Collections.BitArray (shared);

1783

if (Count != vector.Count)

1784

vector.Length = Count;

1785

shared = null;

1786

}

1787

1788

StringBuilder Dump (StringBuilder sb)

1789

{

1790

var dump = vector == null ? shared : vector;

1791

if (dump == null)

1792

return sb.Append ("/");

1793

if (dump == shared)

1794

sb.Append ("=");

1795

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

1796

sb.Append (dump [i] ? "1" : "0");

1797

return sb;

1798

}

1799

1800

public override string ToString ()

1801

{

1802

return Dump (new StringBuilder ("{")).Append ("}").ToString ();

1803

}

1804

}

1805

}

Older »