129if (this.Count == 0) 135return TextSpan.FromBounds(this[0].FullSpan.Start, this[this.Count - 1].FullSpan.End); 147if (this.Count == 0) 153return TextSpan.FromBounds(this[0].Span.Start, this[this.Count - 1].Span.End); 190return this.Insert(this.Count, node); 199return this.InsertRange(this.Count, nodes); 224if (index < 0 || index > this.Count) 253if (index < 0 || index > this.Count) 298if (index >= 0 && index < this.Count) 350return this[this.Count - 1]; 360return this[this.Count - 1]; 373Debug.Assert(_node == null || Count != 0); 516for (int i = this.Count - 1; i >= 0; i--) 529for (int i = this.Count - 1; i >= 0; i--)

29if (newIndex < _list.Count)

81this.AddRange(list, 0, list.Count); 105this.AddRange(list, 0, list.Count);

89for (var i = fieldIndex; i < members.Count; i++)

22if (existingImports.Count == 0)

200Contract.ThrowIfTrue(availableIndices != null && availableIndices.Count != declarationList.Count + 1); 287var index = GetPreferredIndex(declarationList.Count, availableIndices, forward: false); 294return declarationList.Count; 343Debug.Assert(desiredGroupIndex <= declarationList.Count); 346while (desiredGroupIndex < declarationList.Count)

36Debug.Assert(clauses.Count > 0);

3354for (int additionalRankIndex = 1; additionalRankIndex < node.Type.RankSpecifiers.Count; additionalRankIndex++) 3815if (rankSpecifiers.Count != 1 ||

45if (node.Contents.Count == 0)

222if (attributesBuilder.Any(a => a.Count > 0))

94for (int i = node.Body.Clauses.Count - 1; i >= 0; i--) 111for (int i = clauses.Count - 1; i >= 0; i--)

41if (node.AttributeLists.Count > 0) 1856if (node.AttributeLists.Count > 0) 1870int nStatements = syntaxStatements.Count; 3111int n = catchClauses.Count; 3259: (filter.Parent.Parent is TryStatementSyntax s && s.Catches.Count == 1 && s.Finally == null)

656for (int i = node.RankSpecifiers.Count - 1; i >= 0; i--)

33if (node.Sections.Count == 0) 166var boundSwitchSectionsBuilder = ArrayBuilder<BoundSwitchSection>.GetInstance(SwitchSyntax.Sections.Count); 187var boundLabelsBuilder = ArrayBuilder<BoundSwitchLabel>.GetInstance(node.Labels.Count); 200var boundStatementsBuilder = ArrayBuilder<BoundStatement>.GetInstance(node.Statements.Count);

3594if (unit.Members.Count > 0)

625Debug.Assert(structure.Content.Count == 2); 627Debug.Assert(elementSyntax.Attributes.Count == 1);

57if (members.Count == 0) 505if (node.AttributeLists.Count > 0) 691if (node.Members.Count == 0)

628if (attributes.Count > 0)

323if (typeParameters.Length == 0 || constraintClauses.Count == 0) 359if (constraintClauses.Count == 0)

87if (usingsSyntax.Count == 0)

4621if (members.Count == 0)

334if (skipPartialDeclarationsWithoutConstraintClauses && constraintClauses.Count == 0) 343if (constraintClauses.Count == 0) 390if (GetConstraintClauses((CSharpSyntaxNode)decl.SyntaxReference.GetSyntax(), out _).Count != 0) 415if (skipPartialDeclarationsWithoutConstraintClauses && constraintClauses.Count == 0) 424if (constraintClauses.Count == 0)

176if (syntax.ConstraintClauses.Count > 0)

80(syntax.AttributeLists.Count == 0) &&

130if (indexerNameAttributeLists.Count == 0 || isExplicitInterfaceImplementation) 385Debug.Assert(indexerNameAttributeLists.Count != 0);

1346if (constraintClauses.Count > 0)

142for (int i = 0, n = list.Count; i < n; i++)

248if (selectOrGroupClause.IsKind(SyntaxKind.SelectClause) && containingBody.Clauses.Count == 0)

100int count = attributesSyntaxList.Count;

38var semicolonToken = members.Count == 0 ? Token(SyntaxKind.SemicolonToken) : default; 39var openBraceToken = members.Count == 0 ? default : Token(SyntaxKind.OpenBraceToken); 40var closeBraceToken = members.Count == 0 ? default : Token(SyntaxKind.CloseBraceToken);

425for (int i = arrayTypeSyntax.RankSpecifiers.Count - 1; i >= 0; i--)

1625Debug.Assert(structure.Content.Count == 2); 1627Debug.Assert(elementSyntax.Attributes.Count == 1);

423if (index >= 0 && index < list.Count)

26block != null && block.Statements.Count == 1)

113if (typeDeclaration.AttributeLists.Count > 0) 128if (member.AttributeLists.Count > 0)

111if (sections.Count == 0) 135Debug.Assert(labels.Count >= 1); 136if (labels.Count == 1) 221switch (section.Statements.Count)

172if (block.Statements.Count == 0)

286if (anonymousFunction.Block != null && anonymousFunction.Block.Statements.Count == 1)

62whenTrueStatement = ifStatement.Statement is BlockSyntax { Statements.Count: 1 } block

109? block.Statements.Count == 1 ? block.Statements[0] : null

93if (block.Statements.Count == 1)

490if (attributes.Count == 0)

82if (section.Labels.Count == 0 && 83section.Statements.Count == 0) 112if (section.Statements.Count == 0)

72if (block.Statements.Count != 1)

161for (var i = 0; i < attributes.Count; ++i) 185if (switchSection.Labels.Count < 2) 193for (var i = 0; i < switchSection.Labels.Count - 1; ++i) 202if (switchSection.Labels[switchSection.Labels.Count - 1] != null) 204AddSuppressWrappingIfOnSingleLineOperation(list, switchSection.Labels[switchSection.Labels.Count - 1].GetFirstToken(includeZeroWidth: true), switchSection.GetLastToken(includeZeroWidth: true)); 223if (parameterNode.AttributeLists.Count != 0)

453return contextNode.GetAncestorsOrThis<BaseNamespaceDeclarationSyntax>().FirstOrDefault(n => n.Usings.Count > 0); 466return containingNamespace.GetAncestors<BaseNamespaceDeclarationSyntax>().FirstOrDefault(n => n.Usings.Count > 0);

52return accessorList is { Accessors: [{ AttributeLists.Count: 0, RawKind: (int)SyntaxKind.GetAccessorDeclaration } accessor] }

219while (index + 1 < statements.Count && statements[index + 1] is LocalFunctionStatementSyntax) 223if (index == statements.Count - 1)

31if (organizedExternAliasList.Count > 0 && organizedUsingList.Count > 0) 42for (var i = 1; i < organizedUsingList.Count; i++) 103if (externAliasList.Count > 0 || usingList.Count > 0)

127if (root.Externs.Count == 0) 142var endOfList = root.Usings.Count - 1; 145for (var i = 0; i < root.Usings.Count; i++)

132if (switchLabels.Count == 1) 146for (var i = 1; i < switchLabels.Count; i++) 207Debug.Assert(statements.Count is 1 or 2);

787if (index == summaryContent.Count - 1 &&

28return members.Count == 1

177if (node is not SwitchSectionSyntax section || section.Statements.Count == 0)

412for (var i = clauses.Count - 1; i >= 0; i--)

174for (var i = declarationIndex + 1; i < block.Statements.Count; i++)

62if (accessorList.Accessors.Count == 1) 70else if (accessorList.Accessors.Count == 2)

113=> list.Count > 0 ? list[0].SpanStart : container.Span.End;

54for (var i = 0; i < usings.Count; i++) 70if (i < usings.Count - 1) 133Debug.Assert(oldUsings.Count == newUsings.Count); 136for (var i = 0; i < oldUsings.Count; i++) 168if (finalUsings.Count == 0 && 169resultCompilationUnit.Externs.Count == 0 && 170resultCompilationUnit.Members.Count >= 1) 207if (finalUsings.Count == 0 && 208resultNamespace.Externs.Count == 0 && 209resultNamespace.Members.Count >= 1)

856for (var i = 0; i < arrayType.RankSpecifiers.Count; i++)

95blockSyntax.Statements.Count == 0)

237if (compUnit.Usings.Count > 0 && compUnit.Usings.Last().GetLastToken(includeZeroWidth: true) == token) 242if (compUnit.Externs.Count > 0 && compUnit.Externs.Last().GetLastToken(includeZeroWidth: true) == token) 254if (compUnit.AttributeLists.Count > 0 && compUnit.AttributeLists.Last().GetLastToken(includeZeroWidth: true) == token)

431(compilationUnit.Externs.Count > 0 || compilationUnit.Usings.Count > 0)) 1979(compilationUnit.Externs.Count > 0 || compilationUnit.Usings.Count > 0))

202var compilationUnitWithoutBlankLine = compilationUnitWithoutUsings.Usings.Count == 0 319if (members.Count == 0) 358if (members.Count == 0) 392|| compilationUnit.Members.Count > 1

159accessorList?.Accessors.Count == 1)

24if (members.Count == 0) 37for (var i = 0; i < members.Count - 1; i++) 149return (TypeDeclarationSyntax)EnsureHasBraces(typeDeclaration, typeDeclaration.Members.Count > 0);

72if (originalBlock.Statements.Count == currentBlock.Statements.Count)

54for (int i = 0, n = interpolatedString.Contents.Count; i < n && errors.Count > 0; i++)

215for (var i = 0; i < interpolatedString.Contents.Count; i++)

141if (localFunction.AttributeLists.Count > 0)

36if (blockStatements.Count == 1)

274if (members.Count > 0)

41if (namespaceDecls.Length == 1 && compilationUnit.Members.Count == 1)

95if (root.Externs.Count > 0 || 96root.Usings.Count > 0)

172((CompilationUnitSyntax)context.SyntaxTree.GetRoot(cancellationToken)).Externs.Count > 0)

127if (propertyDeclaration.AccessorList?.Accessors.Count == 1 &&

133if (bodyBlock.Statements.Count == 0)

117if (block.Statements.Count == 0)

111namespaceDeclaration.Members.Count >= 2) 188if (methodDeclaration.Body.Statements.Count > 0)

113if (typeDeclaration.AttributeLists.Count > 0) 128if (member.AttributeLists.Count > 0)

132if (switchLabels.Count == 1) 146for (var i = 1; i < switchLabels.Count; i++) 207Debug.Assert(statements.Count is 1 or 2);

111if (sections.Count == 0) 135Debug.Assert(labels.Count >= 1); 136if (labels.Count == 1) 221switch (section.Statements.Count)

787if (index == summaryContent.Count - 1 &&

174for (var i = declarationIndex + 1; i < block.Statements.Count; i++)

172if (block.Statements.Count == 0)

62if (accessorList.Accessors.Count == 1) 70else if (accessorList.Accessors.Count == 2)

286if (anonymousFunction.Block != null && anonymousFunction.Block.Statements.Count == 1)

62whenTrueStatement = ifStatement.Statement is BlockSyntax { Statements.Count: 1 } block

109? block.Statements.Count == 1 ? block.Statements[0] : null

93if (block.Statements.Count == 1)

269if (documentationComment.Content.Count != 1)

374if (switchLabel.Parent is not SwitchSectionSyntax switchSection || switchSection.Statements.Count == 0) 778for (var i = 0; i < accessors.Count; i++) 780if (position <= accessors[i].FullSpan.End || i == accessors.Count - 1)

693if (property.AccessorList!.Accessors.Count == 1) 2654if (tryStatement.Catches.Count == 0)

95blockSyntax.Statements.Count == 0)

53if (block.Statements.Count == 0)

98if (body is BlockSyntax { Statements.Count: > 0 } block)

85else if (block.Statements.Count > 0) 95Debug.Assert(block.Statements.Count == 0);

30=> tryStatement.Catches.Count > 0;

163for (var i = 0; i < oldMembers.Count; i++)

263return block.Statements.Count == 1 && IsSingleStatement(block.Statements[0]);

72if (block.Statements.Count != 1)

248if (selectOrGroupClause.IsKind(SyntaxKind.SelectClause) && containingBody.Clauses.Count == 0)

264if (children.Count == 0) 272for (var i = 0; i < children.Count - 1; i++) 302var nextToLast = children[children.Count - 2];

202var compilationUnitWithoutBlankLine = compilationUnitWithoutUsings.Usings.Count == 0 319if (members.Count == 0) 358if (members.Count == 0) 392|| compilationUnit.Members.Count > 1

40if (compilationUnit.Usings.Count > 0 || 41compilationUnit.Externs.Count > 0 || 42compilationUnit.Members.Count > 0 || 43compilationUnit.AttributeLists.Count > 0)

30if (section.Labels.Count > 0 && section.Statements.Count > 0)

52return accessorList is { Accessors: [{ AttributeLists.Count: 0, RawKind: (int)SyntaxKind.GetAccessorDeclaration } accessor] }

72if (originalBlock.Statements.Count == currentBlock.Statements.Count)

219while (index + 1 < statements.Count && statements[index + 1] is LocalFunctionStatementSyntax) 223if (index == statements.Count - 1)

2299=> node is ClassDeclarationSyntax { AttributeLists: { Count: > 0 } };

243Assert.Equal(3, testClass.Members.Count); 246Assert.Equal(10, mainStats.Count); 375Assert.Equal(2, testClass.Members.Count); 378Assert.Equal(5, mainStats.Count); 478Assert.Equal(2, testClass.Members.Count); 481Assert.Equal(5, mainStats.Count); 531Assert.Equal(1, testClass.Members.Count); 534Assert.Equal(6, mainStats.Count);

308Assert.Equal(2, accessorList.Count); 389Assert.Equal(2, accessorList.Count); 2789Assert.Equal(2, root.Members.Count); 2791Assert.Equal(1, nsSyntax.Members.Count); 2867Assert.Equal(2, explicitPropertyAccessors.Count);

217Assert.True(statementType.AttributeLists.Count == 0);

157Assert.True(statementType.AttributeLists.Count == 0);

100Assert.True(statementType.AttributeLists.Count == 0);

438Assert.Equal(memberInfo.Length, node.Members.Count); 1684Assert.Equal(1, node.Members.Count);

