Contract

src\Analyzers\Core\Analyzers\ForEachCast\AbstractForEachCastDiagnosticAnalyzer.cs (1)

58Contract.ThrowIfFalse(option.Value is ForEachExplicitCastInSourcePreference.Always or ForEachExplicitCastInSourcePreference.WhenStronglyTyped);

src\Analyzers\Core\Analyzers\Formatting\AbstractFormattingAnalyzer.cs (2)

62Contract.ThrowIfNull(change.NewText); 89Contract.ThrowIfNull(change.NewText);

src\Analyzers\Core\Analyzers\Helpers\DiagnosticHelper.cs (3)

212Contract.ThrowIfTrue(additionalLocations.IsEmpty()); 213Contract.ThrowIfTrue(tagIndices.IsEmpty()); 223Contract.ThrowIfFalse(indices.All(idx => idx >= 0 && idx < additionalLocationsLength));

src\Analyzers\Core\Analyzers\RemoveUnusedParametersAndValues\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.BlockAnalyzer.cs (2)

124Contract.ThrowIfFalse(context.FilterSpan != symbolStartAnalyzer._symbolStartAnalysisContext.FilterSpan); 125Contract.ThrowIfNull(symbolStartAnalyzer._symbolStartAnalysisContext.FilterTree);

src\Analyzers\Core\Analyzers\SimplifyInterpolation\AbstractSimplifyInterpolationHelpers.cs (3)

91Contract.ThrowIfNull(expression.SemanticModel); 151Contract.ThrowIfNull(operation.SemanticModel); 170Contract.ThrowIfNull(operation.SemanticModel);

src\Analyzers\Core\Analyzers\UseAutoProperty\AbstractUseAutoPropertyAnalyzer.cs (2)

200Contract.ThrowIfNull(context.FilterTree); 485Contract.ThrowIfFalse(TryGetSyntax(getterField, out var fieldDeclaration, out var variableDeclarator, cancellationToken));

src\Analyzers\Core\Analyzers\UseCollectionInitializer\AbstractUseCollectionInitializerAnalyzer.cs (1)

160Contract.ThrowIfTrue(seenInvocation && seenIndexAssignment);

src\Analyzers\Core\Analyzers\UseCollectionInitializer\UpdateExpressionState.cs (2)

229Contract.ThrowIfTrue(arguments.Count == 0); 230Contract.ThrowIfFalse(this.SyntaxFacts.IsSimpleMemberAccessExpression(memberAccess));

src\Analyzers\Core\Analyzers\UseConditionalExpression\UseConditionalExpressionHelpers.cs (1)

56Contract.ThrowIfNull(semanticModel);

src\Analyzers\Core\Analyzers\UseThrowExpression\AbstractUseThrowExpressionDiagnosticAnalyzer.cs (1)

80Contract.ThrowIfNull(semanticModel);

src\Dependencies\Collections\Extensions\FixedSizeArrayBuilder.cs (1)

64Contract.ThrowIfTrue(condition, lineNumber, filePath);

src\Dependencies\Threading\AsyncBatchingWorkQueue`2.cs (1)

270Contract.ThrowIfFalse(batchResultTask.IsCompleted);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\ImmutableIntervalTree`1.cs (2)

237Contract.ThrowIfTrue(leftMaxEndValue < 0 && rightMaxEndValue < 0); 248Contract.ThrowIfFalse(rightMaxEndValue > leftMaxEndValue);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\IntervalTreeHelpers.NodeEnumerator.cs (2)

