Contract

Classification\SyntaxClassification\SyntacticChangeRangeComputer.cs (7)

101Contract.ThrowIfTrue(commonLeftWidth > oldRootWidth); 102Contract.ThrowIfTrue(commonLeftWidth > newRootWidth); 103Contract.ThrowIfTrue(commonRightWidth > oldRootWidth); 104Contract.ThrowIfTrue(commonRightWidth > newRootWidth); 135Contract.ThrowIfFalse(currentOld.FullSpan.Start == currentNew.FullSpan.Start); 178Contract.ThrowIfTrue(oldRoot.IsIncrementallyIdenticalTo(newRoot)); 190Contract.ThrowIfFalse((oldRoot.FullSpan.End - currentOld.FullSpan.End) ==

CodeActions\CodeAction.cs (1)

199Contract.ThrowIfFalse(provider is CodeFixProvider or CodeRefactoringProvider);

CodeActions\CodeAction_Cleanup.cs (2)

74Contract.ThrowIfFalse(document.SupportsSyntaxTree); 210Contract.ThrowIfFalse(document.SupportsSyntaxTree, "GetDocumentIdsAndOptionsAsync should only be returning documents that support syntax");

CodeCleanup\AbstractCodeCleanerService.cs (7)

213Contract.ThrowIfFalse(hasMultiplePreviousToken || hasMultipleNextToken); 239Contract.ThrowIfTrue(spanMarkerType == SpanMarkerType.EndOfFile); 240Contract.ThrowIfTrue(previousToken.RawKind == 0); 255Contract.ThrowIfTrue(spanMarkerType == SpanMarkerType.BeginningOfFile); 256Contract.ThrowIfTrue(nextToken.RawKind == 0); 371Contract.ThrowIfTrue(startToken.RawKind == 0 || endToken.RawKind == 0); 668Contract.ThrowIfNull(annotation.Data);

CodeFixes\FixAllOccurrences\BatchFixAllProvider.cs (1)

56Contract.ThrowIfFalse(fixAllContext.Scope is FixAllScope.Document or

CodeFixes\FixAllOccurrences\FixAllContext.cs (1)

311Contract.ThrowIfNull(project);

CodeFixesAndRefactorings\DocumentBasedFixAllProviderHelpers.cs (1)

76Contract.ThrowIfFalse(

CodeFixesAndRefactorings\FixAllLogger.cs (1)

94Contract.ThrowIfTrue(completed && timedOut);

CodeRefactorings\FixAllOccurences\DocumentBasedFixAllProvider.cs (1)

84Contract.ThrowIfFalse(fixAllContext.Scope is FixAllScope.Document or FixAllScope.Project

CodeRefactorings\FixAllOccurences\FixAllState.cs (2)

96Contract.ThrowIfNull(Document); 107Contract.ThrowIfNull(Document);

Diagnostics\AnalysisResultPair.cs (6)

21Contract.ThrowIfTrue(projectAnalysisResult is null && hostAnalysisResult is null); 43Contract.ThrowIfNull(arg.hostDiagnostics); 68Contract.ThrowIfNull(arg.hostDiagnostics); 93Contract.ThrowIfNull(arg.hostDiagnostics); 118Contract.ThrowIfNull(arg.hostDiagnostics); 143Contract.ThrowIfNull(arg.hostTelemetryInfo);

Diagnostics\CompilationWithAnalyzersPair.cs (3)

22Contract.ThrowIfFalse(projectCompilationWithAnalyzers.AnalysisOptions.ReportSuppressedDiagnostics == hostCompilationWithAnalyzers.AnalysisOptions.ReportSuppressedDiagnostics); 23Contract.ThrowIfFalse(projectCompilationWithAnalyzers.AnalysisOptions.ConcurrentAnalysis == hostCompilationWithAnalyzers.AnalysisOptions.ConcurrentAnalysis); 27Contract.ThrowIfTrue(projectCompilationWithAnalyzers is null && hostCompilationWithAnalyzers is null);

Diagnostics\DiagnosticAnalysisResult.cs (1)

135Contract.ThrowIfNull(map);

Diagnostics\DiagnosticAnalysisResultBuilder.cs (1)

45Contract.ThrowIfTrue(Project.SupportsCompilation);

Diagnostics\DiagnosticDataLocation.cs (1)

62Contract.ThrowIfNull(unmappedFileSpan.Path);

Diagnostics\DocumentAnalysisScope.cs (1)

56Contract.ThrowIfFalse(TextDocument is AdditionalDocument);

Diagnostics\HostDiagnosticAnalyzers.cs (1)

182Contract.ThrowIfNull(language);

Editing\SyntaxEditor.cs (2)

253Contract.Fail($"GetCurrentNode returned null with the following node: {OriginalNode}"); 285Contract.ThrowIfNull(node);

Editing\SyntaxGenerator.cs (4)

1022Contract.ThrowIfNull(attribute.AttributeClass); 1387Contract.ThrowIfTrue(ReferenceEquals(root, node)); 1538Contract.ThrowIfNull(currentFirst); 1920Contract.ThrowIfNull(name);

ErrorReporting\InfoBarUI.cs (1)

19Contract.ThrowIfNull(title);

FindSymbols\Declarations\DeclarationFinder.cs (3)

28Contract.ThrowIfTrue(query.Kind == SearchKind.Custom, "Custom queries are not supported in this API"); 78Contract.ThrowIfTrue(query.Kind == SearchKind.Custom, "Custom queries are not supported in this API"); 85Contract.ThrowIfNull(info);

FindSymbols\Declarations\DeclarationFinder_AllDeclarations.cs (2)

28Contract.ThrowIfTrue(query.Kind == SearchKind.Custom, "Custom queries are not supported in this API"); 33Contract.ThrowIfNull(query.Name);

FindSymbols\FindLiterals\FindLiteralsSearchEngine.cs (2)

122Contract.ThrowIfNull(index); 125Contract.ThrowIfNull(_stringValue);

FindSymbols\FindReferences\DependentProjectsFinder.cs (4)

311Contract.ThrowIfNull(symbolOrigination.assembly); 312Contract.ThrowIfNull(project); 313Contract.ThrowIfFalse(project.SupportsCompilation); 326Contract.ThrowIfFalse(project.SupportsCompilation);

FindSymbols\FindReferences\DependentTypeFinder.cs (1)

348Contract.ThrowIfNull(symbolTreeInfo);

FindSymbols\FindReferences\Finders\AbstractReferenceFinder.cs (1)

592Contract.ThrowIfFalse(notNullOriginalUnreducedSymbol2.GetOriginalUnreducedDefinition().Equals(notNullOriginalUnreducedSymbol2));

FindSymbols\FindReferences\Finders\AbstractTypeParameterSymbolReferenceFinder.cs (1)

61Contract.ThrowIfNull(token.Parent);

FindSymbols\FindReferences\Finders\ExplicitConversionSymbolReferenceFinder.cs (1)

47Contract.ThrowIfNull(underlyingNamedType);

FindSymbols\FindReferences\Finders\MethodTypeParameterSymbolReferenceFinder.cs (1)

61Contract.ThrowIfNull(symbol.DeclaringMethod);

FindSymbols\FindReferences\FindReferencesSearchEngine.cs (3)

187Contract.ThrowIfFalse(linkedSymbols.Contains(symbol), "Linked symbols did not contain the very symbol we started with."); 190Contract.ThrowIfFalse(group.Symbols.Contains(symbol), "Symbol group did not contain the very symbol we started with."); 197Contract.ThrowIfFalse(symbolToGroup.ContainsKey(symbol));

FindSymbols\FindReferences\FindReferencesSearchEngine.SymbolSet.cs (2)

129Contract.ThrowIfNull(searchSymbol); 241Contract.ThrowIfFalse(projects.Count == 1, "Only a single project should be passed in");

FindSymbols\IStreamingFindReferencesProgress.cs (1)

35Contract.ThrowIfTrue(symbols.IsDefaultOrEmpty, "Symbols should be non empty");

FindSymbols\Shared\AbstractSyntaxIndex.cs (3)

33Contract.ThrowIfNull(index); 58Contract.ThrowIfFalse(index != null || loadOnly == true, "Result can only be null if 'loadOnly: true' was passed."); 122Contract.ThrowIfFalse(document.SupportsSyntaxTree);

FindSymbols\SymbolFinder.FindReferencesServerCallback.cs (1)

42Contract.ThrowIfTrue(dehydrated.Symbols.Count == 0);

FindSymbols\SymbolFinder_Helpers.cs (5)

124Contract.ThrowIfNull(equivalentTypesWithDifferingAssemblies); 125Contract.ThrowIfTrue(equivalentTypesWithDifferingAssemblies.Count == 0); 128Contract.ThrowIfFalse(equivalentTypesWithDifferingAssemblies.All(kvp => !SymbolEquivalenceComparer.Instance.Equals(kvp.Key.ContainingAssembly, kvp.Value.ContainingAssembly))); 131Contract.ThrowIfFalse(equivalentTypesWithDifferingAssemblies.All(kvp => kvp.Key.ContainingType == null)); 132Contract.ThrowIfFalse(equivalentTypesWithDifferingAssemblies.All(kvp => kvp.Value.ContainingType == null));

FindSymbols\SymbolTree\MetadataInfo.cs (1)

30Contract.ThrowIfNull(info);

FindSymbols\SymbolTree\SymbolTreeInfo.cs (4)

124Contract.ThrowIfTrue(query.Kind == SearchKind.Custom, "Custom queries are not supported in this API"); 136Contract.ThrowIfTrue(query.Kind == SearchKind.Custom, "Custom queries are not supported in this API"); 148Contract.ThrowIfTrue(query.Kind == SearchKind.Custom, "Custom queries are not supported in this API"); 154Contract.ThrowIfNull(queryName);

FindSymbols\SymbolTree\SymbolTreeInfo_Metadata.cs (1)

136Contract.ThrowIfTrue(info.Checksum != checksum, "How could the info stored for a particular PEReference now have a different checksum?");

FindSymbols\SymbolTree\SymbolTreeInfo_Serialization.cs (1)

57Contract.ThrowIfNull(result);

FindSymbols\SymbolTree\SymbolTreeInfoCacheService.cs (4)

180Contract.ThrowIfNull(info); 181Contract.ThrowIfTrue(info.Checksum != checksum, "If we computed a SymbolTreeInfo, then its checksum must match our checksum."); 202Contract.ThrowIfNull(info); 203Contract.ThrowIfTrue(info.Checksum != checksum, "If we computed a SymbolTreeInfo, then its checksum must match our checksum.");

FindSymbols\SyntaxTree\SyntaxTreeIndex_Create.cs (1)

90Contract.ThrowIfNull(node);

FindSymbols\TopLevelSyntaxTree\DeclaredSymbolInfo.cs (2)

129Contract.ThrowIfTrue((uint)accessibility > Max4BitValue); 130Contract.ThrowIfTrue((uint)kind > Max5BitValue);

Formatting\AbstractFormattingService.cs (1)

19Contract.ThrowIfNull(syntaxFormattingOptions);

Formatting\Formatter.cs (1)

137Contract.ThrowIfNull(formattingOptions);

LanguageServices\FixAllSpanMappingService\AbstractFixAllSpanMappingService.cs (2)

26Contract.ThrowIfFalse(fixAllScope is FixAllScope.ContainingMember or FixAllScope.ContainingType); 54Contract.ThrowIfNull(documentForLocation);

LinkedFileDiffMerging\LinkedFileDiffMergingSession.cs (4)

36Contract.ThrowIfNull(filePath); 56Contract.ThrowIfTrue(newDocumentsAndHashes.Count == 0); 62Contract.ThrowIfTrue(relatedDocuments.Length == 1, "We should have skipped non-linked files in the prior loop."); 95Contract.ThrowIfTrue(newDocumentsAndHashes.Count < 2);

Options\DocumentOptionSet.cs (1)

78Contract.ThrowIfTrue(internallyDefinedOption.Type == typeof(NamingStylePreferences));

PatternMatching\PatternMatcher.cs (1)

152Contract.ThrowIfTrue(patternChunk.SimilarityChecker.IsDefault);

Remote\ExportRemoteServiceCallbackDispatcherAttribute.cs (1)

19Contract.ThrowIfFalse(serviceInterface.IsInterface);

Remote\IRemoteKeepAliveService.cs (1)

73Contract.Fail("Should have been disposed!");

Remote\RemoteArguments.cs (1)

63Contract.ThrowIfNull(project, WorkspacesResources.Symbols_project_could_not_be_found_in_the_provided_solution);

Remote\RemoteServiceCallbackDispatcher.cs (2)

25Contract.ThrowIfTrue(callbackInstances?.TryRemove(Id, out _) == false); 47Contract.ThrowIfFalse(_callbackInstances.TryGetValue(callbackId, out var instance));

Remote\RemoteServiceCallbackDispatchers.cs (1)

24Contract.ThrowIfNull(serviceInterface);

Rename\ConflictEngine\ConflictResolver.cs (6)

184Contract.ThrowIfNull(implicitUsageConflict.SourceTree); 208Contract.ThrowIfNull(implicitConflict.SourceTree); 235Contract.ThrowIfNull(projectOpt); 287Contract.ThrowIfNull(projectOpt); 302Contract.ThrowIfNull(languageConflict.SourceTree); 329Contract.ThrowIfNull(oldLocation.SourceTree);

Rename\ConflictEngine\ConflictResolver.Session.cs (1)

157Contract.ThrowIfTrue(conflictLocations.Count != 0, "We're the first phase, so we should have no conflict locations yet");

Rename\ConflictEngine\MutableConflictResolution.cs (2)

108Contract.ThrowIfNull(directory); 186Contract.ThrowIfFalse(_options.RenameInSourceGeneratedDocuments);

Rename\IRemoteRenamerService.cs (2)

117Contract.ThrowIfNull(serializableLocations); 184Contract.ThrowIfNull(Resolution);

Rename\LightweightRenameLocations.cs (5)

39Contract.ThrowIfTrue(locations.IsDefault); 40Contract.ThrowIfTrue(implicitLocations.IsDefault); 41Contract.ThrowIfTrue(referencedSymbols.IsDefault); 75Contract.ThrowIfNull(solution); 76Contract.ThrowIfNull(symbol);

Rename\Renamer.cs (6)

149Contract.ThrowIfNull(solution); 150Contract.ThrowIfNull(symbol); 151Contract.ThrowIfTrue(string.IsNullOrEmpty(newName)); 191Contract.ThrowIfNull(solution); 192Contract.ThrowIfNull(symbol); 193Contract.ThrowIfTrue(string.IsNullOrEmpty(newName));

Rename\RenameUtilities.cs (4)

101Contract.ThrowIfFalse(isSubset); 307Contract.ThrowIfNull(definitionSymbol); 318Contract.ThrowIfNull(symbol); 319Contract.ThrowIfNull(solution);

Rename\SymbolicRenameLocations.cs (4)

42Contract.ThrowIfTrue(locations.IsDefault); 43Contract.ThrowIfTrue(implicitLocations.IsDefault); 44Contract.ThrowIfTrue(referencedSymbols.IsDefault); 60Contract.ThrowIfNull(symbol);

Rename\SymbolicRenameLocations.ReferenceProcessing.cs (2)

274Contract.ThrowIfNull(aliasLocation.SourceTree); 297Contract.ThrowIfNull(aliasLocation.SourceTree);

Rename\SymbolicRenameLocations.SearchResult.cs (1)

23Contract.ThrowIfNull(locations);

Serialization\SerializableSourceText.cs (1)

179Contract.ThrowIfFalse(kind is SerializationKinds.Bits or SerializationKinds.MemoryMapFile);

Serialization\SerializedPortableExecutableReference.cs (1)

35Contract.ThrowIfTrue(storageHandles.IsDefault);

Serialization\SerializerService.cs (2)

206Contract.ThrowIfFalse(count <= 2); 214Contract.ThrowIfFalse(language is LanguageNames.CSharp or LanguageNames.VisualBasic);

Serialization\SerializerService_Reference.cs (10)

78Contract.ThrowIfFalse(TryGetAnalyzerImageReferenceGuid(analyzerImageReference, out var guid), "AnalyzerImageReferences are only supported during testing"); 153Contract.ThrowIfFalse(TryGetAnalyzerImageReferenceGuid(analyzerImageReference, out var guid), "AnalyzerImageReferences are only supported during testing"); 175Contract.ThrowIfFalse(TryGetAnalyzerImageReferenceFromGuid(guid, out var analyzerImageReference)); 283Contract.ThrowIfFalse(kind is SerializationKinds.Bits or SerializationKinds.MemoryMapFile); 363Contract.ThrowIfTrue(handles.Count == 0); 400Contract.ThrowIfFalse(metadataKind == MetadataImageKind.Module); 412Contract.ThrowIfFalse(metadataKind == MetadataImageKind.Module); 422Contract.ThrowIfFalse(kind is SerializationKinds.Bits or SerializationKinds.MemoryMapFile); 446Contract.ThrowIfTrue(length != storageHandle.Identifier.Size); 460Contract.ThrowIfFalse(storageHandle.Identifier.Size == unmanagedStream.Length);

Shared\Extensions\DocumentExtensions.cs (1)

17Contract.ThrowIfNull(result);

Shared\Extensions\FileLinePositionSpanExtensions.cs (2)

88Contract.ThrowIfTrue(start < text.Lines.GetLinePosition(0)); 89Contract.ThrowIfTrue(end > text.Lines.GetLinePosition(text.Length));

Shared\Extensions\IMethodSymbolExtensions.cs (1)

17Contract.ThrowIfFalse(delegateType.TypeKind == TypeKind.Delegate);

Shared\Extensions\ISymbolExtensions.cs (1)

363Contract.ThrowIfNull(candidate);

Shared\Extensions\SourceTextExtensions.cs (9)

Shared\Extensions\TelemetryExtensions.cs (1)

18Contract.ThrowIfNull(type.FullName);

Shared\TestHooks\AsynchronousOperationListener.cs (3)

113Contract.ThrowIfFalse(_gate.LockHeldByMe()); 119Contract.ThrowIfFalse(_gate.LockHeldByMe()); 184Contract.ThrowIfFalse(TrackActiveTokens);

Shared\Utilities\BloomFilter_Serialization.cs (1)

28Contract.ThrowIfTrue(bitArray.Length % 8 != 0);

Shared\Utilities\ExtensionOrderer.Graph.cs (1)

20Contract.ThrowIfNull(name);

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

62Contract.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\Options\PublicOptionFactory.cs (4)

89Contract.ThrowIfNull(option.PublicOption); 95Contract.ThrowIfNull(option.PublicOption); 101Contract.ThrowIfNull(option.PublicOption); 107Contract.ThrowIfNull(option.PublicOption);

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)

558Contract.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\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);

Storage\SQLite\v2\Interop\SqlConnection.cs (2)

55Contract.ThrowIfFalse(wrote == length); 316Contract.ThrowIfFalse(MemoryMarshal.TryRead(bytes, out Checksum result));

Storage\SQLite\v2\Interop\SqlStatement.cs (1)

90Contract.ThrowIfFalse(Encoding.UTF8.GetBytes(charsPtr, value.Length, bytesPtr, utf8ByteCount) == utf8ByteCount);

Storage\SQLite\v2\SQLitePersistentStorage.Accessor.cs (6)

152Contract.ThrowIfTrue(optional.HasValue && optional.Value == null); 166Contract.ThrowIfFalse(TaskScheduler.Current == this.Storage.Scheduler.ConcurrentScheduler); 225Contract.ThrowIfFalse(TaskScheduler.Current == this.Storage.Scheduler.ExclusiveScheduler); 290Contract.ThrowIfTrue(exception != null); 307Contract.ThrowIfTrue(exception != null); 364Contract.ThrowIfFalse(TaskScheduler.Current == this.Storage.Scheduler.ExclusiveScheduler);

Storage\SQLite\v2\SQLitePersistentStorage.cs (3)

101Contract.ThrowIfNull(solutionKey.FilePath); 149Contract.ThrowIfNull(directoryName); 159Contract.ThrowIfNull(directory);

Storage\SQLite\v2\SQLitePersistentStorage_FlushWrites.cs (1)

35Contract.ThrowIfFalse(TaskScheduler.Current == this.Scheduler.ExclusiveScheduler);

Storage\SQLite\v2\SQLitePersistentStorage_StringIds.cs (3)

48Contract.ThrowIfFalse( 67Contract.ThrowIfFalse(TaskScheduler.Current == this.Scheduler.ExclusiveScheduler); 133Contract.ThrowIfTrue(id == -1);

Storage\SQLite\v2\SQLitePersistentStorageService.cs (1)

63Contract.ThrowIfTrue(string.IsNullOrWhiteSpace(workingFolderPath));

TemporaryStorage\TemporaryStorageService.cs (2)

177Contract.ThrowIfNull(storageIdentifier.Name, $"{nameof(GetStreamHandle)} should only be called for VS on Windows (where named memory mapped files as supported)"); 188Contract.ThrowIfNull(storageIdentifier.Name, $"{nameof(GetTextHandle)} should only be called for VS on Windows (where named memory mapped files as supported)");

Utilities\Documentation\XmlDocumentationProvider.cs (2)

105Contract.ThrowIfNull(xmlDocCommentBytes); 153Contract.ThrowIfNull(filePath);

Workspace\DocumentActiveContextChangedEventArgs.cs (4)

19Contract.ThrowIfNull(solution); 20Contract.ThrowIfNull(sourceTextContainer); 21Contract.ThrowIfNull(oldActiveContextDocumentId); 22Contract.ThrowIfNull(newActiveContextDocumentId);

Workspace\DocumentEventArgs.cs (1)

15Contract.ThrowIfNull(document);

Workspace\Host\DocumentService\AbstractSpanMappingService.cs (1)

32Contract.ThrowIfFalse(mappedSpanResults.Length == textChanges.Length);

Workspace\Host\PersistentStorage\IPersistentStorageConfiguration.cs (1)

53Contract.ThrowIfNull(fileName);

Workspace\ProjectSystem\FileWatchedPortableExecutableReferenceFactory.cs (1)

160Contract.ThrowIfFalse(newRefCount >= 0, "Ref count cannot be negative");

Workspace\ProjectSystem\ProjectSystemProject.BatchingDocumentCollection.cs (4)

212Contract.ThrowIfNull(documentInfo.FilePath); 495Contract.ThrowIfNull(fileInfo, "We previously received a dynamic file for this path, and we're responding to a change, so we expect to get a new one."); 600Contract.ThrowIfNull(documentInfo.FilePath, "We shouldn't be adding documents without file paths."); 636Contract.ThrowIfTrue(folders.IsDefault);

Workspace\ProjectSystem\ProjectSystemProject.cs (4)

790Contract.ThrowIfTrue(analyzersRemoved.Count == 0 && analyzersAdded.Count == 0, "Should only be called when there is work to do"); 974Contract.ThrowIfNull(providerForFileInfo); 1413Contract.ThrowIfNull(originalMetadataReferences); 1414Contract.ThrowIfNull(originalAnalyzerReferences);

Workspace\ProjectSystem\ProjectSystemProjectFactory.cs (11)

Workspace\ProjectSystem\ProjectSystemProjectOptionsProcessor.cs (1)

203Contract.ThrowIfNull(sender);

Workspace\Solution\Checksum.cs (2)

57Contract.ThrowIfFalse(MemoryMarshal.TryRead(checksum, out Checksum result)); 88Contract.ThrowIfTrue(span.Length < HashSize);

Workspace\Solution\ChecksumCollection.cs (3)

70Contract.ThrowIfFalse(state.TryGetStateChecksums(out var stateChecksums)); 82Contract.ThrowIfFalse(state.TryGetStateChecksums(out var stateChecksums)); 97Contract.ThrowIfFalse(values.Count == checksums.Children.Length);

Workspace\Solution\ChecksumsAndIds.cs (3)

23Contract.ThrowIfTrue(ids.Length != checksums.Children.Length); 75Contract.ThrowIfTrue(ids.Length != attributeChecksums.Children.Length); 76Contract.ThrowIfTrue(ids.Length != textChecksums.Children.Length);

Workspace\Solution\Document.cs (2)

356Contract.ThrowIfNull(result); 596Contract.ThrowIfNull(_cachedOptions);

Workspace\Solution\DocumentState.cs (8)

47Contract.ThrowIfFalse(ParseOptions is null == TreeSource is null); 72Contract.ThrowIfNull(options); 172Contract.ThrowIfNull(tree); 244Contract.ThrowIfNull(newTree); 339Contract.ThrowIfFalse(SupportsSyntaxTree); 401Contract.ThrowIfTrue(ReferenceEquals(newAttributes, Attributes)); 515Contract.ThrowIfNull(ParseOptions); 661Contract.ThrowIfFalse(existingId == id);

Workspace\Solution\DocumentState_LinkedFileReuse.cs (1)

78Contract.ThrowIfNull(siblingTreeSource);

Workspace\Solution\Project.cs (2)

38Contract.ThrowIfNull(solution); 39Contract.ThrowIfNull(projectState);

Workspace\Solution\ProjectCone.cs (1)

21Contract.ThrowIfFalse(projectIds.Contains(rootProjectId));

Workspace\Solution\ProjectDependencyGraph.cs (3)

100Contract.ThrowIfNull(transitiveReferencesMap); 101Contract.ThrowIfNull(reverseTransitiveReferencesMap); 137Contract.ThrowIfFalse(ProjectIds.Contains(projectId));

Workspace\Solution\ProjectDependencyGraph_AddProjectReference.cs (1)

17Contract.ThrowIfFalse(ProjectIds.Contains(projectId));

Workspace\Solution\ProjectDependencyGraph_RemoveAllProjectReferences.cs (1)

16Contract.ThrowIfFalse(ProjectIds.Contains(projectId));

Workspace\Solution\ProjectDependencyGraph_RemoveProject.cs (1)

20Contract.ThrowIfFalse(projectIdsBuilder.Remove(projectId));

Workspace\Solution\ProjectDependencyGraph_RemoveProjectReference.cs (2)

16Contract.ThrowIfFalse(ProjectIds.Contains(projectId)); 17Contract.ThrowIfFalse(_referencesMap[projectId].Contains(referencedProjectId));

Workspace\Solution\ProjectReference.cs (1)

21Contract.ThrowIfNull(projectId);

Workspace\Solution\ProjectState.cs (7)

82Contract.ThrowIfNull(projectInfo); 83Contract.ThrowIfNull(languageServices); 372Contract.ThrowIfNull(projectDirectory); 982Contract.ThrowIfTrue(oldDocuments.IsEmpty); 983Contract.ThrowIfFalse(oldDocuments.Length == newDocuments.Length); 1008Contract.ThrowIfTrue(oldDocuments.IsEmpty); 1009Contract.ThrowIfFalse(oldDocuments.Length == newDocuments.Length);

Workspace\Solution\Solution.cs (7)

95Contract.ThrowIfTrue(this.WorkspaceKind == CodeAnalysis.WorkspaceKind.RemoteWorkspace, "Access .Workspace off of a RemoteWorkspace Solution is not supported."); 168Contract.ThrowIfNull(state); 262Contract.ThrowIfNull(documentId); 277Contract.ThrowIfNull(documentId); 339Contract.ThrowIfNull(generatedDocument, "The call to GetDocumentState found a SourceGeneratedDocumentState, so we should have found it now."); 1560Contract.ThrowIfTrue(solution._documentIdToFrozenSolution.Count != 0); 1641Contract.ThrowIfNull(newDocumentState, "Because we just froze this document, it should always exist.");

Workspace\Solution\SolutionCompilationState.CompilationTracker.CompilationTrackerState.cs (5)

94Contract.ThrowIfTrue(pendingTranslationActions is null); 105Contract.ThrowIfTrue(this.CompilationWithoutGeneratedDocuments.SyntaxTrees.Contains(generatedDocument.GetSyntaxTree(CancellationToken.None))); 182Contract.ThrowIfNull(finalCompilationWithGeneratedDocuments); 205Contract.ThrowIfTrue(compilationWithoutGeneratedDocuments.SyntaxTrees.Contains(generatedDocument.GetSyntaxTree(CancellationToken.None))); 272Contract.ThrowIfNull(projectId);

Workspace\Solution\SolutionCompilationState.cs (8)

77Contract.ThrowIfTrue(projectCone != null); 107Contract.ThrowIfTrue(_projectIdToTrackerMap.Any(kvp => kvp.Key != kvp.Value.ProjectState.Id)); 110Contract.ThrowIfFalse(this.SolutionState.SortedProjectStates 1159Contract.ThrowIfNull(projectState); 1364Contract.ThrowIfFalse(trackerMap.TryGetValue(projectId, out var existingTracker)); 1395Contract.ThrowIfTrue(sourceText is null && syntaxNode is null); 1396Contract.ThrowIfTrue(sourceText is not null && syntaxNode is not null); 1411Contract.ThrowIfNull(syntaxNode);

Workspace\Solution\SolutionCompilationState.RegularCompilationTracker.cs (8)

64Contract.ThrowIfNull(project); 136Contract.ThrowIfTrue(forkedTrackerState is FinalCompilationTrackerState); 137Contract.ThrowIfFalse(forkedTrackerState is null or InProgressState); 206Contract.ThrowIfNull(compilation); 407Contract.ThrowIfTrue(inProgressState.PendingTranslationActions.IsEmpty); 478Contract.ThrowIfTrue(inProgressState.PendingTranslationActions.Count > 0); 543Contract.ThrowIfFalse(creationPolicy.SkeletonReferenceCreationPolicy is SkeletonReferenceCreationPolicy.CreateIfAbsent or SkeletonReferenceCreationPolicy.DoNotCreate); 996/// This is just the same as <see cref="Contract.ThrowIfFalse(bool, string, int, string)"/> but throws a custom exception type to make this easier to find in telemetry since the exception type

Workspace\Solution\SolutionCompilationState.RegularCompilationTracker_Generators.cs (11)

Workspace\Solution\SolutionCompilationState.SymbolToProjectId.cs (1)

83Contract.ThrowIfNull(syntaxTree);

Workspace\Solution\SolutionCompilationState.TranslationAction_Actions.cs (1)

244Contract.ThrowIfNull(this.NewProjectState.CompilationOptions);

Workspace\Solution\SolutionCompilationState_Checksum.cs (2)

73Contract.ThrowIfNull(projectId); 83Contract.ThrowIfNull(projectCone);

Workspace\Solution\SolutionCompilationState_SourceGenerators.cs (2)

69Contract.ThrowIfFalse(projectState.SupportsCompilation); 75Contract.ThrowIfNull(map);

Workspace\Solution\SolutionState.cs (10)

Workspace\Solution\SolutionState_Checksum.cs (1)

67Contract.ThrowIfNull(projectId);

Workspace\Solution\SourceGeneratedDocumentIdentity.cs (1)

28Contract.ThrowIfFalse(documentId.IsSourceGenerated);

Workspace\Solution\SourceGeneratedDocumentState.cs (3)

62Contract.ThrowIfTrue(generatedSourceText is null && syntaxNode is null); 63Contract.ThrowIfTrue(generatedSourceText is not null && syntaxNode is not null); 68Contract.ThrowIfNull(syntaxNode);

Workspace\Solution\StateChecksums.cs (11)

Workspace\Solution\TextDocument.cs (2)

26Contract.ThrowIfNull(project); 27Contract.ThrowIfNull(state);

Workspace\Solution\TextDocumentStates.cs (1)

227Contract.ThrowIfTrue(!ignoreUnchangedContent && ignoreUnchangeableDocuments);

Workspace\Solution\VersionSource\LoadableTextAndVersionSource.cs (1)

88Contract.ThrowIfTrue(_gate.CurrentCount != 0);

Workspace\Solution\VersionSource\RecoverableTextAndVersion.cs (4)

160Contract.ThrowIfTrue(source is LoadableTextAndVersionSource { CacheResult: true }); 173Contract.ThrowIfNull(_storageHandle); 183Contract.ThrowIfNull(_storageHandle); 193Contract.ThrowIfFalse(_storageHandle == null); // Cannot save more than once

Workspace\Solution\VersionSource\RecoverableTextAndVersion.RecoverableText.cs (1)

130Contract.ThrowIfTrue(Gate.CurrentCount != 0);

Workspace\TextExtensions.cs (1)

89Contract.ThrowIfFalse(solution.ContainsAnalyzerConfigDocument(id));

Workspace\Workspace.cs (6)

354Contract.ThrowIfTrue(relatedDocumentId == addedDocumentId); 357Contract.ThrowIfTrue(relatedDocumentId.ProjectId == addedDocumentId.ProjectId); 507Contract.ThrowIfNull(transformation); 1357Contract.ThrowIfNull(newDocument); 1730Contract.ThrowIfNull(projectChanges.OldProject.CompilationOptions); 1731Contract.ThrowIfNull(projectChanges.NewProject.CompilationOptions);

Workspace\Workspace_Editor.cs (7)

272Contract.ThrowIfNull(currentContextId, "The document is open, so we should have had some context ID."); 474Contract.ThrowIfFalse(_openSourceGeneratedDocumentIdentities.Remove(document.Id)); 801Contract.ThrowIfFalse(_bufferToDocumentInCurrentContextMap.ContainsKey(textContainer)); 809Contract.ThrowIfFalse(!_bufferToDocumentInCurrentContextMap.ContainsKey(textContainer)); 827Contract.ThrowIfFalse(!_bufferToDocumentInCurrentContextMap.ContainsKey(textContainer)); 831Contract.ThrowIfFalse(_bufferToDocumentInCurrentContextMap.ContainsKey(textContainer)); 855Contract.ThrowIfFalse(doc.TryGetText(out var text));