85Assert.Equal(2, doc.Content.Count); 154Assert.Equal(3, doc.Content.Count); 175Assert.Equal(3, doc.Content.Count); 200Assert.Equal(3, doc.Content.Count); 222Assert.Equal(2, doc.Content.Count); 227Assert.Equal(1, element.Attributes.Count); 245Assert.Equal(2, doc.Content.Count); 250Assert.Equal(1, element.Attributes.Count); 268Assert.Equal(2, doc.Content.Count); 273Assert.Equal(1, element.Attributes.Count); 295Assert.Equal(2, doc.Content.Count); 300Assert.Equal(1, element.Attributes.Count); 323Assert.Equal(2, doc.Content.Count); 347Assert.Equal(3, doc.Content.Count); 372Assert.Equal(3, doc.Content.Count); 398Assert.Equal(3, doc.Content.Count); 425Assert.Equal(2, doc.Content.Count); 430Assert.Equal(1, element.Attributes.Count); 452Assert.Equal(2, doc.Content.Count); 457Assert.Equal(1, element.Attributes.Count); 480Assert.Equal(3, doc.Content.Count); 485Assert.Equal(1, element.Attributes.Count); 509Assert.Equal(3, doc.Content.Count); 514Assert.Equal(1, element.Attributes.Count); 539Assert.Equal(2, doc.Content.Count); 544Assert.Equal(1, element.Attributes.Count); 568Assert.Equal(2, doc.Content.Count); 573Assert.Equal(1, element.Attributes.Count); 598Assert.Equal(3, doc.Content.Count); 603Assert.Equal(1, element.Attributes.Count); 629Assert.Equal(3, doc.Content.Count); 634Assert.Equal(1, element.Attributes.Count); 652Assert.Equal(2, doc.Content.Count); 674Assert.Equal(2, doc.Content.Count); 696Assert.Equal(2, doc.Content.Count); 718Assert.Equal(2, doc.Content.Count); 760Assert.Equal(2, doc.Content.Count); 767Assert.Equal(1, element.Content.Count); 794Assert.Equal(3, doc.Content.Count); 801Assert.Equal(1, element.Content.Count); 827Assert.Equal(2, doc.Content.Count); 858Assert.Equal(3, doc.Content.Count); 886Assert.Equal(2, doc.Content.Count); 911Assert.Equal(2, doc.Content.Count); 937Assert.Equal(2, doc.Content.Count); 962Assert.Equal(2, doc.Content.Count); 989Assert.Equal(2, doc.Content.Count); 1020Assert.Equal(3, doc.Content.Count); 1048Assert.Equal(2, doc.Content.Count); 1073Assert.Equal(2, doc.Content.Count); 1098Assert.Equal(2, doc.Content.Count); 1125Assert.Equal(2, doc.Content.Count); 1158Assert.Equal(3, doc.Content.Count); 1189Assert.Equal(2, doc.Content.Count); 1215Assert.Equal(2, doc.Content.Count); 1242Assert.Equal(2, doc.Content.Count); 1270Assert.Equal(1, doc.Content.Count); 1315Assert.Equal(1, doc.Content.Count); 1339Assert.Equal(1, doc.Content.Count); 1364Assert.Equal(1, doc.Content.Count); 1388Assert.Equal(1, doc.Content.Count); 1413Assert.Equal(1, doc.Content.Count); 1437Assert.Equal(1, doc.Content.Count); 1462Assert.Equal(1, doc.Content.Count); 1486Assert.Equal(1, doc.Content.Count); 1566Assert.Equal(2, doc.Content.Count); 1571Assert.Equal(1, element.Attributes.Count); 1594Assert.Equal(2, doc.Content.Count); 1599Assert.Equal(1, element.Attributes.Count); 1622Assert.Equal(2, doc.Content.Count); 1626Assert.Equal(1, element.Attributes.Count); 1648Assert.Equal(1, doc.Content.Count); 1992Assert.Equal(0, (firstComment.Content[0] as XmlElementSyntax).StartTag.Attributes.Count); 2028Assert.Equal(0, (firstComment.Content[0] as XmlElementSyntax).StartTag.Attributes.Count); 2772Assert.Equal(3, doc.Content.Count); 3321Assert.Equal(0, xmlElement.Content.Count); 3381Assert.Equal(attributes.Keys.Count, xmlAttributes.Count);