77Contract.ThrowIfTrue(_currentNodeHasValue); 78Contract.ThrowIfTrue(_stack.Count == 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\Common\EmbeddedSeparatedSyntaxNodeList.cs (1)

27Contract.ThrowIfTrue(nodesAndTokens.IsDefault);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\VirtualChar.cs (1)

71Contract.ThrowIfFalse(surrogateChar == 0 || rune == Rune.ReplacementChar,

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\AnalysisContextExtensions.cs (4)

165Contract.ThrowIfNull(context.FilterTree); 166Contract.ThrowIfFalse(context.FilterSpan.HasValue); 177Contract.ThrowIfNull(context.FilterTree); 178Contract.ThrowIfFalse(context.FilterSpan.HasValue);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\AnalyzerConfigOptionsExtensions.cs (1)

22Contract.ThrowIfFalse(option.Definition.IsEditorConfigOption);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\LocationExtensions.cs (1)

14Contract.ThrowIfNull(location.SourceTree);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SemanticEquivalence.cs (1)

105Contract.ThrowIfTrue(b1 != b2);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SemanticModelExtensions.cs (3)

101Contract.ThrowIfNull(semanticModel.ParentModel); 102Contract.ThrowIfTrue(semanticModel.ParentModel.IsSpeculativeSemanticModel); 103Contract.ThrowIfTrue(semanticModel.ParentModel.ParentModel != null);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SourceTextExtensions_SharedWithCodeStyle.cs (1)

18Contract.ThrowIfNull(text);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\StackExtensions.cs (2)

48Contract.ThrowIfNull(stack); 49Contract.ThrowIfNull(range);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\StringExtensions.cs (10)

16Contract.ThrowIfNull(line); 31Contract.ThrowIfNull(line); 46Contract.ThrowIfNull(lineText); 57Contract.ThrowIfNull(lineText); 208Contract.ThrowIfNull(line); 209Contract.ThrowIfFalse(0 <= endPosition && endPosition <= line.Length); 210Contract.ThrowIfFalse(tabSize > 0); 217Contract.ThrowIfNull(line); 218Contract.ThrowIfFalse(column >= 0); 219Contract.ThrowIfFalse(tabSize > 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (4)

107Contract.ThrowIfNull(node); 179Contract.ThrowIfTrue(node1.RawKind == 0 || node2.RawKind == 0); 298Contract.ThrowIfNull(nodes); 299Contract.ThrowIfFalse(nodes.Any());

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxTreeExtensions.cs (2)

72Contract.ThrowIfNull(syntaxTree); 134Contract.ThrowIfNull(syntaxTree);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\BottomUpBaseIndentationFinder.cs (1)

34Contract.ThrowIfNull(formattingRules);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Context\FormattingContext.cs (4)

57Contract.ThrowIfNull(engine); 58Contract.ThrowIfNull(tokenStream); 124Contract.ThrowIfNull(operations); 413Contract.ThrowIfFalse(intervals.Length == 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Context\FormattingContext.InitialContextFinder.cs (3)

34Contract.ThrowIfNull(tokenStream); 35Contract.ThrowIfNull(formattingRules); 36Contract.ThrowIfNull(rootNode);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\AbstractAggregatedFormattingResult.cs (2)

31Contract.ThrowIfNull(node); 32Contract.ThrowIfNull(formattingResults);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\AbstractFormatEngine.cs (1)

94Contract.ThrowIfTrue(treeData.Root.IsInvalidTokenRange(startToken, endToken));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\AbstractFormatEngine.OperationApplier.cs (6)

52Contract.ThrowIfFalse(triviaInfo.LineBreaks == 0); 85Contract.ThrowIfFalse(triviaInfo.LineBreaks == 0); 123Contract.ThrowIfFalse(triviaInfo.LineBreaks == 0); 262Contract.ThrowIfNull(previousChangesMap); 451Contract.ThrowIfFalse(triviaInfo.SecondTokenIsFirstTokenOnLine); 478Contract.ThrowIfFalse(baseToken.RawKind != 0 && startToken.RawKind != 0 && endToken.RawKind != 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\AbstractTriviaDataFactory.AbstractComplexTrivia.cs (3)

22Contract.ThrowIfNull(treeInfo); 75Contract.ThrowIfFalse(line > 0); 132Contract.ThrowIfFalse(list.Count > 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\AbstractTriviaDataFactory.cs (4)

27Contract.ThrowIfNull(treeInfo); 88Contract.ThrowIfFalse(space >= 0); 107Contract.ThrowIfFalse(lineBreaks >= 0); 108Contract.ThrowIfFalse(indentation >= 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\AbstractTriviaDataFactory.ModifiedWhitespace.cs (1)

25Contract.ThrowIfNull(original);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\AbstractTriviaDataFactory.Whitespace.cs (2)

25Contract.ThrowIfFalse(space >= 0); 55Contract.ThrowIfFalse(line > 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\ChainedFormattingRules.cs (1)

33Contract.ThrowIfNull(formattingRules);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\TokenData.cs (4)

27Contract.ThrowIfNull(tokenStream); 28Contract.ThrowIfFalse((indexInStream == -1) || (0 <= indexInStream && indexInStream < tokenStream.TokenCount)); 61Contract.ThrowIfFalse(this.TokenStream == other.TokenStream); 81Contract.ThrowIfNull(commonRoot);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\TokenPairWithOperations.cs (2)

27Contract.ThrowIfNull(tokenStream); 29Contract.ThrowIfFalse(0 <= tokenPairIndex && tokenPairIndex < tokenStream.TokenCount - 1);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\TokenStream.cs (10)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\TreeData.cs (1)

40Contract.ThrowIfNull(root);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\TreeData.Debug.cs (1)

18Contract.ThrowIfFalse(text == _debugNodeData.GetTextBetween(token1, token2));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\TreeData.Node.cs (2)

17Contract.ThrowIfFalse(root.GetFirstToken(includeZeroWidth: true).RawKind != 0); 22Contract.ThrowIfTrue(token.RawKind == 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\TreeData.NodeAndText.cs (2)

19Contract.ThrowIfNull(text); 25Contract.ThrowIfTrue(token.RawKind == 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\TreeData.StructuredTrivia.cs (1)

21Contract.ThrowIfFalse(trivia.HasStructure);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\FormattingExtensions.cs (1)

183Contract.ThrowIfFalse(lines.Length > 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\Operations\AdjustNewLinesOperation.cs (3)

14Contract.ThrowIfFalse(option != AdjustNewLinesOption.ForceLines || line > 0); 15Contract.ThrowIfFalse(option != AdjustNewLinesOption.PreserveLines || line >= 0); 16Contract.ThrowIfFalse(option != AdjustNewLinesOption.ForceLinesIfOnSingleLine || line > 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\Operations\AdjustSpacesOperation.cs (1)

14Contract.ThrowIfFalse(space >= 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\Operations\AlignTokensOperation.cs (1)

18Contract.ThrowIfNull(tokens);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\Operations\AnchorIndentationOperation.cs (3)

17Contract.ThrowIfTrue(anchorToken.RawKind == 0); 18Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0); 20Contract.ThrowIfTrue(endToken.RawKind == 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\Operations\IndentBlockOperation.cs (10)

16Contract.ThrowIfFalse(option.IsMaskOn(IndentBlockOption.PositionMask)); 18Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0); 19Contract.ThrowIfTrue(startToken.RawKind == 0); 20Contract.ThrowIfTrue(endToken.RawKind == 0); 35Contract.ThrowIfFalse(option.IsMaskOn(IndentBlockOption.PositionMask)); 37Contract.ThrowIfFalse(option.IsMaskOn(IndentBlockOption.RelativePositionMask)); 38Contract.ThrowIfFalse(baseToken.Span.End <= textSpan.Start); 40Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0); 41Contract.ThrowIfTrue(startToken.RawKind == 0); 42Contract.ThrowIfTrue(endToken.RawKind == 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\Operations\SuppressOperation.cs (3)

21Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0); 22Contract.ThrowIfTrue(startToken.RawKind == 0); 23Contract.ThrowIfTrue(endToken.RawKind == 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\TriviaEngine\AbstractTriviaFormatter.cs (6)

71Contract.ThrowIfNull(context); 72Contract.ThrowIfNull(formattingRules); 73Contract.ThrowIfNull(originalString); 75Contract.ThrowIfFalse(lineBreaks >= 0); 76Contract.ThrowIfFalse(spaces >= 0); 78Contract.ThrowIfTrue(token1 == default && token2 == default);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Log\Logger.LogBlock.cs (1)

21Contract.ThrowIfNull(logger);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\NamingStylePreferences.cs (4)

61Contract.ThrowIfFalse(serializableRules.IsEmpty == namingStyles.IsEmpty); 62Contract.ThrowIfFalse(serializableRules.IsEmpty == symbolSpecifications.IsEmpty); 80Contract.ThrowIfFalse(namingRules.IsEmpty == namingStyles.IsEmpty); 81Contract.ThrowIfFalse(namingRules.IsEmpty == symbolSpecifications.IsEmpty);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\EditorConfigValueSerializer`1.cs (1)

58Contract.ThrowIfTrue(RoslynString.IsNullOrEmpty(editorConfigStringForValue));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\AbstractDocumentationCommentService.cs (1)

49Contract.ThrowIfNull(documentationComment);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\ISyntaxFactsExtensions.cs (1)

29Contract.ThrowIfNull(node);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.BodyLevelSymbolKey.cs (5)

21Contract.ThrowIfFalse(IsBodyLevelSymbol(symbol)); 22Contract.ThrowIfTrue(symbol.DeclaringSyntaxReferences.IsEmpty && symbol.Locations.IsEmpty); 61Contract.ThrowIfTrue(symbol.DeclaringSyntaxReferences.IsEmpty && symbol.Locations.IsEmpty); 65Contract.ThrowIfFalse(locations.All(loc => loc != null && loc.IsInSource)); 257Contract.ThrowIfTrue(semanticModel.SyntaxTree != containerDeclaration.SyntaxTree);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.BuiltinOperatorSymbolKey.cs (1)

46Contract.ThrowIfNull(returnTypeSymbol);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.ErrorTypeSymbolKey.cs (2)

85Contract.ThrowIfFalse(typeArguments.IsDefault); 90Contract.ThrowIfTrue(typeArguments.IsDefault);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.FunctionPointerTypeSymbolKey.cs (2)

69Contract.ThrowIfFalse(parameterTypes.IsDefault); 74Contract.ThrowIfTrue(parameterTypes.IsDefault);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.NamedTypeSymbolKey.cs (2)

62Contract.ThrowIfFalse(typeArguments.IsDefault); 68Contract.ThrowIfTrue(typeArguments.IsDefault);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyReader.cs (5)

126Contract.ThrowIfNull(result); 417Contract.ThrowIfTrue(_methodSymbolStack.Count == 0); 418Contract.ThrowIfFalse(Equals(method, _methodSymbolStack[^1])); 433Contract.ThrowIfTrue(_contextualSymbolStack.Count == 0); 434Contract.ThrowIfFalse(Equals(contextualSymbol, _contextualSymbolStack.Peek()));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyWriter.cs (2)

517Contract.ThrowIfTrue(_methodSymbolStack.Count == 0); 518Contract.ThrowIfFalse(method.Equals(_methodSymbolStack[^1]));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.TypeParameterOrdinalSymbolKey.cs (1)

13Contract.ThrowIfFalse(symbol.TypeParameterKind == TypeParameterKind.Method);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AnnotationTable.cs (1)

103Contract.ThrowIfNull(ra.Data);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AsyncLazy`1.cs (12)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\BKTree.cs (7)

54Contract.ThrowIfNull(concatenatedLowerCaseWords, nameof(_concatenatedLowerCaseWords)); 55Contract.ThrowIfTrue(nodes.IsDefault, $"{nameof(nodes)}.{nameof(nodes.IsDefault)}"); 56Contract.ThrowIfTrue(edges.IsDefault, $"{nameof(edges)}.{nameof(edges.IsDefault)}"); 67Contract.ThrowIfNull(value, nameof(value)); 68Contract.ThrowIfNull(_concatenatedLowerCaseWords, nameof(_concatenatedLowerCaseWords)); 69Contract.ThrowIfTrue(_nodes.IsDefault, $"{nameof(_nodes)}.{nameof(_nodes.IsDefault)}"); 70Contract.ThrowIfTrue(_edges.IsDefault, $"{nameof(_edges)}.{nameof(_edges.IsDefault)}");

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\CommonFormattingHelpers.cs (15)

47Contract.ThrowIfNull(root); 48Contract.ThrowIfFalse(spans.Count > 0); 83Contract.ThrowIfNull(root); 84Contract.ThrowIfTrue(textSpan.IsEmpty); 123Contract.ThrowIfFalse(startToken.Equals(endToken) || startToken.Span.End <= endToken.SpanStart); 147Contract.ThrowIfNull(tree); 148Contract.ThrowIfTrue(token.RawKind == 0); 169Contract.ThrowIfTrue(token1.RawKind == 0 && token2.RawKind == 0); 170Contract.ThrowIfTrue(token1.Equals(token2)); 285Contract.ThrowIfFalse(backwardPosition < parentNode.FullSpan.End); 289Contract.ThrowIfTrue(nextToken.RawKind == 0); 310Contract.ThrowIfNull(parentNode); 311Contract.ThrowIfFalse(parentNode.FullSpan.Start < forwardPosition); 315Contract.ThrowIfTrue(previousToken.RawKind == 0); 359Contract.ThrowIfNull(root);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\EnumerableConditionalWeakTable.cs (1)

114Contract.ThrowIfFalse(_table.Remove(key));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\EnumValueUtilities.cs (1)

148Contract.ThrowIfTrue(typeof(TFromEnum).GetEnumUnderlyingType() != typeof(TToEnum).GetEnumUnderlyingType());

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\NonReentrantLock.cs (1)

173=> Contract.ThrowIfFalse(LockHeldByMe());

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\ReferenceCountedDisposable.cs (1)

294Contract.ThrowIfNull(weakInstance);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\TaskExtensions.cs (2)

69Contract.ThrowIfFalse(task.IsCompleted); 85Contract.ThrowIfFalse(task.IsCompleted);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\ValueTaskExtensions.cs (1)

22Contract.ThrowIfFalse(task.IsCompleted, message);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (3)

336Contract.ThrowIfNull(classOrStructType); 337Contract.ThrowIfNull(interfacesOrAbstractClasses); 338Contract.ThrowIfNull(isImplemented);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (1)

560Contract.ThrowIfFalse(symbol.IsNormalAnonymousType());

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions_Accessibility.cs (7)

90Contract.ThrowIfNull(symbol); 91Contract.ThrowIfNull(within); 180Contract.ThrowIfNull(type); 218Contract.ThrowIfNull(assembly); 255Contract.ThrowIfNull(containingType); 431Contract.ThrowIfNull(withinType); 432Contract.ThrowIfNull(originalContainingType);

src\Analyzers\Core\CodeFixes\AddAccessibilityModifiers\AbstractAddAccessibilityModifiersCodeFixProvider.cs (1)

52Contract.ThrowIfNull(symbol);

src\Analyzers\Core\CodeFixes\AddAccessibilityModifiers\AddAccessibilityModifiersHelpers.cs (1)

15Contract.ThrowIfNull(symbol);

src\Analyzers\Core\CodeFixes\AddObsoleteAttribute\AbstractAddObsoleteAttributeCodeFixProvider.cs (1)

77Contract.ThrowIfNull(obsoleteAttribute);

src\Analyzers\Core\CodeFixes\DocumentationComments\AbstractRemoveDocCommentNodeCodeFixProvider.cs (1)

81Contract.ThrowIfNull(newRoot);

src\Analyzers\Core\CodeFixes\ForEachCast\AbstractForEachCastCodeFixProvider.cs (2)

67Contract.ThrowIfNull(variableDeclarator.Symbol.Type); 68Contract.ThrowIfNull(enumerableType);

src\Analyzers\Core\CodeFixes\GenerateConstructor\AbstractGenerateConstructorService.cs (1)

89Contract.ThrowIfNull(state.TypeToGenerateIn);

src\Analyzers\Core\CodeFixes\GenerateConstructor\AbstractGenerateConstructorService.State.cs (10)

105Contract.ThrowIfNull(TypeToGenerateIn); 125Contract.ThrowIfNull(TypeToGenerateIn); 142Contract.ThrowIfNull(TypeToGenerateIn); 185Contract.ThrowIfNull(TypeToGenerateIn); 186Contract.ThrowIfNull(TypeToGenerateIn.BaseType); 207Contract.ThrowIfNull(TypeToGenerateIn); 241Contract.ThrowIfNull(TypeToGenerateIn); 425Contract.ThrowIfNull(TypeToGenerateIn); 458Contract.ThrowIfNull(TypeToGenerateIn); 480Contract.ThrowIfNull(TypeToGenerateIn);

src\Analyzers\Core\CodeFixes\GenerateConstructor\GenerateConstructorHelpers.cs (1)

303Contract.ThrowIfNull(typeToGenerateIn);

src\Analyzers\Core\CodeFixes\GenerateDefaultConstructors\AbstractGenerateDefaultConstructorsService.cs (1)

49Contract.ThrowIfNull(state.ClassType);

src\Analyzers\Core\CodeFixes\GenerateDefaultConstructors\GenerateDefaultConstructorsCodeAction.cs (2)

32Contract.ThrowIfNull(_state.ClassType); 53Contract.ThrowIfNull(classType);

src\Analyzers\Core\CodeFixes\GenerateMember\AbstractGenerateMemberService.cs (1)

131Contract.ThrowIfNull(attributeNode);

src\Analyzers\Core\CodeFixes\MakeFieldReadonly\AbstractMakeFieldReadonlyCodeFixProvider.cs (1)

80Contract.ThrowIfNull(symbol);

src\Analyzers\Core\CodeFixes\MakeMethodAsynchronous\AbstractMakeMethodAsynchronousCodeFixProvider.cs (3)

114Contract.ThrowIfNull(node); 121Contract.ThrowIfNull(methodSymbol); 210Contract.ThrowIfNull(partialDefinitionDocument);

src\Analyzers\Core\CodeFixes\MakeMethodSynchronous\AbstractMakeMethodSynchronousCodeFixProvider.cs (2)

59Contract.ThrowIfNull(methodSymbol); 252Contract.ThrowIfNull(currentInvocationExpression);

src\Analyzers\Core\CodeFixes\NamingStyle\NamingStyleCodeFixProvider.cs (1)

50Contract.ThrowIfNull(serializedNamingStyle);

src\Analyzers\Core\CodeFixes\RemoveUnusedMembers\AbstractRemoveUnusedMembersCodeFixProvider.cs (2)

57Contract.ThrowIfNull(symbol); 70Contract.ThrowIfNull(fieldDeclarator);

src\Analyzers\Core\CodeFixes\RemoveUnusedParametersAndValues\AbstractRemoveUnusedValuesCodeFixProvider.cs (6)

496Contract.ThrowIfNull(variableDeclarator); 512Contract.ThrowIfFalse(node.GetRequiredParent().Parent is TExpressionStatementSyntax); 602Contract.ThrowIfNull(type); 603Contract.ThrowIfNull(newLocalNameOpt); 858Contract.ThrowIfNull(declStatement); 904Contract.ThrowIfNull(rootWithRemovedDeclaration);

src\Analyzers\Core\CodeFixes\UseCoalesceExpression\AbstractUseCoalesceExpressionForIfNullStatementCheckCodeFixProvider.cs (1)

89Contract.ThrowIfNull(expression); // checked in analyzer.

src\Analyzers\Core\CodeFixes\UseExplicitTupleName\UseExplicitTupleNameCodeFixProvider.cs (1)

44Contract.ThrowIfNull(preferredName);

src\Analyzers\Core\CodeFixes\UseNullPropagation\AbstractUseNullPropagationCodeFixProvider.cs (1)

181Contract.ThrowIfNull(newWhenTrueStatement);

src\Analyzers\Core\CodeFixes\UseObjectInitializer\AbstractUseObjectInitializerCodeFixProvider.cs (1)

81Contract.ThrowIfNull(statement);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\AbstractFlagsEnumGenerator.cs (5)

77Contract.ThrowIfNull(enumType.EnumUnderlyingType); 118Contract.ThrowIfNull(finalNode); 148Contract.ThrowIfNull(field.ConstantValue); 171Contract.ThrowIfNull(enumType.EnumUnderlyingType); 187Contract.ThrowIfNull(enumType.EnumUnderlyingType);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\CodeGenerationHelpers.cs (2)

181Contract.ThrowIfNull(attribute); 200Contract.ThrowIfTrue(availableIndices != null && availableIndices.Count != declarationList.Count + 1);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\CodeGenerationOptionsProviders.cs (1)

42Contract.ThrowIfNull(document.Project.ParseOptions);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\SyntaxAnnotationExtensions.cs (1)

17Contract.ThrowIfFalse(symbol is CodeGenerationSymbol);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\DocumentExtensions.cs (1)

130Contract.ThrowIfFalse(document.SupportsSemanticModel);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions.cs (1)

442Contract.ThrowIfNull(type);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_Negate.cs (1)

552Contract.ThrowIfFalse(syntaxFacts.IsNotPattern(pattern));

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\TextDocumentExtensions.cs (2)

50Contract.ThrowIfFalse(textDocument is AdditionalDocument); 59Contract.ThrowIfFalse(textDocument is AnalyzerConfigDocument);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\FindSymbols\LinkedFileReferenceLocationEqualityComparer.cs (1)

24Contract.ThrowIfFalse(x.Document == y.Document);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Indentation\IIndentationService.cs (1)

35Contract.ThrowIfNull(firstNonWhitespacePos);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\AbstractSimplificationService.cs (1)

163Contract.ThrowIfFalse(nodesAndTokensToReduce.Any());

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\SimplificationHelpers.cs (1)

65Contract.ThrowIfNull(expression);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\ParsedDocument.cs (1)

70Contract.ThrowIfFalse(Id == oldDocument.Id);

src\Analyzers\CSharp\Analyzers\AddAccessibilityModifiers\CSharpAddAccessibilityModifiers.cs (1)

76Contract.ThrowIfFalse(option == AccessibilityModifiersRequired.OmitIfDefault);

src\Analyzers\CSharp\Analyzers\AddBraces\CSharpAddBracesDiagnosticAnalyzer.cs (1)

58Contract.ThrowIfNull(embeddedStatement);

src\Analyzers\CSharp\Analyzers\ConvertSwitchStatementToExpression\ConvertSwitchStatementToExpressionDiagnosticAnalyzer.Analyzer.cs (3)

45Contract.ThrowIfNull(dataFlow); 64Contract.ThrowIfNull(declaration); 70Contract.ThrowIfNull(beforeSwitch);

src\Analyzers\CSharp\Analyzers\InlineDeclaration\CSharpInlineDeclarationDiagnosticAnalyzer.cs (2)

266Contract.ThrowIfNull(nextStatement); 271Contract.ThrowIfNull(dataFlow);

src\Analyzers\CSharp\Analyzers\MakeStructMemberReadOnly\CSharpMakeStructMemberReadOnlyAnalyzer.cs (2)

77Contract.ThrowIfNull(context.FilterTree); 220Contract.ThrowIfNull(semanticModel);

src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryImports\CSharpRemoveUnnecessaryImportsDiagnosticAnalyzer.cs (1)

53Contract.ThrowIfFalse(nodes.Any());

src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryNullableDirective\CSharpRemoveUnnecessaryNullableDirectiveDiagnosticAnalyzer.cs (2)

117Contract.ThrowIfNull(currentOptionsDirective); 149Contract.ThrowIfNull(currentOptionsDirective);

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForFluentDiagnosticAnalyzer.cs (1)

358Contract.ThrowIfTrue(useSpread && arguments.Count != 1);

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\UseCollectionExpressionHelpers.cs (3)

659Contract.ThrowIfFalse(originalInitializer.Parent 747Contract.ThrowIfFalse(expression is ArrayCreationExpressionSyntax or StackAllocArrayCreationExpressionSyntax); 1193Contract.ThrowIfTrue(arguments.Count != 1);

src\Analyzers\CSharp\Analyzers\UseExpressionBody\Helpers\UseExpressionBodyHelper`1.cs (1)

87Contract.ThrowIfNull(body);

src\Analyzers\CSharp\Analyzers\UseIndexOrRangeOperator\CSharpUseIndexOperatorDiagnosticAnalyzer.cs (1)

198Contract.ThrowIfNull(semanticModel);

src\Analyzers\CSharp\Analyzers\UseIndexOrRangeOperator\CSharpUseRangeOperatorDiagnosticAnalyzer.cs (5)

79Contract.ThrowIfNull(semanticModel); 141Contract.ThrowIfNull(invocation.Instance); 165Contract.ThrowIfNull(invocation.Instance); 227Contract.ThrowIfNull(invocation.Instance); 276Contract.ThrowIfNull(invocation.Instance);

src\Analyzers\CSharp\Analyzers\UseIsNullCheck\CSharpUseNullCheckOverTypeCheckDiagnosticAnalyzer.cs (1)

90Contract.ThrowIfNull(semanticModel);

src\Analyzers\CSharp\Analyzers\UsePatternCombinators\AnalyzedPattern.cs (1)

33Contract.ThrowIfNull(operation.SemanticModel);

src\Analyzers\CSharp\Analyzers\UsePatternMatching\CSharpAsAndMemberAccessDiagnosticAnalyzer.cs (1)

132Contract.ThrowIfNull(isPatternExpression);

src\Analyzers\CSharp\Analyzers\UsePatternMatching\CSharpAsAndNullCheckDiagnosticAnalyzer.Analyzer.cs (7)

38Contract.ThrowIfNull(semanticModel); 39Contract.ThrowIfNull(localSymbol); 40Contract.ThrowIfNull(comparison); 41Contract.ThrowIfNull(operand); 323Contract.ThrowIfNull(statement); 349Contract.ThrowIfNull(scope); 417Contract.ThrowIfNull(dataFlow);

src\Analyzers\CSharp\Analyzers\UsePrimaryConstructor\CSharpUsePrimaryConstructorDiagnosticAnalyzer.cs (1)

547Contract.ThrowIfNull(semanticModel);

src\Analyzers\CSharp\Analyzers\UseUtf8StringLiteral\UseUtf8StringLiteralDiagnosticAnalyzer.cs (1)

86Contract.ThrowIfNull(semanticModel);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\EmbeddedLanguages\VirtualChars\CSharpVirtualCharService.cs (3)

141Contract.ThrowIfFalse(tokenText is [.., 'u' or 'U', '8']); 147Contract.ThrowIfFalse(tokenText[0] == '"'); 152Contract.ThrowIfFalse(tokenText[endIndexExclusive - 1] == '"');

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\BlockSyntaxExtensions.cs (1)

177Contract.ThrowIfFalse(preference == ExpressionBodyPreference.WhenOnSingleLine);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SemanticModelExtensions.cs (1)

170Contract.ThrowIfNull(@using.NamespaceOrType);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SyntaxNodeExtensions.cs (1)

80Contract.ThrowIfTrue(sourceText == null && includePreviousTokenTrailingTriviaOnlyIfOnSameLine, "If we are including previous token trailing trivia, we need the text too.");

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SyntaxTokenExtensions.cs (2)

257Contract.ThrowIfFalse(genericIdentifier.Kind() == SyntaxKind.IdentifierToken); 261Contract.ThrowIfFalse(token.Kind() == SyntaxKind.LessThanToken);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SyntaxTreeExtensions.cs (1)

472Contract.ThrowIfNull(syntaxTree);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SyntaxTriviaExtensions.cs (2)

121Contract.ThrowIfNull(trivia); 137Contract.ThrowIfNull(trivia);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Formatting\Engine\Trivia\CSharpTriviaFormatter.cs (1)

224Contract.ThrowIfFalse(multilineCommentTrivia.Count == 1);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Formatting\Engine\Trivia\TriviaDataFactory.Analyzer.cs (1)

128Contract.ThrowIfFalse(SyntaxFacts.IsPreprocessorDirective(trivia.Kind()));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Formatting\Engine\Trivia\TriviaDataFactory.CodeShapeAnalyzer.cs (3)

36Contract.ThrowIfTrue(trivia.Kind() == SyntaxKind.EndOfLineTrivia); 37Contract.ThrowIfTrue(trivia.Kind() == SyntaxKind.SkippedTokensTrivia); 38Contract.ThrowIfTrue(trivia.Kind() == SyntaxKind.PreprocessingMessageTrivia);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Formatting\Engine\Trivia\TriviaDataFactory.ComplexTrivia.cs (1)

61Contract.ThrowIfFalse(triviaList.Count > 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Formatting\Engine\Trivia\TriviaDataFactory.cs (1)

108Contract.ThrowIfFalse(space >= -1);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Formatting\Engine\Trivia\TriviaDataFactory.FormattedComplexTrivia.cs (3)

31Contract.ThrowIfNull(context); 32Contract.ThrowIfNull(formattingRules); 33Contract.ThrowIfNull(originalString);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Formatting\Engine\Trivia\TriviaDataFactory.ModifiedComplexTrivia.cs (3)

22Contract.ThrowIfNull(original); 72Contract.ThrowIfFalse(this.SecondTokenIsFirstTokenOnLine); 78Contract.ThrowIfFalse(triviaList.Count > 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Formatting\Engine\Trivia\TriviaRewriter.cs (2)

33Contract.ThrowIfNull(node); 34Contract.ThrowIfNull(map);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Formatting\FormattingHelpers.cs (1)

488Contract.ThrowIfNull(node);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Indentation\CSharpSmartTokenFormatter.cs (4)

35Contract.ThrowIfNull(root); 47Contract.ThrowIfTrue(startToken.Kind() is SyntaxKind.None or SyntaxKind.EndOfFileToken); 48Contract.ThrowIfTrue(endToken.Kind() is SyntaxKind.None or SyntaxKind.EndOfFileToken); 78Contract.ThrowIfTrue(token.Kind() is SyntaxKind.None or SyntaxKind.EndOfFileToken);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Simplification\CSharpInferredMemberNameSimplifier.cs (2)

62Contract.ThrowIfNull(toRemove.NameColon); 84Contract.ThrowIfNull(toRemove.NameEquals);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Simplification\Simplifiers\CastSimplifier.cs (1)

183Contract.ThrowIfTrue(castNode.WalkUpParentheses().ContainsDiagnostics);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Utilities\FormattingRangeHelper.cs (1)

22Contract.ThrowIfTrue(endToken.Kind() == SyntaxKind.None);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Utilities\UsingsAndExternAliasesDirectiveComparer.cs (2)

134Contract.ThrowIfNull(using1!.Name); 135Contract.ThrowIfNull(using2!.Name);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Utilities\UsingsAndExternAliasesOrganizer.cs (2)

93Contract.ThrowIfNull(using1.Name); 94Contract.ThrowIfNull(using2.Name);

src\Analyzers\CSharp\CodeFixes\AssignOutParameters\AbstractAssignOutParametersCodeFixProvider.cs (1)

110Contract.ThrowIfNull(parameterList);

src\Analyzers\CSharp\CodeFixes\ConvertSwitchStatementToExpression\ConvertSwitchStatementToExpressionCodeFixProvider.cs (1)

107Contract.ThrowIfNull(nextStatement);

src\Analyzers\CSharp\CodeFixes\ConvertSwitchStatementToExpression\ConvertSwitchStatementToExpressionCodeFixProvider.Rewriter.cs (7)

95Contract.ThrowIfNull(_assignmentTarget); 106Contract.ThrowIfFalse(_assignmentTarget is IdentifierNameSyntax); 210Contract.ThrowIfNull(result); 237Contract.ThrowIfNull(armExpression); 279Contract.ThrowIfNull(node.Expression); 285Contract.ThrowIfNull(node.Expression); 294Contract.ThrowIfNull(result);

src\Analyzers\CSharp\CodeFixes\ConvertTypeOfToNameOf\CSharpConvertTypeOfToNameOfCodeFixProvider.cs (1)

37Contract.ThrowIfNull(typeSymbol);

src\Analyzers\CSharp\CodeFixes\ForEachCast\CSharpForEachCastCodeFixProvider.cs (1)

26Contract.ThrowIfNull(result);

src\Analyzers\CSharp\CodeFixes\MakeLocalFunctionStatic\MakeLocalFunctionStaticCodeFixHelper.cs (1)

210Contract.ThrowIfNull(symbolType);

src\Analyzers\CSharp\CodeFixes\MakeStructMemberReadOnly\CSharpMakeStructMemberReadOnlyCodeFixProvider.cs (1)

73Contract.ThrowIfNull(currentAccessorList);

src\Analyzers\CSharp\CodeFixes\NewLines\ArrowExpressionClausePlacement\ArrowExpressionClausePlacementCodeFixProvider.cs (1)

53Contract.ThrowIfTrue(arrowToken.Kind() != SyntaxKind.EqualsGreaterThanToken);

src\Analyzers\CSharp\CodeFixes\NewLines\ConditionalExpressionPlacement\ConditionalExpressionPlacementCodeFixProvider.cs (1)

53Contract.ThrowIfTrue(questionToken.Kind() != SyntaxKind.QuestionToken);

src\Analyzers\CSharp\CodeFixes\UpdateProjectToAllowUnsafe\CSharpUpdateProjectToAllowUnsafeCodeFixProvider.cs (1)

41Contract.ThrowIfNull(compilationOptions);

src\Analyzers\CSharp\CodeFixes\UpgradeProject\CSharpUpgradeProjectCodeFixProvider.cs (2)

91Contract.ThrowIfFalse(LanguageVersionFacts.TryParse(newVersion, out var parsedNewVersion)); 105Contract.ThrowIfFalse(LanguageVersionFacts.TryParse(newVersion, out var parsedNewVersion));

src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpCollectionExpressionRewriter.cs (3)

469Contract.ThrowIfTrue(expressions.Length >= 2 && match.UseSpread); 543Contract.ThrowIfNull(expression.Parent); 810Contract.ThrowIfNull(expression.Parent);

src\Analyzers\CSharp\CodeFixes\UseCollectionInitializer\CSharpUseCollectionInitializerCodeFixProvider_CollectionInitializer.cs (1)

98Contract.ThrowIfNull(expression.Parent);

src\Analyzers\CSharp\CodeFixes\UseCompoundAssignment\CSharpUseCompoundCoalesceAssignmentCodeFixProvider.cs (1)

55Contract.ThrowIfFalse(CSharpUseCompoundCoalesceAssignmentDiagnosticAnalyzer.GetWhenTrueAssignment(

src\Analyzers\CSharp\CodeFixes\UseExplicitArrayInExpressionTree\CSharpUseExplicitArrayInExpressionTreeCodeFixProvider.cs (1)

120Contract.ThrowIfNull(arrayType); // Validated in RegisterCodeFixesAsync

src\Analyzers\CSharp\CodeFixes\UseIndexOrRangeOperator\CSharpUseRangeOperatorCodeFixProvider.cs (2)

137Contract.ThrowIfNull(instance); 250Contract.ThrowIfNull(result.Op2);

src\Analyzers\CSharp\CodeFixes\UseNameofInAttribute\CSharpUseNameofInAttributeCodeFixProvider.cs (1)

45Contract.ThrowIfNull(name);

src\Analyzers\CSharp\CodeFixes\UsePatternMatching\CSharpAsAndMemberAccessCodeFixProvider.cs (2)

62Contract.ThrowIfNull(parent); 135Contract.ThrowIfNull(binaryExpression);

src\Analyzers\CSharp\CodeFixes\UsePrimaryConstructor\CSharpUsePrimaryConstructorCodeFixProvider.cs (3)

453Contract.ThrowIfNull(constructorDeclaration.Body); 470Contract.ThrowIfFalse(member is IFieldSymbol or IPropertySymbol); 522Contract.ThrowIfNull(parameterName);

src\Analyzers\CSharp\CodeFixes\UseUtf8StringLiteral\UseUtf8StringLiteralCodeFixProvider.cs (3)

50Contract.ThrowIfNull(readOnlySpanType); 58Contract.ThrowIfNull(arrayOp.Initializer); 147Contract.ThrowIfFalse(UseUtf8StringLiteralDiagnosticAnalyzer.TryConvertToUtf8String(builder, initializer.ElementValues));

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\CSharpCodeGenerationHelpers.cs (2)

117Contract.ThrowIfNull(syntax); 272Contract.ThrowIfNull(symbol);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\NamedTypeGenerator.cs (1)

234Contract.ThrowIfNull(invokeMethod);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\TypeDeclarationSyntaxExtensions.cs (1)

72Contract.ThrowIfNull(typeNode);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Indentation\CSharpIndentationService.cs (2)

53Contract.ThrowIfNull(formattingRules); 54Contract.ThrowIfNull(root);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Indentation\CSharpIndentationService.Indenter.cs (5)

73Contract.ThrowIfNull(indenter.Tree); 74Contract.ThrowIfTrue(token.Kind() == SyntaxKind.None); 124Contract.ThrowIfNull(interpolatedExpression); 267Contract.ThrowIfNull(nonTerminalNode, @"Malformed code or bug in parser???"); 280Contract.ThrowIfNull(nonTerminalNode, @"Malformed code or bug in parser???");

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpAddImportsService.cs (1)

134Contract.ThrowIfNull(rewritten);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpSyntaxGeneratorInternal.cs (1)

299Contract.ThrowIfNull(expression);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpTypeInferenceService.TypeInferrer.cs (4)

948Contract.ThrowIfTrue(previousToken.HasValue && previousToken.Value != operatorToken); 1116Contract.ThrowIfTrue(previousToken.HasValue && previousToken.Value != coalesceExpression.OperatorToken); 1906Contract.ThrowIfTrue(previousToken.HasValue && previousToken.Value != prefixUnaryExpression.OperatorToken); 1962Contract.ThrowIfTrue(previousToken.HasValue && previousToken.Value != awaitExpression.AwaitKeyword);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\SemanticModelReuse\CSharpSemanticModelReuseLanguageService.cs (2)

31Contract.ThrowIfFalse(accessor.Parent is AccessorListSyntax); 32Contract.ThrowIfFalse(accessor.Parent.Parent is BasePropertyDeclarationSyntax);