35Assert.Equal(1, file.Externs.Count); 58Assert.Equal(1, file.Usings.Count); 80Assert.Equal(1, file.Usings.Count); 102Assert.Equal(1, file.Usings.Count); 117Assert.Equal(1, file.Usings.Count); 132Assert.Equal(1, file.Usings.Count); 147Assert.Equal(1, file.Usings.Count); 169Assert.Equal(1, file.Usings.Count); 191Assert.Equal(1, file.Usings.Count); 213Assert.Equal(1, file.Usings.Count); 237Assert.Equal(1, file.Usings.Count); 261Assert.Equal(1, file.AttributeLists.Count); 287Assert.Equal(1, file.AttributeLists.Count); 316Assert.Equal(1, file.AttributeLists.Count); 345Assert.Equal(1, file.AttributeLists.Count); 372Assert.Equal(1, file.AttributeLists.Count); 400Assert.Equal(1, file.AttributeLists.Count); 430Assert.Equal(1, file.AttributeLists.Count); 461Assert.Equal(1, file.AttributeLists.Count); 497Assert.Equal(1, file.AttributeLists.Count); 529Assert.Equal(2, file.AttributeLists.Count); 566Assert.Equal(1, file.Members.Count); 576Assert.Equal(0, ns.Usings.Count); 577Assert.Equal(0, ns.Members.Count); 588Assert.Equal(1, file.Members.Count); 598Assert.Equal(0, ns.Usings.Count); 599Assert.Equal(0, ns.Members.Count); 609Assert.Equal(1, file.Members.Count); 619Assert.Equal(0, ns.Usings.Count); 620Assert.Equal(0, ns.Members.Count); 631Assert.Equal(1, file.Members.Count); 641Assert.Equal(1, ns.Usings.Count); 643Assert.Equal(0, ns.Members.Count); 654Assert.Equal(1, file.Members.Count); 664Assert.Equal(1, ns.Usings.Count); 666Assert.Equal(0, ns.Members.Count); 676Assert.Equal(1, file.Members.Count); 686Assert.Equal(1, ns.Externs.Count); 688Assert.Equal(0, ns.Members.Count); 699Assert.Equal(1, file.Members.Count); 709Assert.Equal(1, ns.Externs.Count); 711Assert.Equal(0, ns.Members.Count); 721Assert.Equal(1, file.Members.Count); 731Assert.Equal(1, ns.Usings.Count); 733Assert.Equal(0, ns.Externs.Count); 734Assert.Equal(0, ns.Members.Count); 745Assert.Equal(1, file.Members.Count); 755Assert.Equal(0, ns.Usings.Count); 756Assert.Equal(1, ns.Members.Count); 763Assert.Equal(0, ns2.Usings.Count); 764Assert.Equal(0, ns2.Members.Count); 776Assert.Equal(1, file.Members.Count); 782Assert.Equal(0, cs.AttributeLists.Count); 789Assert.Equal(0, cs.ConstraintClauses.Count); 791Assert.Equal(0, cs.Members.Count); 802Assert.Equal(1, file.Members.Count); 808Assert.Equal(0, cs.AttributeLists.Count); 816Assert.Equal(0, cs.ConstraintClauses.Count); 818Assert.Equal(0, cs.Members.Count); 829Assert.Equal(1, file.Members.Count); 835Assert.Equal(0, cs.AttributeLists.Count); 843Assert.Equal(0, cs.ConstraintClauses.Count); 845Assert.Equal(0, cs.Members.Count); 856Assert.Equal(1, file.Members.Count); 862Assert.Equal(0, cs.AttributeLists.Count); 870Assert.Equal(0, cs.ConstraintClauses.Count); 872Assert.Equal(0, cs.Members.Count); 883Assert.Equal(1, file.Members.Count); 889Assert.Equal(0, cs.AttributeLists.Count); 897Assert.Equal(0, cs.ConstraintClauses.Count); 899Assert.Equal(0, cs.Members.Count); 910Assert.Equal(1, file.Members.Count); 916Assert.Equal(0, cs.AttributeLists.Count); 924Assert.Equal(0, cs.ConstraintClauses.Count); 926Assert.Equal(0, cs.Members.Count); 937Assert.Equal(1, file.Members.Count); 943Assert.Equal(0, cs.AttributeLists.Count); 951Assert.Equal(0, cs.ConstraintClauses.Count); 953Assert.Equal(0, cs.Members.Count); 964Assert.Equal(1, file.Members.Count); 970Assert.Equal(1, cs.AttributeLists.Count); 978Assert.Equal(0, cs.ConstraintClauses.Count); 980Assert.Equal(0, cs.Members.Count); 991Assert.Equal(1, file.Members.Count); 997Assert.Equal(2, cs.AttributeLists.Count); 1006Assert.Equal(0, cs.ConstraintClauses.Count); 1008Assert.Equal(0, cs.Members.Count); 1019Assert.Equal(1, file.Members.Count); 1025Assert.Equal(1, cs.AttributeLists.Count); 1033Assert.Equal(0, cs.ConstraintClauses.Count); 1035Assert.Equal(0, cs.Members.Count); 1046Assert.Equal(1, file.Members.Count); 1052Assert.Equal(0, cs.AttributeLists.Count); 1064Assert.Equal(0, cs.ConstraintClauses.Count); 1066Assert.Equal(0, cs.Members.Count); 1077Assert.Equal(1, file.Members.Count); 1083Assert.Equal(0, cs.AttributeLists.Count); 1096Assert.Equal(0, cs.ConstraintClauses.Count); 1098Assert.Equal(0, cs.Members.Count); 1109Assert.Equal(1, file.Members.Count); 1115Assert.Equal(0, cs.AttributeLists.Count); 1125Assert.Equal(1, cs.ConstraintClauses.Count); 1138Assert.Equal(0, cs.Members.Count); 1149Assert.Equal(1, file.Members.Count); 1157Assert.Equal(0, cs.AttributeLists.Count); 1166Assert.Equal(1, cs.ConstraintClauses.Count); 1179Assert.Equal(0, cs.Members.Count); 1212Assert.Equal(1, file.Members.Count); 1218Assert.Equal(0, cs.AttributeLists.Count); 1228Assert.Equal(1, cs.ConstraintClauses.Count); 1245Assert.Equal(0, cs.Members.Count); 1256Assert.Equal(1, file.Members.Count); 1262Assert.Equal(0, cs.AttributeLists.Count); 1272Assert.Equal(1, cs.ConstraintClauses.Count); 1286Assert.Equal(0, cs.Members.Count); 1297Assert.Equal(1, file.Members.Count); 1303Assert.Equal(0, cs.AttributeLists.Count); 1313Assert.Equal(1, cs.ConstraintClauses.Count); 1327Assert.Equal(0, cs.Members.Count); 1338Assert.Equal(1, file.Members.Count); 1344Assert.Equal(0, cs.AttributeLists.Count); 1354Assert.Equal(1, cs.ConstraintClauses.Count); 1383Assert.Equal(0, cs.Members.Count); 1394Assert.Equal(1, file.Members.Count); 1400Assert.Equal(0, cs.AttributeLists.Count); 1409Assert.Equal(2, cs.ConstraintClauses.Count); 1438Assert.Equal(0, cs.Members.Count); 1449Assert.Equal(1, file.Members.Count); 1455Assert.Equal(0, cs.AttributeLists.Count); 1464Assert.Equal(2, cs.ConstraintClauses.Count); 1495Assert.Equal(1, file.Members.Count); 1501Assert.Equal(0, cs.AttributeLists.Count); 1510Assert.Equal(2, cs.ConstraintClauses.Count); 1539Assert.Equal(1, file.Members.Count); 1545Assert.Equal(0, cs.AttributeLists.Count); 1559Assert.Equal(1, cs.ConstraintClauses.Count); 1588Assert.Equal(0, cs.Members.Count); 1599Assert.Equal(1, file.Members.Count); 1605Assert.Equal(0, cs.AttributeLists.Count); 1612Assert.Equal(0, cs.ConstraintClauses.Count); 1624Assert.Equal(1, file.Members.Count); 1630Assert.Equal(0, cs.AttributeLists.Count); 1638Assert.Equal(0, gn.Parameters[0].AttributeLists.Count); 1642Assert.Equal(0, cs.ConstraintClauses.Count); 1654Assert.Equal(1, file.Members.Count); 1660Assert.Equal(0, cs.AttributeLists.Count); 1669Assert.Equal(1, gn.Parameters[0].AttributeLists.Count); 1674Assert.Equal(0, cs.ConstraintClauses.Count); 1686Assert.Equal(1, file.Members.Count); 1692Assert.Equal(0, cs.AttributeLists.Count); 1699Assert.Equal(0, cs.ConstraintClauses.Count); 1711Assert.Equal(1, file.Members.Count); 1717Assert.Equal(0, cs.AttributeLists.Count); 1724Assert.Equal(0, cs.ConstraintClauses.Count); 1728Assert.Equal(1, cs.Members.Count); 1732Assert.Equal(0, cs.AttributeLists.Count); 1739Assert.Equal(0, cs.ConstraintClauses.Count); 1751Assert.Equal(1, file.Members.Count); 1757Assert.Equal(0, cs.AttributeLists.Count); 1764Assert.Equal(0, cs.ConstraintClauses.Count); 1768Assert.Equal(1, cs.Members.Count); 1772Assert.Equal(0, cs.AttributeLists.Count); 1780Assert.Equal(0, cs.ConstraintClauses.Count); 1792Assert.Equal(1, file.Members.Count); 1798Assert.Equal(0, cs.AttributeLists.Count); 1805Assert.Equal(0, cs.ConstraintClauses.Count); 1809Assert.Equal(1, cs.Members.Count); 1813Assert.Equal(0, cs.AttributeLists.Count); 1821Assert.Equal(0, cs.ConstraintClauses.Count); 1833Assert.Equal(1, file.Members.Count); 1839Assert.Equal(0, cs.AttributeLists.Count); 1846Assert.Equal(0, cs.ConstraintClauses.Count); 1850Assert.Equal(1, cs.Members.Count); 1854Assert.Equal(0, cs.AttributeLists.Count); 1863Assert.Equal(0, cs.ConstraintClauses.Count); 1875Assert.Equal(1, file.Members.Count); 1881Assert.Equal(0, cs.AttributeLists.Count); 1888Assert.Equal(0, cs.ConstraintClauses.Count); 1892Assert.Equal(1, cs.Members.Count); 1896Assert.Equal(0, cs.AttributeLists.Count); 1905Assert.Equal(0, cs.ConstraintClauses.Count); 1917Assert.Equal(1, file.Members.Count); 1923Assert.Equal(0, cs.AttributeLists.Count); 1930Assert.Equal(0, cs.ConstraintClauses.Count); 1934Assert.Equal(1, cs.Members.Count); 1938Assert.Equal(0, cs.AttributeLists.Count); 1946Assert.Equal(0, cs.ConstraintClauses.Count); 1958Assert.Equal(1, file.Members.Count); 1964Assert.Equal(0, cs.AttributeLists.Count); 1971Assert.Equal(0, cs.ConstraintClauses.Count); 1975Assert.Equal(1, cs.Members.Count); 1979Assert.Equal(0, cs.AttributeLists.Count); 1987Assert.Equal(0, cs.ConstraintClauses.Count); 1999Assert.Equal(1, file.Members.Count); 2026Assert.Equal(1, file.Members.Count); 2054Assert.Equal(1, file.Members.Count); 2101Assert.Equal(1, file.Members.Count); 2147Assert.Equal(1, file.Members.Count); 2162Assert.Equal(0, ds.ParameterList.Parameters[0].AttributeLists.Count); 2182Assert.Equal(1, file.Members.Count); 2197Assert.Equal(0, ds.ParameterList.Parameters[0].AttributeLists.Count); 2217Assert.Equal(1, file.Members.Count); 2232Assert.Equal(0, ds.ParameterList.Parameters[0].AttributeLists.Count); 2239Assert.Equal(0, ds.ParameterList.Parameters[1].AttributeLists.Count); 2259Assert.Equal(1, file.Members.Count); 2274Assert.Equal(0, ds.ParameterList.Parameters[0].AttributeLists.Count); 2295Assert.Equal(1, file.Members.Count); 2310Assert.Equal(0, ds.ParameterList.Parameters[0].AttributeLists.Count); 2331Assert.Equal(1, file.Members.Count); 2346Assert.Equal(0, ds.ParameterList.Parameters[0].AttributeLists.Count); 2367Assert.Equal(1, file.Members.Count); 2383Assert.Equal(0, ds.ParameterList.Parameters[0].AttributeLists.Count); 2401Assert.Equal(1, file.Members.Count); 2416Assert.Equal(1, ds.ParameterList.Parameters[0].AttributeLists.Count); 2437Assert.Equal(1, file.Members.Count); 2443Assert.Equal(0, cs.AttributeLists.Count); 2450Assert.Equal(0, cs.ConstraintClauses.Count); 2454Assert.Equal(1, cs.Members.Count); 2479Assert.Equal(1, file.Members.Count); 2485Assert.Equal(0, cs.AttributeLists.Count); 2492Assert.Equal(0, cs.ConstraintClauses.Count); 2496Assert.Equal(1, cs.Members.Count); 2500Assert.Equal(0, ms.AttributeLists.Count); 2511Assert.Equal(0, ms.ConstraintClauses.Count); 2525Assert.Equal(1, file.Members.Count); 2531Assert.Equal(0, cs.AttributeLists.Count); 2538Assert.Equal(0, cs.ConstraintClauses.Count); 2542Assert.Equal(1, cs.Members.Count); 2546Assert.Equal(0, ms.AttributeLists.Count); 2556Assert.Equal(0, ms.ConstraintClauses.Count); 2571Assert.Equal(1, file.Members.Count); 2577Assert.Equal(0, cs.AttributeLists.Count); 2584Assert.Equal(0, cs.ConstraintClauses.Count); 2588Assert.Equal(1, cs.Members.Count); 2592Assert.Equal(0, ms.AttributeLists.Count); 2602Assert.Equal(0, ms.ConstraintClauses.Count); 2616Assert.Equal(1, file.Members.Count); 2622Assert.Equal(0, cs.AttributeLists.Count); 2629Assert.Equal(0, cs.ConstraintClauses.Count); 2633Assert.Equal(1, cs.Members.Count); 2646Assert.Equal(1, file.Members.Count); 2652Assert.Equal(0, cs.AttributeLists.Count); 2659Assert.Equal(0, cs.ConstraintClauses.Count); 2663Assert.Equal(1, cs.Members.Count); 2674Assert.Equal(1, file.Members.Count); 2680Assert.Equal(0, cs.AttributeLists.Count); 2687Assert.Equal(0, cs.ConstraintClauses.Count); 2691Assert.Equal(1, cs.Members.Count); 2695Assert.Equal(0, ms.AttributeLists.Count); 2710Assert.Equal(0, ms.ConstraintClauses.Count); 2742Assert.Equal(1, file.Members.Count); 2748Assert.Equal(0, cs.AttributeLists.Count); 2755Assert.Equal(0, cs.ConstraintClauses.Count); 2759Assert.Equal(1, cs.Members.Count); 2763Assert.Equal(0, ms.AttributeLists.Count); 2775Assert.Equal(0, ms.ConstraintClauses.Count); 2789Assert.Equal(1, file.Members.Count); 2795Assert.Equal(0, structDecl.AttributeLists.Count); 2802Assert.Equal(0, structDecl.ConstraintClauses.Count); 2806Assert.Equal(1, structDecl.Members.Count); 2810Assert.Equal(0, ms.AttributeLists.Count); 2822Assert.Equal(0, ms.ConstraintClauses.Count); 2836Assert.Equal(1, file.Members.Count); 2842Assert.Equal(0, structDecl.AttributeLists.Count); 2849Assert.Equal(0, structDecl.ConstraintClauses.Count); 2853Assert.Equal(1, structDecl.Members.Count); 2857Assert.Equal(0, ms.AttributeLists.Count); 2872Assert.Equal(0, ms.ConstraintClauses.Count); 2886Assert.Equal(1, file.Members.Count); 2892Assert.Equal(0, structDecl.AttributeLists.Count); 2899Assert.Equal(0, structDecl.ConstraintClauses.Count); 2903Assert.Equal(1, structDecl.Members.Count); 2907Assert.Equal(0, propertySyntax.AttributeLists.Count); 2927Assert.Equal(1, file.Members.Count); 2933Assert.Equal(0, structDecl.AttributeLists.Count); 2940Assert.Equal(0, structDecl.ConstraintClauses.Count); 2944Assert.Equal(1, structDecl.Members.Count); 2948Assert.Equal(0, propertySyntax.AttributeLists.Count); 2955Assert.Equal(1, accessors.Count); 2972Assert.Equal(1, file.Members.Count); 2988Assert.Equal(1, file.Members.Count); 2994Assert.Equal(0, cs.AttributeLists.Count); 3001Assert.Equal(0, cs.ConstraintClauses.Count); 3005Assert.Equal(1, cs.Members.Count); 3009Assert.Equal(0, ms.AttributeLists.Count); 3018Assert.Equal(0, ms.ParameterList.Parameters[0].AttributeLists.Count); 3026Assert.Equal(0, ms.ConstraintClauses.Count); 3040Assert.Equal(1, file.Members.Count); 3046Assert.Equal(0, cs.AttributeLists.Count); 3053Assert.Equal(0, cs.ConstraintClauses.Count); 3057Assert.Equal(1, cs.Members.Count); 3061Assert.Equal(0, ms.AttributeLists.Count); 3072Assert.Equal(0, ms.ParameterList.Parameters[0].AttributeLists.Count); 3079Assert.Equal(0, ms.ParameterList.Parameters[1].AttributeLists.Count); 3088Assert.Equal(0, ms.ConstraintClauses.Count); 3101Assert.Equal(1, file.Members.Count); 3107Assert.Equal(0, cs.AttributeLists.Count); 3114Assert.Equal(0, cs.ConstraintClauses.Count); 3118Assert.Equal(1, cs.Members.Count); 3122Assert.Equal(0, ms.AttributeLists.Count); 3133Assert.Equal(0, ms.ParameterList.Parameters[0].AttributeLists.Count); 3143Assert.Equal(0, ms.ConstraintClauses.Count); 3166Assert.Equal(1, file.Members.Count); 3172Assert.Equal(0, cs.AttributeLists.Count); 3179Assert.Equal(0, cs.ConstraintClauses.Count); 3183Assert.Equal(1, cs.Members.Count); 3187Assert.Equal(0, ms.AttributeLists.Count); 3198Assert.Equal(0, ms.ParameterList.Parameters[0].AttributeLists.Count); 3206Assert.Equal(0, ms.ConstraintClauses.Count); 3240Assert.Equal(1, file.Members.Count); 3246Assert.Equal(0, cs.AttributeLists.Count); 3253Assert.Equal(0, cs.ConstraintClauses.Count); 3257Assert.Equal(1, cs.Members.Count); 3261Assert.Equal(0, ms.AttributeLists.Count); 3272Assert.Equal(0, ms.ConstraintClauses.Count); 3305Assert.Equal(1, file.Members.Count); 3311Assert.Equal(0, cs.AttributeLists.Count); 3318Assert.Equal(0, cs.ConstraintClauses.Count); 3322Assert.Equal(1, cs.Members.Count); 3326Assert.Equal(0, ms.AttributeLists.Count); 3335Assert.Equal(0, ms.ParameterList.Parameters[0].AttributeLists.Count); 3343Assert.Equal(0, ms.ConstraintClauses.Count); 3357Assert.Equal(1, file.Members.Count); 3363Assert.Equal(0, cs.AttributeLists.Count); 3370Assert.Equal(0, cs.ConstraintClauses.Count); 3374Assert.Equal(1, cs.Members.Count); 3378Assert.Equal(0, ms.AttributeLists.Count); 3389Assert.Equal(0, ms.ConstraintClauses.Count); 3403Assert.Equal(1, file.Members.Count); 3409Assert.Equal(0, cs.AttributeLists.Count); 3416Assert.Equal(0, cs.ConstraintClauses.Count); 3420Assert.Equal(1, cs.Members.Count); 3424Assert.Equal(0, ms.AttributeLists.Count); 3438Assert.Equal(1, ms.ConstraintClauses.Count); 3468Assert.Equal(1, file.Members.Count); 3484Assert.Equal(1, file.Members.Count); 3490Assert.Equal(0, cs.AttributeLists.Count); 3497Assert.Equal(0, cs.ConstraintClauses.Count); 3502Assert.Equal(1, cs.Members.Count); 3506Assert.Equal(0, cn.AttributeLists.Count); 3519Assert.Equal(1, file.Members.Count); 3525Assert.Equal(0, cs.AttributeLists.Count); 3532Assert.Equal(0, cs.ConstraintClauses.Count); 3537Assert.Equal(1, cs.Members.Count); 3541Assert.Equal(0, cn.AttributeLists.Count); 3566Assert.Equal(1, file.Members.Count); 3572Assert.Equal(0, cs.AttributeLists.Count); 3579Assert.Equal(0, cs.ConstraintClauses.Count); 3584Assert.Equal(1, cs.Members.Count); 3589Assert.Equal(0, cn.AttributeLists.Count); 3603Assert.Equal(1, file.Members.Count); 3609Assert.Equal(0, cs.AttributeLists.Count); 3616Assert.Equal(0, cs.ConstraintClauses.Count); 3620Assert.Equal(1, cs.Members.Count); 3624Assert.Equal(0, fs.AttributeLists.Count); 3663Assert.Equal(1, file.Members.Count); 3669Assert.Equal(0, cs.AttributeLists.Count); 3676Assert.Equal(0, cs.ConstraintClauses.Count); 3680Assert.Equal(1, cs.Members.Count); 3684Assert.Equal(0, fs.AttributeLists.Count); 3703Assert.Equal(1, file.Members.Count); 3709Assert.Equal(0, cs.AttributeLists.Count); 3716Assert.Equal(0, cs.ConstraintClauses.Count); 3720Assert.Equal(1, cs.Members.Count); 3724Assert.Equal(0, fs.AttributeLists.Count); 3757Assert.Equal(1, file.Members.Count); 3763Assert.Equal(0, cs.AttributeLists.Count); 3770Assert.Equal(0, cs.ConstraintClauses.Count); 3774Assert.Equal(1, cs.Members.Count); 3778Assert.Equal(0, fs.AttributeLists.Count); 3813Assert.Equal(1, file.Members.Count); 3819Assert.Equal(0, cs.AttributeLists.Count); 3826Assert.Equal(0, cs.ConstraintClauses.Count); 3830Assert.Equal(1, cs.Members.Count); 3834Assert.Equal(0, fs.AttributeLists.Count); 3858Assert.Equal(1, file.Members.Count); 3864Assert.Equal(0, cs.AttributeLists.Count); 3871Assert.Equal(0, cs.ConstraintClauses.Count); 3875Assert.Equal(1, cs.Members.Count); 3879Assert.Equal(0, fs.AttributeLists.Count); 3902Assert.Equal(1, file.Members.Count); 3908Assert.Equal(0, cs.AttributeLists.Count); 3915Assert.Equal(0, cs.ConstraintClauses.Count); 3919Assert.Equal(1, cs.Members.Count); 3923Assert.Equal(0, fs.AttributeLists.Count); 3947Assert.Equal(1, file.Members.Count); 3953Assert.Equal(0, cs.AttributeLists.Count); 3960Assert.Equal(0, cs.ConstraintClauses.Count); 3964Assert.Equal(1, cs.Members.Count); 3968Assert.Equal(0, fs.AttributeLists.Count); 4001Assert.Equal(1, file.Members.Count); 4007Assert.Equal(0, cs.AttributeLists.Count); 4014Assert.Equal(0, cs.ConstraintClauses.Count); 4018Assert.Equal(1, cs.Members.Count); 4022Assert.Equal(0, fs.AttributeLists.Count); 4064Assert.Equal(1, file.Members.Count); 4070Assert.Equal(0, cs.AttributeLists.Count); 4077Assert.Equal(0, cs.ConstraintClauses.Count); 4081Assert.Equal(1, cs.Members.Count); 4085Assert.Equal(0, fs.AttributeLists.Count); 4110Assert.Equal(1, file.Members.Count); 4116Assert.Equal(0, cs.AttributeLists.Count); 4123Assert.Equal(0, cs.ConstraintClauses.Count); 4127Assert.Equal(1, cs.Members.Count); 4131Assert.Equal(0, ps.AttributeLists.Count); 4140Assert.Equal(2, ps.AccessorList.Accessors.Count); 4142Assert.Equal(0, ps.AccessorList.Accessors[0].AttributeLists.Count); 4149Assert.Equal(0, ps.AccessorList.Accessors[1].AttributeLists.Count); 4164Assert.Equal(1, file.Members.Count); 4170Assert.Equal(0, cs.AttributeLists.Count); 4177Assert.Equal(0, cs.ConstraintClauses.Count); 4181Assert.Equal(1, cs.Members.Count); 4185Assert.Equal(0, ps.AttributeLists.Count); 4194Assert.Equal(2, ps.AccessorList.Accessors.Count); 4196Assert.Equal(0, ps.AccessorList.Accessors[0].AttributeLists.Count); 4203Assert.Equal(0, ps.AccessorList.Accessors[1].AttributeLists.Count); 4219Assert.Equal(1, file.Members.Count); 4225Assert.Equal(0, cs.AttributeLists.Count); 4232Assert.Equal(0, cs.ConstraintClauses.Count); 4236Assert.Equal(1, cs.Members.Count); 4240Assert.Equal(0, ps.AttributeLists.Count); 4249Assert.Equal(2, ps.AccessorList.Accessors.Count); 4251Assert.Equal(0, ps.AccessorList.Accessors[0].AttributeLists.Count); 4258Assert.Equal(0, ps.AccessorList.Accessors[1].AttributeLists.Count); 4292Assert.Equal(1, file.Members.Count); 4298Assert.Equal(0, cs.AttributeLists.Count); 4305Assert.Equal(0, cs.ConstraintClauses.Count); 4309Assert.Equal(1, cs.Members.Count); 4313Assert.Equal(0, ps.AttributeLists.Count); 4322Assert.Equal(2, ps.AccessorList.Accessors.Count); 4324Assert.Equal(0, ps.AccessorList.Accessors[0].AttributeLists.Count); 4331Assert.Equal(0, ps.AccessorList.Accessors[1].AttributeLists.Count); 4346Assert.Equal(1, file.Members.Count); 4352Assert.Equal(0, cs.AttributeLists.Count); 4359Assert.Equal(0, cs.ConstraintClauses.Count); 4363Assert.Equal(1, cs.Members.Count); 4367Assert.Equal(0, ps.AttributeLists.Count); 4376Assert.Equal(2, ps.AccessorList.Accessors.Count); 4378Assert.Equal(0, ps.AccessorList.Accessors[0].AttributeLists.Count); 4385Assert.Equal(0, ps.AccessorList.Accessors[1].AttributeLists.Count); 4400Assert.Equal(1, file.Members.Count); 4406Assert.Equal(0, cs.AttributeLists.Count); 4413Assert.Equal(0, cs.ConstraintClauses.Count); 4417Assert.Equal(1, cs.Members.Count); 4421Assert.Equal(0, ps.AttributeLists.Count); 4430Assert.Equal(2, ps.AccessorList.Accessors.Count); 4432Assert.Equal(0, ps.AccessorList.Accessors[0].AttributeLists.Count); 4438Assert.Equal(0, ps.AccessorList.Accessors[1].AttributeLists.Count); 4458Assert.Equal(1, file.Members.Count); 4462Assert.Equal(1, cs.Members.Count); 4484Assert.Equal(1, file.Members.Count); 4490Assert.Equal(0, cs.AttributeLists.Count); 4497Assert.Equal(0, cs.ConstraintClauses.Count); 4501Assert.Equal(1, cs.Members.Count); 4505Assert.Equal(0, ps.AttributeLists.Count); 4514Assert.Equal(1, ps.AccessorList.Accessors.Count); 4516Assert.Equal(0, ps.AccessorList.Accessors[0].AttributeLists.Count); 4524Assert.Equal(1, body.Statements.Count); 4540Assert.Equal(1, file.Members.Count); 4546Assert.Equal(0, cs.AttributeLists.Count); 4553Assert.Equal(0, cs.ConstraintClauses.Count); 4557Assert.Equal(1, cs.Members.Count); 4561Assert.Equal(0, es.AttributeLists.Count); 4570Assert.Equal(1, es.AccessorList.Accessors.Count); 4572Assert.Equal(0, es.AccessorList.Accessors[0].AttributeLists.Count); 4580Assert.Equal(1, body.Statements.Count); 4596Assert.Equal(1, file.Members.Count); 4602Assert.Equal(0, cs.AttributeLists.Count); 4609Assert.Equal(0, cs.ConstraintClauses.Count); 4613Assert.Equal(1, cs.Members.Count); 4617Assert.Equal(0, ps.AttributeLists.Count); 4627Assert.Equal(2, ps.AccessorList.Accessors.Count); 4629Assert.Equal(0, ps.AccessorList.Accessors[0].AttributeLists.Count); 4636Assert.Equal(0, ps.AccessorList.Accessors[1].AttributeLists.Count); 4680Assert.Equal(1, file.Members.Count); 4686Assert.Equal(0, cs.AttributeLists.Count); 4693Assert.Equal(0, cs.ConstraintClauses.Count); 4697Assert.Equal(1, cs.Members.Count); 4701Assert.Equal(0, ps.AttributeLists.Count); 4712Assert.Equal(2, ps.AccessorList.Accessors.Count); 4714Assert.Equal(0, ps.AccessorList.Accessors[0].AttributeLists.Count); 4721Assert.Equal(0, ps.AccessorList.Accessors[1].AttributeLists.Count); 4736Assert.Equal(1, file.Members.Count); 4742Assert.Equal(0, cs.AttributeLists.Count); 4749Assert.Equal(0, cs.ConstraintClauses.Count); 4753Assert.Equal(1, cs.Members.Count); 4757Assert.Equal(0, es.AttributeLists.Count); 4767Assert.Equal(2, es.AccessorList.Accessors.Count); 4769Assert.Equal(0, es.AccessorList.Accessors[0].AttributeLists.Count); 4776Assert.Equal(0, es.AccessorList.Accessors[1].AttributeLists.Count); 4790Assert.Equal(1, file.Members.Count); 4796Assert.Equal(0, cs.AttributeLists.Count); 4803Assert.Equal(0, cs.ConstraintClauses.Count); 4807Assert.Equal(1, cs.Members.Count); 4811Assert.Equal(0, es.AttributeLists.Count); 4822Assert.Equal(2, es.AccessorList.Accessors.Count); 4824Assert.Equal(0, es.AccessorList.Accessors[0].AttributeLists.Count); 4831Assert.Equal(0, es.AccessorList.Accessors[1].AttributeLists.Count); 4873Assert.Equal(1, file.Members.Count); 4879Assert.Equal(0, cs.AttributeLists.Count); 4886Assert.Equal(0, cs.ConstraintClauses.Count); 4890Assert.Equal(1, cs.Members.Count); 4894Assert.Equal(0, es.AttributeLists.Count); 4906Assert.Equal(2, es.AccessorList.Accessors.Count); 4908Assert.Equal(0, es.AccessorList.Accessors[0].AttributeLists.Count); 4915Assert.Equal(0, es.AccessorList.Accessors[1].AttributeLists.Count); 4930Assert.Equal(1, file.Members.Count); 4936Assert.Equal(0, cs.AttributeLists.Count); 4943Assert.Equal(0, cs.ConstraintClauses.Count); 4947Assert.Equal(1, cs.Members.Count); 4951Assert.Equal(0, ps.AttributeLists.Count); 4964Assert.Equal(0, ps.ParameterList.Parameters[0].AttributeLists.Count); 4973Assert.Equal(2, ps.AccessorList.Accessors.Count); 4975Assert.Equal(0, ps.AccessorList.Accessors[0].AttributeLists.Count); 4982Assert.Equal(0, ps.AccessorList.Accessors[1].AttributeLists.Count); 4997Assert.Equal(1, file.Members.Count); 5003Assert.Equal(0, cs.AttributeLists.Count); 5010Assert.Equal(0, cs.ConstraintClauses.Count); 5014Assert.Equal(1, cs.Members.Count); 5018Assert.Equal(0, ps.AttributeLists.Count); 5031Assert.Equal(0, ps.ParameterList.Parameters[0].AttributeLists.Count); 5040Assert.Equal(2, ps.AccessorList.Accessors.Count); 5042Assert.Equal(0, ps.AccessorList.Accessors[0].AttributeLists.Count); 5049Assert.Equal(0, ps.AccessorList.Accessors[1].AttributeLists.Count); 5065Assert.Equal(1, file.Members.Count); 5071Assert.Equal(0, cs.AttributeLists.Count); 5078Assert.Equal(0, cs.ConstraintClauses.Count); 5082Assert.Equal(1, cs.Members.Count); 5086Assert.Equal(0, ps.AttributeLists.Count); 5099Assert.Equal(0, ps.ParameterList.Parameters[0].AttributeLists.Count); 5108Assert.Equal(2, ps.AccessorList.Accessors.Count); 5110Assert.Equal(0, ps.AccessorList.Accessors[0].AttributeLists.Count); 5117Assert.Equal(0, ps.AccessorList.Accessors[1].AttributeLists.Count); 5132Assert.Equal(1, file.Members.Count); 5138Assert.Equal(0, cs.AttributeLists.Count); 5145Assert.Equal(0, cs.ConstraintClauses.Count); 5149Assert.Equal(1, cs.Members.Count); 5153Assert.Equal(0, ps.AttributeLists.Count); 5168Assert.Equal(0, ps.ParameterList.Parameters[0].AttributeLists.Count); 5175Assert.Equal(0, ps.ParameterList.Parameters[1].AttributeLists.Count); 5184Assert.Equal(2, ps.AccessorList.Accessors.Count); 5186Assert.Equal(0, ps.AccessorList.Accessors[0].AttributeLists.Count); 5193Assert.Equal(0, ps.AccessorList.Accessors[1].AttributeLists.Count); 5208Assert.Equal(1, file.Members.Count); 5214Assert.Equal(0, cs.AttributeLists.Count); 5221Assert.Equal(0, cs.ConstraintClauses.Count); 5225Assert.Equal(1, cs.Members.Count); 5229Assert.Equal(0, ps.AttributeLists.Count); 5244Assert.Equal(0, ps.ParameterList.Parameters[0].AttributeLists.Count); 5253Assert.Equal(2, ps.AccessorList.Accessors.Count); 5255Assert.Equal(0, ps.AccessorList.Accessors[0].AttributeLists.Count); 5262Assert.Equal(0, ps.AccessorList.Accessors[1].AttributeLists.Count); 5276Assert.Equal(1, file.Members.Count); 5282Assert.Equal(0, cs.AttributeLists.Count); 5289Assert.Equal(0, cs.ConstraintClauses.Count); 5293Assert.Equal(1, cs.Members.Count); 5297Assert.Equal(0, ps.AttributeLists.Count); 5311Assert.Equal(0, ps.ParameterList.Parameters[0].AttributeLists.Count); 5318Assert.Equal(0, ps.ParameterList.Parameters[1].AttributeLists.Count); 5356Assert.Equal(1, file.Members.Count); 5362Assert.Equal(0, cs.AttributeLists.Count); 5369Assert.Equal(0, cs.ConstraintClauses.Count); 5373Assert.Equal(1, cs.Members.Count); 5377Assert.Equal(0, ps.AttributeLists.Count); 5391Assert.Equal(0, ps.ParameterList.Parameters[0].AttributeLists.Count); 5398Assert.Equal(0, ps.ParameterList.Parameters[1].AttributeLists.Count); 5470Assert.Equal(1, file.Members.Count); 5476Assert.Equal(0, cs.AttributeLists.Count); 5483Assert.Equal(0, cs.ConstraintClauses.Count); 5487Assert.Equal(1, cs.Members.Count); 5491Assert.Equal(0, ps.AttributeLists.Count); 5505Assert.Equal(0, ps.ParameterList.Parameters[0].AttributeLists.Count); 5533Assert.Equal(1, file.Members.Count); 5539Assert.Equal(0, cs.AttributeLists.Count); 5546Assert.Equal(0, cs.ConstraintClauses.Count); 5550Assert.Equal(1, cs.Members.Count); 5554Assert.Equal(0, ms.AttributeLists.Count); 5566Assert.Equal(0, ms.ParameterList.Parameters[0].AttributeLists.Count); 5581Assert.Equal(1, file.Members.Count); 5587Assert.Equal(0, cs.AttributeLists.Count); 5594Assert.Equal(0, cs.ConstraintClauses.Count); 5598Assert.Equal(1, cs.Members.Count); 5602Assert.Equal(0, ms.AttributeLists.Count); 5614Assert.Equal(0, ms.ParameterList.Parameters[0].AttributeLists.Count); 5629Assert.Equal(1, file.Members.Count); 5641Assert.Equal(1, file.Members.Count); 5653Assert.Equal(1, file.Members.Count); 5880Assert.Equal(1, file.Members.Count); 5888Assert.Equal(1, mainMethod.Body.Statements.Count);

1969Assert.Equal(0, am.Block.Statements.Count); 1999Assert.Equal(0, am.Block.Statements.Count); 2024Assert.Equal(0, am.Block.Statements.Count); 2301Assert.Equal(0, qs.Body.Clauses.Count); 2334Assert.Equal(0, qs.Body.Clauses.Count); 2367Assert.Equal(0, qs.Body.Clauses.Count); 2394Assert.Equal(0, qs.Body.Continuation.Body.Clauses.Count); 2418Assert.Equal(1, qs.Body.Clauses.Count); 2458Assert.Equal(1, qs.Body.Clauses.Count); 2501Assert.Equal(1, qs.Body.Clauses.Count); 2546Assert.Equal(1, qs.Body.Clauses.Count); 2591Assert.Equal(1, qs.Body.Clauses.Count); 2640Assert.Equal(1, qs.Body.Clauses.Count); 2688Assert.Equal(1, qs.Body.Clauses.Count); 2736Assert.Equal(0, qs.Body.Clauses.Count); 2775Assert.Equal(0, qs.Body.Clauses.Count); 2804Assert.Equal(0, qs.Body.Continuation.Body.Clauses.Count); 2828Assert.Equal(1, qs.Body.Clauses.Count); 2884Assert.Equal(1, qs.Body.Clauses.Count); 2939Assert.Equal(1, qs.Body.Clauses.Count);

1295Assert.Equal(2, c.Members.Count); 1347Assert.Equal(2, c.Members.Count);

552Assert.Equal(1, array.RankSpecifiers.Count); 574Assert.Equal(1, array.RankSpecifiers.Count); 596Assert.Equal(3, array.RankSpecifiers.Count);

80Assert.Equal(1, file.AttributeLists.Count); 95Assert.Equal(1, file.AttributeLists.Count); 96Assert.Equal(0, file.Members.Count); 111Assert.Equal(1, file.AttributeLists.Count); 112Assert.Equal(0, file.Members.Count); 127Assert.Equal(1, file.AttributeLists.Count); 128Assert.Equal(1, file.Members.Count); 143Assert.Equal(1, file.AttributeLists.Count); 144Assert.Equal(1, file.Members.Count); 159Assert.Equal(2, file.AttributeLists.Count); 160Assert.Equal(0, file.Members.Count); 174Assert.Equal(1, file.AttributeLists.Count); 175Assert.Equal(0, file.Members.Count); 189Assert.Equal(1, file.AttributeLists.Count); 190Assert.Equal(0, file.Members.Count); 204Assert.Equal(1, file.AttributeLists.Count); 205Assert.Equal(0, file.Members.Count); 220Assert.Equal(1, file.AttributeLists.Count); 221Assert.Equal(0, file.Members.Count); 236Assert.Equal(1, file.AttributeLists.Count); 237Assert.Equal(0, file.Members.Count); 251Assert.Equal(1, file.AttributeLists.Count); 252Assert.Equal(0, file.Members.Count); 267Assert.Equal(1, file.AttributeLists.Count); 268Assert.Equal(0, file.Members.Count); 288Assert.Equal(1, file.AttributeLists.Count); 289Assert.Equal(0, file.Members.Count); 304Assert.Equal(1, file.AttributeLists.Count); 305Assert.Equal(0, file.Members.Count); 320Assert.Equal(1, file.AttributeLists.Count); 321Assert.Equal(1, file.Members.Count); 336Assert.Equal(1, file.AttributeLists.Count); 337Assert.Equal(1, file.Members.Count); 352Assert.Equal(1, file.Members.Count); 366Assert.Equal(1, file.Members.Count); 380Assert.Equal(1, file.Members.Count); 394Assert.Equal(1, file.Members.Count); 409Assert.Equal(1, file.Members.Count); 447Assert.Equal(1, file.Members.Count); 463Assert.Equal(1, file.Members.Count); 478Assert.Equal(1, file.Members.Count); 493Assert.Equal(1, file.Members.Count); 507Assert.Equal(1, file.Members.Count); 522Assert.Equal(1, file.Members.Count); 537Assert.Equal(1, file.Members.Count); 553Assert.Equal(1, file.Members.Count); 570Assert.Equal(1, file.Members.Count); 588Assert.Equal(1, file.Members.Count); 604Assert.Equal(1, file.Members.Count); 618Assert.Equal(1, file.Members.Count); 632Assert.Equal(1, file.Members.Count); 646Assert.Equal(1, file.Members.Count); 660Assert.Equal(1, file.Members.Count); 684Assert.Equal(1, file.Members.Count); 697Assert.Equal(2, file.Members.Count); 714Assert.Equal(2, file.Members.Count); 730Assert.Equal(2, file.Members.Count); 747Assert.Equal(2, file.Members.Count); 764Assert.Equal(1, file.Members.Count); 779Assert.Equal(1, file.Members.Count); 793Assert.Equal(1, file.Members.Count); 808Assert.Equal(1, file.Members.Count); 823Assert.Equal(1, file.Members.Count); 837Assert.Equal(1, file.Members.Count); 850Assert.Equal(1, file.Members.Count); 864Assert.Equal(1, file.Members.Count); 877Assert.Equal(1, file.Members.Count); 891Assert.Equal(1, file.Members.Count); 905Assert.Equal(1, file.Members.Count); 918Assert.Equal(1, file.Members.Count); 932Assert.Equal(1, file.Members.Count); 945Assert.Equal(1, file.Members.Count); 959Assert.Equal(1, file.Members.Count); 975Assert.Equal(1, file.Members.Count); 990Assert.Equal(1, file.Members.Count); 1004Assert.Equal(1, file.Members.Count); 1018Assert.Equal(1, file.Members.Count); 1034Assert.Equal(1, file.Members.Count); 1049Assert.Equal(1, file.Members.Count); 1063Assert.Equal(1, file.Members.Count); 1077Assert.Equal(1, file.Members.Count); 1094Assert.Equal(1, file.Members.Count); 1110Assert.Equal(1, file.Members.Count); 1125Assert.Equal(1, file.Members.Count); 1139Assert.Equal(1, file.Members.Count); 1154Assert.Equal(1, file.Members.Count); 1169Assert.Equal(1, file.Members.Count); 1183Assert.Equal(1, file.Members.Count); 1198Assert.Equal(1, file.Members.Count); 1213Assert.Equal(1, file.Members.Count); 1227Assert.Equal(2, file.Members.Count); 1245Assert.Equal(2, file.Members.Count); 1262Assert.Equal(2, file.Members.Count); 1280Assert.Equal(1, file.Members.Count); 1295Assert.Equal(1, file.Members.Count); 1309Assert.Equal(1, file.Members.Count); 1324Assert.Equal(1, file.Members.Count); 1339Assert.Equal(1, file.Members.Count); 1353Assert.Equal(1, file.Members.Count); 1368Assert.Equal(1, file.Members.Count); 1371Assert.Equal(2, agg.Members.Count); 1386Assert.Equal(1, file.Members.Count); 1389Assert.Equal(2, agg.Members.Count); 1404Assert.Equal(1, file.Members.Count); 1407Assert.Equal(2, agg.Members.Count); 1423Assert.Equal(1, file.Members.Count); 1426Assert.Equal(2, agg.Members.Count); 1443Assert.Equal(1, file.Members.Count); 1446Assert.Equal(2, agg.Members.Count); 1462Assert.Equal(1, file.Members.Count); 1465Assert.Equal(2, agg.Members.Count); 1482Assert.Equal(1, file.Members.Count); 1485Assert.Equal(1, agg.Members.Count); 1499Assert.Equal(1, file.Members.Count); 1502Assert.Equal(1, agg.Members.Count); 1516Assert.Equal(1, file.Members.Count); 1519Assert.Equal(1, agg.Members.Count); 1534Assert.Equal(1, file.Members.Count); 1537Assert.Equal(1, agg.Members.Count); 1552Assert.Equal(1, file.Members.Count); 1555Assert.Equal(1, agg.Members.Count); 1571Assert.Equal(1, file.Members.Count); 1574Assert.Equal(1, agg.Members.Count); 1589Assert.Equal(1, file.Members.Count); 1592Assert.Equal(1, agg.Members.Count); 1609Assert.Equal(1, file.Members.Count); 1612Assert.Equal(1, agg.Members.Count); 1626Assert.Equal(1, file.Members.Count); 1629Assert.Equal(1, agg.Members.Count); 1643Assert.Equal(1, file.Members.Count); 1646Assert.Equal(1, agg.Members.Count); 1661Assert.Equal(1, file.Members.Count); 1664Assert.Equal(1, agg.Members.Count); 1678Assert.Equal(1, file.Members.Count); 1681Assert.Equal(1, agg.Members.Count); 1697Assert.Equal(1, file.Members.Count); 1700Assert.Equal(2, agg.Members.Count); 1716Assert.Equal(1, file.Members.Count); 1719Assert.Equal(2, agg.Members.Count); 1736Assert.Equal(1, file.Members.Count); 1739Assert.Equal(2, agg.Members.Count); 1755Assert.Equal(1, file.Members.Count); 1758Assert.Equal(2, agg.Members.Count); 1776Assert.Equal(1, file.Members.Count); 1779Assert.Equal(2, agg.Members.Count); 1794Assert.Equal(1, file.Members.Count); 1797Assert.Equal(1, agg.Members.Count); 1811Assert.Equal(1, file.Members.Count); 1814Assert.Equal(1, agg.Members.Count); 1828Assert.Equal(1, file.Members.Count); 1831Assert.Equal(1, agg.Members.Count); 1845Assert.Equal(1, file.Members.Count); 1860Assert.Equal(1, file.Members.Count); 1863Assert.Equal(1, agg.Members.Count); 1899Assert.Equal(1, file.Members.Count); 1902Assert.Equal(1, agg.Members.Count); 1919Assert.Equal(1, file.Members.Count); 1922Assert.Equal(1, agg.Members.Count); 1938Assert.Equal(1, file.Members.Count); 1941Assert.Equal(1, agg.Members.Count); 1959Assert.Equal(1, file.Members.Count); 1962Assert.Equal(1, agg.Members.Count); 1977Assert.Equal(1, file.Members.Count); 1980Assert.Equal(1, agg.Members.Count); 2008Assert.Equal(1, file.Members.Count); 2011Assert.Equal(1, agg.Members.Count); 2026Assert.Equal(1, file.Members.Count); 2029Assert.Equal(1, agg.Members.Count); 2043Assert.Equal(1, file.Members.Count); 2046Assert.Equal(1, agg.Members.Count); 2062Assert.Equal(1, file.Members.Count); 2065Assert.Equal(2, agg.Members.Count); 2102Assert.Equal(1, file.Members.Count); 2105Assert.Equal(2, agg.Members.Count); 2123Assert.Equal(1, file.Members.Count); 2126Assert.Equal(2, agg.Members.Count); 2143Assert.Equal(1, file.Members.Count); 2146Assert.Equal(2, agg.Members.Count); 2165Assert.Equal(1, file.Members.Count); 2168Assert.Equal(2, agg.Members.Count); 2184Assert.Equal(1, file.Members.Count); 2202Assert.Equal(1, file.Members.Count); 2219Assert.Equal(1, file.Members.Count); 2235Assert.Equal(1, file.Members.Count); 2250Assert.Equal(1, file.Members.Count); 2266Assert.Equal(1, file.Members.Count); 2281Assert.Equal(1, file.Members.Count); 2295Assert.Equal(1, file.Members.Count); 2312Assert.Equal(2, file.Members.Count); 2331Assert.Equal(2, file.Members.Count); 2349Assert.Equal(2, file.Members.Count); 2366Assert.Equal(2, file.Members.Count); 2382Assert.Equal(2, file.Members.Count); 2399Assert.Equal(2, file.Members.Count); 2415Assert.Equal(2, file.Members.Count); 2430Assert.Equal(2, file.Members.Count); 2448Assert.Equal(1, file.Members.Count); 2462Assert.Equal(1, file.Members.Count); 2477Assert.Equal(1, file.Members.Count); 2491Assert.Equal(1, file.Members.Count); 2507Assert.Equal(1, file.Members.Count); 2521Assert.Equal(1, file.Members.Count); 2535Assert.Equal(1, file.Members.Count); 2549Assert.Equal(1, file.Members.Count); 2563Assert.Equal(1, file.Members.Count); 2577Assert.Equal(1, file.Members.Count); 2591Assert.Equal(1, file.Members.Count); 2606Assert.Equal(1, file.Members.Count); 2621Assert.Equal(1, file.Members.Count); 2635Assert.Equal(1, file.Members.Count); 2649Assert.Equal(1, file.Members.Count); 2663Assert.Equal(2, file.Members.Count); 2678Assert.Equal(2, file.Members.Count); 2693Assert.Equal(2, file.Members.Count); 2708Assert.Equal(1, file.Members.Count); 2725Assert.Equal(1, file.Members.Count); 2741Assert.Equal(1, file.Members.Count); 2759Assert.Equal(1, file.Members.Count); 2775Assert.Equal(1, file.Members.Count); 2791Assert.Equal(1, file.Members.Count); 2807Assert.Equal(1, file.Members.Count); 2823Assert.Equal(1, file.Members.Count); 2839Assert.Equal(1, file.Members.Count); 2842Assert.Equal(2, agg.Members.Count); 2857Assert.Equal(1, file.Members.Count); 2860Assert.Equal(2, agg.Members.Count); 2875Assert.Equal(1, file.Members.Count); 2878Assert.Equal(1, agg.Members.Count); 2882Assert.Equal(2, ms.Body.Statements.Count); 2898Assert.Equal(1, file.Members.Count); 2901Assert.Equal(1, agg.Members.Count); 2905Assert.Equal(2, ms.Body.Statements.Count); 2922Assert.Equal(1, file.Members.Count); 2925Assert.Equal(1, agg.Members.Count); 2929Assert.Equal(2, ms.Body.Statements.Count); 2946Assert.Equal(1, file.Members.Count); 2949Assert.Equal(1, agg.Members.Count); 2953Assert.Equal(2, ms.Body.Statements.Count); 2968Assert.Equal(1, file.Members.Count); 2971Assert.Equal(1, agg.Members.Count); 2975Assert.Equal(2, ms.Body.Statements.Count); 2991Assert.Equal(1, file.Members.Count); 2994Assert.Equal(1, agg.Members.Count); 2998Assert.Equal(2, ms.Body.Statements.Count); 3014Assert.Equal(1, file.Members.Count); 3017Assert.Equal(1, agg.Members.Count); 3021Assert.Equal(2, ms.Body.Statements.Count); 3037Assert.Equal(1, file.Members.Count); 3040Assert.Equal(1, agg.Members.Count); 3044Assert.Equal(2, ms.Body.Statements.Count); 3060Assert.Equal(1, file.Members.Count); 3063Assert.Equal(1, agg.Members.Count); 3067Assert.Equal(2, ms.Body.Statements.Count); 3083Assert.Equal(1, file.Members.Count); 3086Assert.Equal(1, agg.Members.Count); 3090Assert.Equal(1, ms.Body.Statements.Count); 3104Assert.Equal(1, file.Members.Count); 3107Assert.Equal(1, agg.Members.Count); 3111Assert.Equal(1, ms.Body.Statements.Count); 3125Assert.Equal(1, file.Members.Count); 3128Assert.Equal(1, agg.Members.Count); 3132Assert.Equal(1, ms.Body.Statements.Count); 3146Assert.Equal(1, file.Members.Count); 3149Assert.Equal(1, agg.Members.Count); 3153Assert.Equal(1, ms.Body.Statements.Count); 3167Assert.Equal(1, file.Members.Count); 3170Assert.Equal(1, agg.Members.Count); 3174Assert.Equal(1, ms.Body.Statements.Count); 3188Assert.Equal(1, file.Members.Count); 3191Assert.Equal(1, agg.Members.Count); 3195Assert.Equal(1, ms.Body.Statements.Count); 3209Assert.Equal(1, file.Members.Count); 3212Assert.Equal(1, agg.Members.Count); 3216Assert.Equal(1, ms.Body.Statements.Count); 3231Assert.Equal(1, file.Members.Count); 3234Assert.Equal(1, agg.Members.Count); 3238Assert.Equal(1, ms.Body.Statements.Count); 3254Assert.Equal(1, file.Members.Count); 3257Assert.Equal(1, agg.Members.Count); 3261Assert.Equal(1, ms.Body.Statements.Count); 3277Assert.Equal(1, file.Members.Count); 3280Assert.Equal(1, agg.Members.Count); 3284Assert.Equal(1, ms.Body.Statements.Count); 3300Assert.Equal(1, file.Members.Count); 3303Assert.Equal(1, agg.Members.Count); 3307Assert.Equal(1, ms.Body.Statements.Count); 3324Assert.Equal(1, file.Members.Count); 3327Assert.Equal(1, agg.Members.Count); 3331Assert.Equal(1, ms.Body.Statements.Count); 3347Assert.Equal(1, file.Members.Count); 3350Assert.Equal(1, agg.Members.Count); 3354Assert.Equal(1, ms.Body.Statements.Count); 3370Assert.Equal(1, file.Members.Count); 3373Assert.Equal(1, agg.Members.Count); 3377Assert.Equal(1, ms.Body.Statements.Count); 3413Assert.Equal(1, file.Members.Count); 3416Assert.Equal(1, agg.Members.Count); 3420Assert.Equal(2, ms.Body.Statements.Count); 3438Assert.Equal(1, file.Members.Count); 3441Assert.Equal(1, agg.Members.Count); 3445Assert.Equal(2, ms.Body.Statements.Count); 3463Assert.Equal(1, file.Members.Count); 3466Assert.Equal(1, agg.Members.Count); 3470Assert.Equal(2, ms.Body.Statements.Count); 3489Assert.Equal(1, file.Members.Count); 3492Assert.Equal(1, agg.Members.Count); 3496Assert.Equal(1, ms.Body.Statements.Count); 3513Assert.Equal(1, file.Members.Count); 3516Assert.Equal(1, agg.Members.Count); 3520Assert.Equal(1, ms.Body.Statements.Count); 3537Assert.Equal(1, file.Members.Count); 3540Assert.Equal(1, agg.Members.Count); 3544Assert.Equal(1, ms.Body.Statements.Count); 3562Assert.Equal(1, file.Members.Count); 3565Assert.Equal(1, agg.Members.Count); 3569Assert.Equal(1, ms.Body.Statements.Count); 3586Assert.Equal(1, file.Members.Count); 3589Assert.Equal(1, agg.Members.Count); 3593Assert.Equal(1, ms.Body.Statements.Count); 3610Assert.Equal(1, file.Members.Count); 3613Assert.Equal(1, agg.Members.Count); 3617Assert.Equal(1, ms.Body.Statements.Count); 3634Assert.Equal(1, file.Members.Count); 3637Assert.Equal(1, agg.Members.Count); 3641Assert.Equal(1, ms.Body.Statements.Count); 3659Assert.Equal(1, file.Members.Count); 3662Assert.Equal(1, agg.Members.Count); 3666Assert.Equal(1, ms.Body.Statements.Count); 3683Assert.Equal(1, file.Members.Count); 3686Assert.Equal(1, agg.Members.Count); 3690Assert.Equal(1, ms.Body.Statements.Count); 3707Assert.Equal(1, file.Members.Count); 3710Assert.Equal(1, agg.Members.Count); 3714Assert.Equal(1, ms.Body.Statements.Count); 3732Assert.Equal(1, file.Members.Count); 3735Assert.Equal(1, agg.Members.Count); 3739Assert.Equal(2, ms.Body.Statements.Count); 3758Assert.Equal(1, file.Members.Count); 3761Assert.Equal(1, agg.Members.Count); 3765Assert.Equal(2, ms.Body.Statements.Count); 3784Assert.Equal(1, file.Members.Count); 3787Assert.Equal(1, agg.Members.Count); 3791Assert.Equal(2, ms.Body.Statements.Count); 3811Assert.Equal(1, file.Members.Count); 3814Assert.Equal(1, agg.Members.Count); 3818Assert.Equal(1, ms.Body.Statements.Count); 3836Assert.Equal(1, file.Members.Count); 3839Assert.Equal(1, agg.Members.Count); 3843Assert.Equal(1, ms.Body.Statements.Count); 3861Assert.Equal(1, file.Members.Count); 3864Assert.Equal(1, agg.Members.Count); 3868Assert.Equal(1, ms.Body.Statements.Count); 3887Assert.Equal(1, file.Members.Count); 3890Assert.Equal(1, agg.Members.Count); 3894Assert.Equal(1, ms.Body.Statements.Count); 3908Assert.Equal(1, file.Members.Count); 3911Assert.Equal(1, agg.Members.Count); 3915Assert.Equal(1, ms.Body.Statements.Count); 3953Assert.Equal(1, file.Members.Count); 3956Assert.Equal(1, agg.Members.Count); 3960Assert.Equal(1, ms.Body.Statements.Count); 3974Assert.Equal(1, file.Members.Count); 3977Assert.Equal(1, agg.Members.Count); 3981Assert.Equal(1, ms.Body.Statements.Count); 3995Assert.Equal(1, file.Members.Count); 3998Assert.Equal(1, agg.Members.Count); 4002Assert.Equal(1, ms.Body.Statements.Count); 4016Assert.Equal(1, file.Members.Count); 4019Assert.Equal(1, agg.Members.Count); 4023Assert.Equal(1, ms.Body.Statements.Count); 4038Assert.Equal(1, file.Members.Count); 4041Assert.Equal(1, agg.Members.Count); 4045Assert.Equal(1, ms.Body.Statements.Count); 4060Assert.Equal(1, file.Members.Count); 4063Assert.Equal(1, agg.Members.Count); 4067Assert.Equal(1, ms.Body.Statements.Count); 4083Assert.Equal(1, file.Members.Count); 4086Assert.Equal(1, agg.Members.Count); 4090Assert.Equal(1, ms.Body.Statements.Count); 4106Assert.Equal(1, file.Members.Count); 4109Assert.Equal(1, agg.Members.Count); 4113Assert.Equal(1, ms.Body.Statements.Count); 4127Assert.Equal(1, file.Members.Count); 4130Assert.Equal(1, agg.Members.Count); 4134Assert.Equal(1, ms.Body.Statements.Count); 4150Assert.Equal(1, file.Members.Count); 4153Assert.Equal(1, agg.Members.Count); 4157Assert.Equal(1, ms.Body.Statements.Count); 4173Assert.Equal(1, file.Members.Count); 4176Assert.Equal(1, agg.Members.Count); 4180Assert.Equal(1, ms.Body.Statements.Count); 4199Assert.Equal(1, file.Members.Count); 4202Assert.Equal(1, agg.Members.Count); 4206Assert.Equal(1, ms.Body.Statements.Count); 4221Assert.Equal(1, file.Members.Count); 4224Assert.Equal(1, agg.Members.Count); 4228Assert.Equal(1, ms.Body.Statements.Count); 4247Assert.Equal(1, file.Members.Count); 4250Assert.Equal(1, agg.Members.Count); 4254Assert.Equal(1, ms.Body.Statements.Count); 4274Assert.Equal(1, file.Members.Count); 4277Assert.Equal(1, agg.Members.Count); 4281Assert.Equal(1, ms.Body.Statements.Count); 4295Assert.Equal(1, file.Members.Count); 4298Assert.Equal(1, agg.Members.Count); 4302Assert.Equal(1, ms.Body.Statements.Count); 4318Assert.Equal(1, file.Members.Count); 4321Assert.Equal(1, agg.Members.Count); 4325Assert.Equal(1, ms.Body.Statements.Count); 4343Assert.Equal(1, file.Members.Count); 4346Assert.Equal(1, agg.Members.Count); 4350Assert.Equal(1, ms.Body.Statements.Count); 4368Assert.Equal(1, file.Members.Count); 4371Assert.Equal(1, agg.Members.Count); 4375Assert.Equal(1, ms.Body.Statements.Count); 4390Assert.Equal(1, file.Members.Count); 4393Assert.Equal(1, agg.Members.Count); 4397Assert.Equal(1, ms.Body.Statements.Count); 4415Assert.Equal(1, file.Members.Count); 4418Assert.Equal(1, agg.Members.Count); 4422Assert.Equal(1, ms.Body.Statements.Count); 4441Assert.Equal(1, file.Members.Count); 4444Assert.Equal(1, agg.Members.Count); 4448Assert.Equal(1, ms.Body.Statements.Count); 4468Assert.Equal(1, file.Members.Count); 4471Assert.Equal(1, agg.Members.Count); 4475Assert.Equal(1, ms.Body.Statements.Count); 4495Assert.Equal(1, file.Members.Count); 4498Assert.Equal(1, agg.Members.Count); 4502Assert.Equal(1, ms.Body.Statements.Count); 4523Assert.Equal(1, file.Members.Count); 4526Assert.Equal(1, agg.Members.Count); 4530Assert.Equal(1, ms.Body.Statements.Count); 4550Assert.Equal(1, file.Members.Count); 4553Assert.Equal(1, agg.Members.Count); 4557Assert.Equal(1, ms.Body.Statements.Count); 4577Assert.Equal(1, file.Members.Count); 4580Assert.Equal(1, agg.Members.Count); 4584Assert.Equal(2, ms.Body.Statements.Count); 4606Assert.Equal(1, file.Members.Count); 4609Assert.Equal(1, agg.Members.Count); 4613Assert.Equal(2, ms.Body.Statements.Count); 4635Assert.Equal(1, file.Members.Count); 4638Assert.Equal(1, agg.Members.Count); 4642Assert.Equal(2, ms.Body.Statements.Count); 4665Assert.Equal(1, file.Members.Count); 4668Assert.Equal(1, agg.Members.Count); 4672Assert.Equal(2, ms.Body.Statements.Count); 4694Assert.Equal(1, file.Members.Count); 4697Assert.Equal(1, agg.Members.Count); 4701Assert.Equal(2, ms.Body.Statements.Count); 4723Assert.Equal(1, file.Members.Count); 4726Assert.Equal(1, agg.Members.Count); 4730Assert.Equal(1, ms.Body.Statements.Count); 4750Assert.Equal(1, file.Members.Count); 4753Assert.Equal(1, agg.Members.Count); 4757Assert.Equal(1, ms.Body.Statements.Count); 4777Assert.Equal(1, file.Members.Count); 4780Assert.Equal(1, agg.Members.Count); 4784Assert.Equal(1, ms.Body.Statements.Count); 4804Assert.Equal(1, file.Members.Count); 4807Assert.Equal(1, agg.Members.Count); 4811Assert.Equal(1, ms.Body.Statements.Count); 4832Assert.Equal(1, file.Members.Count); 4835Assert.Equal(1, agg.Members.Count); 4839Assert.Equal(1, ms.Body.Statements.Count); 4859Assert.Equal(1, file.Members.Count); 4862Assert.Equal(1, agg.Members.Count); 4866Assert.Equal(1, ms.Body.Statements.Count); 4887Assert.Equal(1, file.Members.Count); 4890Assert.Equal(1, agg.Members.Count); 4894Assert.Equal(1, ms.Body.Statements.Count); 4913Assert.Equal(1, file.Members.Count); 4916Assert.Equal(1, agg.Members.Count); 4920Assert.Equal(1, ms.Body.Statements.Count); 4940Assert.Equal(1, file.Members.Count); 4943Assert.Equal(1, agg.Members.Count); 4947Assert.Equal(1, ms.Body.Statements.Count); 4967Assert.Equal(1, file.Members.Count); 4970Assert.Equal(1, agg.Members.Count); 4974Assert.Equal(1, ms.Body.Statements.Count); 4995Assert.Equal(1, file.Members.Count); 4998Assert.Equal(1, agg.Members.Count); 5002Assert.Equal(1, ms.Body.Statements.Count); 5022Assert.Equal(1, file.Members.Count); 5025Assert.Equal(1, agg.Members.Count); 5029Assert.Equal(1, ms.Body.Statements.Count); 5052Assert.Equal(1, file.Members.Count); 5055Assert.Equal(1, agg.Members.Count); 5059Assert.Equal(2, ms.Body.Statements.Count); 5081Assert.Equal(1, file.Members.Count); 5084Assert.Equal(1, agg.Members.Count); 5088Assert.Equal(2, ms.Body.Statements.Count); 5110Assert.Equal(1, file.Members.Count); 5113Assert.Equal(1, agg.Members.Count); 5117Assert.Equal(2, ms.Body.Statements.Count); 5140Assert.Equal(1, file.Members.Count); 5143Assert.Equal(1, agg.Members.Count); 5147Assert.Equal(2, ms.Body.Statements.Count); 5169Assert.Equal(1, file.Members.Count); 5172Assert.Equal(1, agg.Members.Count); 5176Assert.Equal(2, ms.Body.Statements.Count); 5203Assert.Equal(1, file.Members.Count); 5206Assert.Equal(1, agg.Members.Count); 5210Assert.Equal(1, ms.Body.Statements.Count); 5230Assert.Equal(1, file.Members.Count); 5233Assert.Equal(1, agg.Members.Count); 5237Assert.Equal(1, ms.Body.Statements.Count); 5257Assert.Equal(1, file.Members.Count); 5260Assert.Equal(1, agg.Members.Count); 5264Assert.Equal(1, ms.Body.Statements.Count); 5284Assert.Equal(1, file.Members.Count); 5287Assert.Equal(1, agg.Members.Count); 5291Assert.Equal(1, ms.Body.Statements.Count); 5312Assert.Equal(1, file.Members.Count); 5315Assert.Equal(1, agg.Members.Count); 5319Assert.Equal(1, ms.Body.Statements.Count); 5339Assert.Equal(1, file.Members.Count); 5342Assert.Equal(1, agg.Members.Count); 5346Assert.Equal(1, ms.Body.Statements.Count); 5369Assert.Equal(1, file.Members.Count); 5372Assert.Equal(1, agg.Members.Count); 5376Assert.Equal(1, ms.Body.Statements.Count); 5400Assert.Equal(1, file.Members.Count); 5403Assert.Equal(1, agg.Members.Count); 5407Assert.Equal(1, ms.Body.Statements.Count); 5428Assert.Equal(1, file.Members.Count); 5431Assert.Equal(1, agg.Members.Count); 5435Assert.Equal(1, ms.Body.Statements.Count); 5475Assert.Equal(1, file.Members.Count); 5478Assert.Equal(1, agg.Members.Count); 5482Assert.Equal(2, ms.Body.Statements.Count); 5509Assert.Equal(1, file.Members.Count); 5512Assert.Equal(1, agg.Members.Count); 5516Assert.Equal(2, ms.Body.Statements.Count); 5539Assert.Equal(1, file.Members.Count); 5542Assert.Equal(1, agg.Members.Count); 5546Assert.Equal(2, ms.Body.Statements.Count); 5597Assert.Equal(1, file.Members.Count); 5600Assert.Equal(1, agg.Members.Count); 5608Assert.Equal(0, pd.AccessorList.Accessors.Count); 5621Assert.Equal(1, file.Members.Count); 5624Assert.Equal(2, agg.Members.Count); 5633Assert.Equal(0, pd.AccessorList.Accessors.Count); 5646Assert.Equal(1, file.Members.Count); 5649Assert.Equal(2, agg.Members.Count); 5658Assert.Equal(1, pd.AccessorList.Accessors.Count); 5681Assert.Equal(1, file.Members.Count); 5684Assert.Equal(2, agg.Members.Count); 5693Assert.Equal(1, pd.AccessorList.Accessors.Count); 5702Assert.Equal(0, acc.Body.Statements.Count); 5720Assert.Equal(1, file.Members.Count); 5723Assert.Equal(2, agg.Members.Count); 5732Assert.Equal(1, pd.AccessorList.Accessors.Count); 5741Assert.Equal(0, acc.Body.Statements.Count); 5759Assert.Equal(1, file.Members.Count); 5765Assert.Equal(1, accessorDecls.Count); 5775Assert.Equal(1, getBodyStmts.Count); 5791Assert.Equal(1, file.Members.Count); 5797Assert.Equal(2, accessorDecls.Count); 5822Assert.Equal(1, file.Members.Count); 5825Assert.Equal(1, agg.Members.Count); 5834Assert.Equal(1, md.Body.Statements.Count); 5842Assert.Equal(1, qx.Body.Clauses.Count); 5867Assert.Equal(1, file.Members.Count); 5870Assert.Equal(1, agg.Members.Count); 5879Assert.Equal(1, md.Body.Statements.Count); 5887Assert.Equal(1, qx.Body.Clauses.Count); 5911Assert.Equal(1, file.Members.Count); 5914Assert.Equal(1, agg.Members.Count); 5923Assert.Equal(1, md.Body.Statements.Count); 5931Assert.Equal(1, qx.Body.Clauses.Count); 5960Assert.Equal(1, file.Members.Count); 5963Assert.Equal(2, agg.Members.Count); 5973Assert.Equal(1, md.Body.Statements.Count); 5981Assert.Equal(1, qx.Body.Clauses.Count); 6008Assert.Equal(1, file.Members.Count); 6011Assert.Equal(2, agg.Members.Count); 6021Assert.Equal(1, md.Body.Statements.Count); 6029Assert.Equal(1, qx.Body.Clauses.Count); 6055Assert.Equal(1, file.Members.Count); 6058Assert.Equal(2, agg.Members.Count); 6068Assert.Equal(1, md.Body.Statements.Count); 6076Assert.Equal(1, qx.Body.Clauses.Count); 6107Assert.Equal(1, file.Members.Count); 6113Assert.Equal(2, item1.Members.Count); 6121Assert.Equal(1, subitem1.Body.Statements.Count); 6269Assert.Equal(1, usings.Count); 6284Assert.Equal(1, usings.Count); 6301Assert.Equal(1, usings.Count); 6305Assert.Equal(1, members.Count); 6325Assert.Equal(1, usings.Count); 6329Assert.Equal(1, members.Count);

47Assert.Equal(memberCount, tree.GetCompilationUnitRoot().Members.Count);

1238Assert.Equal(1, ts.Catches.Count); 1268Assert.Equal(1, ts.Catches.Count); 1297Assert.Equal(1, ts.Catches.Count); 1321Assert.Equal(3, ts.Catches.Count); 1364Assert.Equal(0, ts.Catches.Count); 1387Assert.Equal(3, ts.Catches.Count); 2136Assert.Equal(0, ss.Sections.Count); 2160Assert.Equal(1, ss.Sections.Count); 2161Assert.Equal(1, ss.Sections[0].Labels.Count); 2169Assert.Equal(1, ss.Sections[0].Statements.Count); 2195Assert.Equal(2, ss.Sections.Count); 2197Assert.Equal(1, ss.Sections[0].Labels.Count); 2205Assert.Equal(1, ss.Sections[0].Statements.Count); 2208Assert.Equal(1, ss.Sections[1].Labels.Count); 2216Assert.Equal(1, ss.Sections[1].Statements.Count); 2242Assert.Equal(1, ss.Sections.Count); 2244Assert.Equal(1, ss.Sections[0].Labels.Count); 2249Assert.Equal(1, ss.Sections[0].Statements.Count); 2275Assert.Equal(1, ss.Sections.Count); 2277Assert.Equal(2, ss.Sections[0].Labels.Count); 2291Assert.Equal(1, ss.Sections[0].Statements.Count); 2317Assert.Equal(1, ss.Sections.Count); 2319Assert.Equal(1, ss.Sections[0].Labels.Count); 2326Assert.Equal(2, ss.Sections[0].Statements.Count);

52Assert.Equal(0, n.Externs.Count); 53Assert.Equal(0, n.Usings.Count); 59Assert.Equal(0, n.Members.Count); 71Assert.Equal(0, c.AttributeLists.Count); 75Assert.Equal(0, c.ConstraintClauses.Count); 79Assert.Equal(0, c.Members.Count);

52Assert.Equal(3, list.Count); 70Assert.Equal(4, newList.Count); 74Assert.Equal(5, newList.Count); 78Assert.Equal(4, newList.Count); 82Assert.Equal(4, newList.Count); 86Assert.Equal(4, newList.Count); 90Assert.Equal(4, newList.Count); 94Assert.Equal(5, newList.Count); 98Assert.Equal(5, newList.Count); 102Assert.Equal(5, newList.Count); 106Assert.Equal(5, newList.Count); 110Assert.Equal(2, newList.Count); 113newList = list.RemoveAt(list.Count - 1); 114Assert.Equal(2, newList.Count); 118Assert.Equal(2, newList.Count); 122Assert.Equal(2, newList.Count); 126Assert.Equal(2, newList.Count); 130Assert.Equal(3, newList.Count); 134Assert.Equal(3, newList.Count); 138Assert.Equal(3, newList.Count); 142Assert.Equal(4, newList.Count); 146Assert.Equal(4, newList.Count); 150Assert.Equal(4, newList.Count); 154Assert.Equal(2, newList.Count); 158Assert.Equal(2, newList.Count); 162Assert.Equal(2, newList.Count); 167Assert.Throws<ArgumentOutOfRangeException>(() => list.Insert(list.Count + 1, nodeD)); 169Assert.Throws<ArgumentOutOfRangeException>(() => list.InsertRange(list.Count + 1, new[] { nodeD })); 171Assert.Throws<ArgumentOutOfRangeException>(() => list.RemoveAt(list.Count)); 188Assert.Equal(0, list.Count); 194Assert.Equal(1, newList.Count); 198Assert.Equal(2, newList.Count); 202Assert.Equal(1, newList.Count); 206Assert.Equal(2, newList.Count); 210Assert.Equal(0, newList.Count); 239Assert.True(declaration.AttributeLists.Count == 0); 248Assert.True(declaration.AttributeLists.Count == 1); 253Assert.True(declaration.AttributeLists.Count == 1);

26block != null && block.Statements.Count == 1)

596if (method.ConstraintClauses.Count > 0) 1797if (method.ConstraintClauses.Count == 0)

28return members.Count == 1

177if (node is not SwitchSectionSyntax section || section.Statements.Count == 0)

412for (var i = clauses.Count - 1; i >= 0; i--)

113=> list.Count > 0 ? list[0].SpanStart : container.Span.End;

54for (var i = 0; i < usings.Count; i++) 70if (i < usings.Count - 1) 133Debug.Assert(oldUsings.Count == newUsings.Count); 136for (var i = 0; i < oldUsings.Count; i++) 168if (finalUsings.Count == 0 && 169resultCompilationUnit.Externs.Count == 0 && 170resultCompilationUnit.Members.Count >= 1) 207if (finalUsings.Count == 0 && 208resultNamespace.Externs.Count == 0 && 209resultNamespace.Members.Count >= 1)

856for (var i = 0; i < arrayType.RankSpecifiers.Count; i++)

74if (node is BlockSyntax { Statements: { Count: >= 1 } statements })

490if (attributes.Count == 0)

82if (section.Labels.Count == 0 && 83section.Statements.Count == 0) 112if (section.Statements.Count == 0)

453return contextNode.GetAncestorsOrThis<BaseNamespaceDeclarationSyntax>().FirstOrDefault(n => n.Usings.Count > 0); 466return containingNamespace.GetAncestors<BaseNamespaceDeclarationSyntax>().FirstOrDefault(n => n.Usings.Count > 0);

127if (root.Externs.Count == 0) 142var endOfList = root.Usings.Count - 1; 145for (var i = 0; i < root.Usings.Count; i++)

237if (compUnit.Usings.Count > 0 && compUnit.Usings.Last().GetLastToken(includeZeroWidth: true) == token) 242if (compUnit.Externs.Count > 0 && compUnit.Externs.Last().GetLastToken(includeZeroWidth: true) == token) 254if (compUnit.AttributeLists.Count > 0 && compUnit.AttributeLists.Last().GetLastToken(includeZeroWidth: true) == token)

431(compilationUnit.Externs.Count > 0 || compilationUnit.Usings.Count > 0)) 1979(compilationUnit.Externs.Count > 0 || compilationUnit.Usings.Count > 0))

80if (list.Count > 0)

159accessorList?.Accessors.Count == 1)

196if (compUnit.Usings.Count > 0 && compUnit.Usings.Last().SemicolonToken == token)

121if (node.Statements.Count != 1)

227root.Members.Count > 0 ? root.Members[0] : 228root.AttributeLists.Count > 0 ? root.AttributeLists[0] : (SyntaxNode)null;

161for (var i = 0; i < attributes.Count; ++i) 185if (switchSection.Labels.Count < 2) 193for (var i = 0; i < switchSection.Labels.Count - 1; ++i) 202if (switchSection.Labels[switchSection.Labels.Count - 1] != null) 204AddSuppressWrappingIfOnSingleLineOperation(list, switchSection.Labels[switchSection.Labels.Count - 1].GetFirstToken(includeZeroWidth: true), switchSection.GetLastToken(includeZeroWidth: true)); 223if (parameterNode.AttributeLists.Count != 0)

24if (members.Count == 0) 37for (var i = 0; i < members.Count - 1; i++) 149return (TypeDeclarationSyntax)EnsureHasBraces(typeDeclaration, typeDeclaration.Members.Count > 0);

31if (organizedExternAliasList.Count > 0 && organizedUsingList.Count > 0) 42for (var i = 1; i < organizedUsingList.Count; i++) 103if (externAliasList.Count > 0 || usingList.Count > 0)

985for (var i = 0; i < structuredContent.Count; i++)

53if (childNodes.Count <= 1) 65var itemsAfter = index < childNodes.Count - 1 ? childNodes.Skip(index + 1) : Enumerable.Empty<SyntaxNode>();

389if (bodyStatements.Count >= 1)

167var spanStart = imports.Count > 0 ? imports[0].SpanStart : 0;

126var tryStatement = declarationStatementIndex + 1 < surroundingStatements.Count 170.Concat(surroundingStatements.Skip(declarationStatementIndex + 1 + statementsToSurround.Count)))); 202if (finallyStatements.Count != 1)

138if (syntaxFacts.GetMembersOfCompilationUnit(container).Count > 1) 202Debug.Assert(compilationUnitMembers.Count == 1);

1098If functionBlock.Statements.Count > 1 Then

61If query.Clauses.Count < 1 Then

2051Dim boundStatements(stmtList.Count - 1) As BoundStatement 2756For i = 0 To node.ElseIfBlocks.Count - 1 4735Dim n As Integer = catchClauses.Count

333For i As Integer = arrayModifierSyntax.Count - 1 To 0 Step -1 387Debug.Assert(arrayModifierSyntax.Count > 0 OrElse 419Return identifierSyntax.ArrayBounds IsNot Nothing OrElse identifierSyntax.ArrayRankSpecifiers.Count > 0

201If content.Count > 0 Then

939If query.Clauses.Count = 1 AndAlso query.Clauses(0) Is node Then

1837If forBlock.Statements.Count = 0 Then

2686If unit.Members.Count > 0 Then

420If members.Count > 0 Then 455If members.Count > 0 Then 583If members.Count = 0 Then 710If (members.Count <> 0) Then

548If attributes.Count > 0 Then

124If aggregateClause.AdditionalQueryOperators.Count = 0 Then

35For i = 0 To importList.Count - 1

86If attributeLists.Count > 0 Then

363If (syntax.AttributeLists.Count <> 0 OrElse syntax.Default IsNot Nothing) Then

1871If bestPartialMethod.BlockSyntax IsNot Nothing AndAlso bestPartialMethod.BlockSyntax.Statements.Count > 0 Then

597If syntax.AttributeLists.Count = 0 Then

716If syntax.Members.Count = 0 Then 1060If baseDeclList.Count > 0 Then 1076If inheritsSyntax.Count = 0 Then Return Nothing 1155If baseSyntax.Count = 0 Then Return 1212If baseSyntax.Count = 0 Then Return 1704If DirectCast(syntaxNode, TypeBlockSyntax).Inherits.Count > 0 Then 1722If DirectCast(syntaxNode, TypeBlockSyntax).Implements.Count > 0 Then 1726If DirectCast(syntaxNode, TypeBlockSyntax).Inherits.Count > 0 Then

103If syntax.AttributeLists.Count = 0 Then

392If attributeBlockSyntaxList.Count > 0 Then

301If body.Count > 0 Then 302Dim lastStatement = body(body.Count - 1)

687Dim lastElementIndex = list.Count - 1 765If node.Members.Count > 0 Then 830Dim hasImplements As Boolean = node.Implements.Count > 0 831Dim hasInherits As Boolean = node.Inherits.Count > 0 834If Not hasInherits AndAlso Not hasImplements AndAlso node.Members.Count > 0 Then

325If index >= 0 AndAlso index < list.Count Then

77Dim i = 0, n = list.Count

20For i = 1 To [imports].Count - 1 75If [imports].Count > 1 Then

155If caseBlock.Statements.Count = 0 Then 404If ifBlock.Statements.Count > 0 Then 431If [try].Statements.Count > 0 Then

643If statements.Count = 1 Then 684Return executableBlock.GetExecutableBlockStatements().Count = 1 985For i = 0 To root.Imports.Count - 1

306Return compilationUnit Is Nothing OrElse compilationUnit.Imports.Count = 0

147If newCompilationUnit.Imports.Count = 0 AndAlso newCompilationUnit.Options.Count = 0 Then 148If newCompilationUnit.Attributes.Count > 0 OrElse newCompilationUnit.Members.Count > 0 Then

58If methodSyntax.Statements.Count = 1 Then

826Return method.Statements.Count > 0 AndAlso ContainsExclusively(GetSyntaxListSpan(method.Statements), span) 831Return [event].Accessors.Count > 0 AndAlso ContainsExclusively(GetSyntaxListSpan([event].Accessors), span) 836Return [property].Accessors.Count > 0 AndAlso ContainsExclusively(GetSyntaxListSpan([property].Accessors), span) 866Debug.Assert(list.Count > 0)

92If statements?.Count = 1 Then 115If statements?.Count = 1 Then

59If ifBlock.Statements.Count <> 1 Then 68Return ifBlock.ElseBlock IsNot Nothing Or ifBlock.ElseIfBlocks.Count > 0

61If ifStatement.ElseIfBlocks.Count > 0 Then 65If ifStatement.Statements.Count <> 1 Then

28If root.Imports.Count > 0 Then 35Dim [end] = If(root.Members.Count > 0, 91Dim importsLength = root.Imports.Count

18If members.Count = 0 Then 30For i = 0 To members.Count - 2 55allElements.Take(allElements.Count - 1).Concat(ReplaceTrailingColonToEndOfLineTrivia(allElements.Last()))) 63If allElements.Count > 0 AndAlso 64destinationType.Implements.Count = 0 Then 73If allElements.Count > 0 Then 81If destinationType.Inherits.Count = 0 AndAlso 82destinationType.Implements.Count = 0 AndAlso

420While i < arrayType.RankSpecifiers.Count

60If statements = Nothing OrElse statements.Count = 0 Then 66Dim newList As New List(Of StatementSyntax)(capacity:=statements.Count) 70Dim lastStatementToProcess = statements.Count - 1 73lastStatementToProcess = statements.Count - 2

33If constructorBlock.Statements.Count = 0 OrElse

35If eventBlock.EventStatement.AttributeLists.Count > 0 Then

257If body.Statements <> Nothing AndAlso body.Statements.Count > 0 Then 261If body.Statements.Count = 1 Then

28If statements.Count = 1 Then

45DirectCast(typeStatement.Parent, TypeBlockSyntax).Implements.Count > 0 Then

32If compilationUnit.Options.Count > 0 Then

39If tryBlock.CatchBlocks.Count = 0 Then

38If foreachBlock.Statements.Count = 0 Then 42Return (foreachBlock.Statements(0), foreachBlock.Statements(foreachBlock.Statements.Count - 1)) 70forEachBlock.Statements.Count = 0, 137If forEachBlock.Statements.Count = 0 Then

20Return Not (statements.Count = 0 OrElse operation.SemanticModel.AnalyzeControlFlow(statements.First(), statements.Last()).EndPointIsReachable)

145If documentationComment Is Nothing OrElse documentationComment.Content.Count = 0 Then 150If documentationComment.Content.Count > 2 Then 171If documentationComment.Content.Count = 2 Then

1221If ctor.Statements.Count = 0 Then 2611If tryBlock.CatchBlocks.Count = 0 Then

316If statements.Count = 0 Then

397Where(Function(t) t.Members.Count > 0).

30If .Attributes.Count = 0 Then

26Return tryStatement.CatchBlocks.Count > 0

157If statements.Count = 0 Then

183While i < oldMembers.Count

52If falseStatementOpt.Count > 0 Then

51If isSingleLine AndAlso falseStatements.Count > 0 Then 73If falseStatements.Count <> 0 Then

18Return If(statements.Count = 0, Nothing, New StatementRange(statements.First(), statements.Last())) 67If nextIndex < statements.Count Then

106If children.Count = 0 Then 111For i As Integer = 0 To children.Count - 2 134Dim nextToLast = children(children.Count - 2)

40If ifBlock.Statements.Count > 0 AndAlso span.IsAround(ifBlock, ifBlock.Statements.Last()) Then

58If methodSyntax.Statements.Count = 1 Then

92If statements?.Count = 1 Then 115If statements?.Count = 1 Then

59If ifBlock.Statements.Count <> 1 Then 68Return ifBlock.ElseBlock IsNot Nothing Or ifBlock.ElseIfBlocks.Count > 0

61If ifStatement.ElseIfBlocks.Count > 0 Then 65If ifStatement.Statements.Count <> 1 Then

1033Assert.Equal(1, el.Content.Count) 1043Assert.Equal(1, el.Content.Count)

2185Assert.Equal(1, ifBlock.ElseIfBlocks.Count) 2187Assert.Equal(1, statements.Count) 2191Assert.Equal(1, ifBlock.Statements.Count) 2224Assert.Equal(1, ifBlock.ElseIfBlocks.Count) 2226Assert.Equal(1, statements.Count) 2230Assert.Equal(1, ifBlock.Statements.Count) 2260Assert.Equal(2, statements.Count)

18Assert.Equal(3, list.Count) 36Assert.Equal(4, newList.Count) 40Assert.Equal(5, newList.Count) 44Assert.Equal(4, newList.Count) 48Assert.Equal(4, newList.Count) 52Assert.Equal(4, newList.Count) 56Assert.Equal(4, newList.Count) 60Assert.Equal(5, newList.Count) 64Assert.Equal(5, newList.Count) 68Assert.Equal(5, newList.Count) 72Assert.Equal(5, newList.Count) 76Assert.Equal(2, newList.Count) 79newList = list.RemoveAt(list.Count - 1) 80Assert.Equal(2, newList.Count) 84Assert.Equal(2, newList.Count) 88Assert.Equal(2, newList.Count) 92Assert.Equal(2, newList.Count) 96Assert.Equal(3, newList.Count) 100Assert.Equal(3, newList.Count) 104Assert.Equal(3, newList.Count) 108Assert.Equal(4, newList.Count) 112Assert.Equal(4, newList.Count) 116Assert.Equal(4, newList.Count) 120Assert.Equal(2, newList.Count) 124Assert.Equal(2, newList.Count) 128Assert.Equal(2, newList.Count) 133Assert.Throws(Of ArgumentOutOfRangeException)(Function() list.Insert(list.Count + 1, nodeD)) 135Assert.Throws(Of ArgumentOutOfRangeException)(Function() list.InsertRange(list.Count + 1, {nodeD})) 137Assert.Throws(Of ArgumentOutOfRangeException)(Function() list.RemoveAt(list.Count)) 154Assert.Equal(0, list.Count) 160Assert.Equal(1, newList.Count) 164Assert.Equal(2, newList.Count) 168Assert.Equal(1, newList.Count) 172Assert.Equal(2, newList.Count) 176Assert.Equal(0, newList.Count)

220If list.Count > 0 Then 223Assert.Equal(expectedFullSpan.End, list(list.Count - 1).FullSpan.End) 225For i = 0 To list.Count - 1 230If i < list.Count - 1 Then 2933Assert.Equal(4, x.Count)

240modifiedIdentifier.ArrayRankSpecifiers.Count > 0 OrElse

71If destinationOpt.Members.Count = 0 Then 78If destinationOpt.Members.Count = value AndAlso

71If members.Count >= 1 Then 78For i = 0 To members.Count - 2

963Return If(propertyBlock.Accessors.Count = 0, 1694If compilationUnit.Attributes.Count = 1 Then 3578If inh.Count = 1 AndAlso last IsNot Nothing Then 3588If imp.Count = 1 AndAlso last IsNot Nothing Then 3895If attrStmt IsNot Nothing AndAlso attrStmt.AttributeLists.Count = 1 Then

28If root.Imports.Count > 0 Then 35Dim [end] = If(root.Members.Count > 0, 91Dim importsLength = root.Imports.Count

155If caseBlock.Statements.Count = 0 Then 404If ifBlock.Statements.Count > 0 Then 431If [try].Statements.Count > 0 Then

20For i = 1 To [imports].Count - 1 75If [imports].Count > 1 Then

306Return compilationUnit Is Nothing OrElse compilationUnit.Imports.Count = 0

61If list.Count > 0 Then

643If statements.Count = 1 Then 684Return executableBlock.GetExecutableBlockStatements().Count = 1 985For i = 0 To root.Imports.Count - 1

18If members.Count = 0 Then 30For i = 0 To members.Count - 2 55allElements.Take(allElements.Count - 1).Concat(ReplaceTrailingColonToEndOfLineTrivia(allElements.Last()))) 63If allElements.Count > 0 AndAlso 64destinationType.Implements.Count = 0 Then 73If allElements.Count > 0 Then 81If destinationType.Inherits.Count = 0 AndAlso 82destinationType.Implements.Count = 0 AndAlso

147If newCompilationUnit.Imports.Count = 0 AndAlso newCompilationUnit.Options.Count = 0 Then 148If newCompilationUnit.Attributes.Count > 0 OrElse newCompilationUnit.Members.Count > 0 Then

826Return method.Statements.Count > 0 AndAlso ContainsExclusively(GetSyntaxListSpan(method.Statements), span) 831Return [event].Accessors.Count > 0 AndAlso ContainsExclusively(GetSyntaxListSpan([event].Accessors), span) 836Return [property].Accessors.Count > 0 AndAlso ContainsExclusively(GetSyntaxListSpan([property].Accessors), span) 866Debug.Assert(list.Count > 0)

420While i < arrayType.RankSpecifiers.Count

89for (var i = fieldIndex; i < members.Count; i++)

22if (existingImports.Count == 0)

200Contract.ThrowIfTrue(availableIndices != null && availableIndices.Count != declarationList.Count + 1); 287var index = GetPreferredIndex(declarationList.Count, availableIndices, forward: false); 294return declarationList.Count; 343Debug.Assert(desiredGroupIndex <= declarationList.Count); 346while (desiredGroupIndex < declarationList.Count)

1550for (; count > 0 && offset < list.Count; count--)

98if (currentAccessors.Count != previousAccessors.Count)

102if (classBlock.Implements.Count > 0) 104return classBlock.Implements[classBlock.Implements.Count - 1].FullSpan.End; 106else if (classBlock.Inherits.Count > 0) 108return classBlock.Inherits[classBlock.Inherits.Count - 1].FullSpan.End;

800return oldArrayType.RankSpecifiers.Count == newArrayType.RankSpecifiers.Count

2309if (method.Body != null && method.Body.Statements.Count == 0) 2324accessor.Body.Statements.Count > 1 || 2325(accessor.Body.Statements.Count == 1 && !accessor.Body.Statements[0].IsKind(SyntaxKind.ReturnStatement)))

324if (node.AttributeLists.Count == 0) 372if (node.AttributeLists.Count == 0) 458if (node.AttributeLists.Count == 0) 621if (node.AttributeLists.Count == 0) 695if (field.AttributeLists.Count == 0) 735if (node.AttributeLists.Count == 0) 775if (node.AttributeLists.Count == 0) 896if (node.AttributeLists.Count == 0) 937if (node.AttributeLists.Count == 0) 1011if (node.AttributeLists.Count == 0) 1110if (node.AttributeLists.Count == 0) 1233if (node.AttributeLists.Count == 0) 1275if (field.AttributeLists.Count == 0) 1316if (node.AttributeLists.Count == 0)

80for (var i = 0; i < specifiers.Count; i++)

63if (node.TryGetAttributeLists(out var attributeLists) && attributeLists.Count > 0)

1033Return oldArrayType.RankSpecifiers.Count = newArrayType.RankSpecifiers.Count AndAlso

224If attributes.Count = 0 Then 256If attributes.Count = 0 Then 534If declareStatement.AttributeLists.Count > 0 Then 599If methodStatement.AttributeLists.Count > 0 Then 716If propertyStatement.AttributeLists.Count > 0 Then 844If eventStatement.AttributeLists.Count > 0 Then 925If delegateStatement.AttributeLists.Count > 0 Then

60For i = 0 To specifiers.Count - 1

3086For i = 0 To eventBlock.Accessors.Count - 1 3352For i = 0 To propertyBlock.Accessors.Count - 1 4261Dim baseCount = typeBlock.Inherits.Count 4287If typeBlock.Inherits.Count = 0 Then 4327Dim baseCount = typeBlock.Implements.Count 4359If typeBlock.Implements.Count = 0 Then

197If method Is Nothing OrElse method.Statements.Count <> 2 Then