222ImmutableArray.Create<PropertySetAbstractValueKind>( 503ImmutableArray.Create<PropertySetAbstractValueKind>( 988ImmutableArray.Create<PropertySetAbstractValueKind>( 1084ImmutableArray.Create<PropertySetAbstractValueKind>( 1229defaultReferences = defaultReferences.AddPackages(ImmutableArray.Create(new PackageIdentity("System.DirectoryServices", "6.0.1")));

370var symbolNames = ImmutableArray.Create(patternName);

34ImmutableArray.Create(new HealthReportViewModel("Null", null, "Description1", null))), 76ImmutableArray.Create(new HealthReportViewModel("Healthy", HealthStatus.Healthy, "Description2", null)))) 123ImmutableArray.Create(new HealthReportViewModel("Null", null, "Description1", null))), 128ImmutableArray.Create(new HealthReportViewModel("Healthy", HealthStatus.Healthy, "Description2", null))), 133ImmutableArray.Create(new HealthReportViewModel("Degraded", HealthStatus.Degraded, "Description3", null))), 185ImmutableArray.Create(new HealthReportViewModel("Null", null, "Description1", null))),

23public static readonly ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics = ImmutableArray.Create(

134aliases: metadataReferenceInfo.ExternAlias is null ? ImmutableArray<string>.Empty : ImmutableArray.Create(metadataReferenceInfo.ExternAlias),

165case 1: return ImmutableArray.Create(span[0]);

368ImmutableArray.Create(name));

281return ImmutableArray.Create<V>((V)_value);

854? ImmutableArray.Create(symbol) 855: ImmutableArray<TNamespaceOrTypeSymbol>.CastUp(ImmutableArray.Create((TNamedTypeSymbol)symbol));

186=> HasOneItem ? ImmutableArray.Create(_one) : _many;

3131 => ImmutableArray.Create(_item0),

567dictionary1.Add(keySelector(value), ImmutableArray.Create(value));

88return ImmutableArray.Create(operation);

65var diagnostics = ImmutableArray.Create(diagnostic ?? context.Diagnostics[0]);

41return ImmutableDictionary.CreateRange([KeyValuePair.Create(document, ImmutableArray.Create(decl.FullSpan))]); 67return ImmutableDictionary.CreateRange([KeyValuePair.Create(document, ImmutableArray.Create(decl.FullSpan))]);

80var parameters = ImmutableArray.Create(CodeGenerationSymbolFactory.CreateParameterSymbol(

60incrementalAnalyzerNames: ImmutableArray.Create(AnalyzerName));

20public static ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(DiagnosticDescriptors.GetDiagnosticDescriptor(DiagnosticId.RequiresDynamicCode));

20public static ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(DiagnosticDescriptors.GetDiagnosticDescriptor(DiagnosticId.RequiresUnreferencedCode));

25public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(s_correctnessOfCOMCannotBeGuaranteed);

153case 1: return ImmutableArray.Create(span[0]);

526HandleMethodCallHelper(addMethod, instanceValue, ImmutableArray.Create(value), operation, state); 534HandleMethodCallHelper(removeMethod, instanceValue, ImmutableArray.Create(value), operation, state); 765return HandleMethodCallHelper(getMethod, instanceValue, ImmutableArray.Create(indexArgumentValue), operation, state);

168ImmutableArray.Create<Action<CompilationAnalysisContext>>((context) =>

82ImmutableArray.Create<Action<CompilationAnalysisContext>>((context) =>

281return ImmutableArray.Create<V>((V)_value);

854? ImmutableArray.Create(symbol) 855: ImmutableArray<TNamespaceOrTypeSymbol>.CastUp(ImmutableArray.Create((TNamedTypeSymbol)symbol));

186=> HasOneItem ? ImmutableArray.Create(_one) : _many;

3131 => ImmutableArray.Create(_item0),

567dictionary1.Add(keySelector(value), ImmutableArray.Create(value));

88return ImmutableArray.Create(operation);

281return ImmutableArray.Create<V>((V)_value);

854? ImmutableArray.Create(symbol) 855: ImmutableArray<TNamespaceOrTypeSymbol>.CastUp(ImmutableArray.Create((TNamedTypeSymbol)symbol));

186=> HasOneItem ? ImmutableArray.Create(_one) : _many;

3131 => ImmutableArray.Create(_item0),

567dictionary1.Add(keySelector(value), ImmutableArray.Create(value));

88return ImmutableArray.Create(operation);

16public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(

16public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(

50public override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(DiagDescriptors.LegacyLogging.Id);

18public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(DiagDescriptors.ConditionalAccess);

50public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(DiagDescriptors.MakeExeTypesInternal);

22public override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(DiagDescriptors.MakeExeTypesInternal.Id);

17public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(DiagDescriptors.UsingToStringInLoggers);

257var analyzers = ImmutableArray.Create(analyzer); 329var analyzers = ImmutableArray.Create(analyzer); 440var diagsProvider = new TestDiagnosticProvider(proj, ImmutableArray.Create(analyzer), fixer);

21private static readonly ImmutableArray<DiagnosticDescriptor> _supportedDiagnostics = ImmutableArray.Create(DiagDescriptors.InternalReferencedInPublicDoc);

257var analyzers = ImmutableArray.Create(analyzer); 330var analyzers = ImmutableArray.Create(analyzer); 441var diagsProvider = new TestDiagnosticProvider(proj, ImmutableArray.Create(analyzer), fixer);

75.WithAnalyzers(ImmutableArray.Create(analyzer));

95.WithAnalyzers(ImmutableArray.Create(analyzer));

19public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(DiagnosticDescriptors.UseAddAuthorizationBuilder);

17public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(DiagnosticDescriptors.DoNotUseIHeaderDictionaryAdd);

16public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(DiagnosticDescriptors.UseHeaderDictionaryPropertiesInsteadOfIndexer);

17public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(DiagnosticDescriptors.DoNotReturnValueFromRequestDelegate);

40=> Diagnostics.Length > 0 ? this : WithDiagnostics(ImmutableArray.Create(diagnostic));

113: ImmutableArray.Create(GetHttpMethod(match.Value)!);

19public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(DiagnosticDescriptors.DoNotUseNonLiteralSequenceNumbers);

45filterCharacterRules: ImmutableArray.Create(CharacterSetModificationRule.Create(CharacterSetModificationKind.Replace, Array.Empty<char>()))); 74ImmutableArray.Create(new TaggedText(TextTags.Text, description)))); 277tags: ImmutableArray.Create(embeddedItem.Glyph)));

17private static readonly EmbeddedLanguageCommentDetector _commentDetector = new(ImmutableArray.Create("Route")); 532return ImmutableArray.Create(info.Symbol);

349return ImmutableArray.Create(info.Symbol);

39filterCharacterRules: ImmutableArray.Create(CharacterSetModificationRule.Create(CharacterSetModificationKind.Replace, Array.Empty<char>()))); 68ImmutableArray.Create(new TaggedText(TextTags.Text, description)))); 156tags: ImmutableArray.Create(embeddedItem.Glyph)));

69return ImmutableArray.Create(new AspNetCoreDocumentHighlights(highlightSpans.ToImmutable()));

16public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(DiagnosticDescriptors.PublicPartialProgramClassNotRequired);

75var trees = ImmutableArray.Create(tree);

23public override ImmutableArray<string> FixableDiagnosticIds { get; } = ImmutableArray.Create(DiagnosticDescriptors.UseAddAuthorizationBuilder.Id);

19public override ImmutableArray<string> FixableDiagnosticIds { get; } = ImmutableArray.Create(DiagnosticDescriptors.DetectMismatchedParameterOptionality.Id);

24public override ImmutableArray<string> FixableDiagnosticIds { get; } = ImmutableArray.Create(DiagnosticDescriptors.DoNotUseIHeaderDictionaryAdd.Id);

19public override ImmutableArray<string> FixableDiagnosticIds { get; } = ImmutableArray.Create(DiagnosticDescriptors.UseHeaderDictionaryPropertiesInsteadOfIndexer.Id);

24public override ImmutableArray<string> FixableDiagnosticIds { get; } = ImmutableArray.Create(

29public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(DiagnosticDescriptors.DoNotUseRenderTreeTypes);

23=> ImmutableArray.Create(DiagnosticDescriptors.ComponentParametersShouldBePublic.Id);

20SupportedDiagnostics = ImmutableArray.Create(

20SupportedDiagnostics = ImmutableArray.Create(

62var compilationWithAnalyzers = project.GetCompilationAsync().Result.WithAnalyzers(ImmutableArray.Create(analyzer));

29public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(DiagnosticDescriptors.DoNotUseRenderTreeTypes);

23=> ImmutableArray.Create(DiagnosticDescriptors.ComponentParametersShouldBePublic.Id);

62var compilationWithAnalyzers = project.GetCompilationAsync().Result.WithAnalyzers(ImmutableArray.Create(analyzer));

162new SourceFileResolver(ImmutableArray<string>.Empty, currentDirectory, ImmutableArray.Create(new KeyValuePair<string, string>(currentDirectory, mappedDirectory))));

17SupportedDiagnostics = ImmutableArray.Create(DiagnosticDescriptors.MVC1006_FunctionsContainingTagHelpersMustBeAsyncAndReturnTask);

16public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(

15public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(

21ImmutableArray.Create(ApiDiagnosticDescriptors.API1003_ApiActionsDoNotRequireExplicitModelValidationCheck.Id);

112return ImmutableArray.Create<Cci.IMetadataNamedArgument>(new HexPropertyMetadataNamedArgument(stringType, new MetadataConstant(stringType, hexFileContent)));

281return ImmutableArray.Create<V>((V)_value);

36return ImmutableArray.Create(_provider(fullPath, properties));

81=> this.Symbol == null ? CandidateSymbols : ImmutableArray.Create(this.Symbol);

122var trees = filterFile.SourceTree != null ? ImmutableArray.Create(filterFile.SourceTree) : ImmutableArray<SyntaxTree>.Empty; 123var additionalFiles = filterFile.AdditionalFile != null ? ImmutableArray.Create(filterFile.AdditionalFile) : ImmutableArray<AdditionalText>.Empty;

1720await OnEventProcessedCoreAsync(processedContainerEvent, ImmutableArray.Create(analyzer), analysisScope, cancellationToken).ConfigureAwait(false);

303return ImmutableArray.Create(LanguageNames.CSharp);

1298var analysisScope = _compilationAnalysisScope.WithAnalyzers(ImmutableArray.Create(analyzer), this);

599private static readonly ImmutableArray<string> s_splitQualifiedNameSystem = ImmutableArray.Create(SystemString); 600private static readonly ImmutableArray<ReadOnlyMemory<char>> s_splitQualifiedNameSystemMemory = ImmutableArray.Create(SystemString.AsMemory()); 633return nameMemory.Span.SequenceEqual(SystemString.AsSpan()) ? splitSystemString : ImmutableArray.Create(convert(nameMemory));

1115private static readonly ImmutableArray<bool> s_simpleTransformFlags = ImmutableArray.Create(true); 1481return (ImmutableArray.Create(paramName), true);

103_initialModules = ImmutableArray.Create(manifestModule); 186return new AssemblyMetadata(ImmutableArray.Create(module));

3290return new InvalidOperation(ImmutableArray.Create<IOperation>(child), 4310ImmutableArray.Create(lockStatement.LockTakenSymbol) : 4343ImmutableArray.Create<IArgumentOperation>( 4426ImmutableArray.Create<IArgumentOperation>( 4482regionForCollection = new RegionBuilder(ControlFlowRegionKind.LocalLifetime, locals: ImmutableArray.Create(local)); 7521var visitedReDimOperation = new ReDimOperation(ImmutableArray.Create(visitedReDimClause), operation.Preserve,

457private static readonly ImmutableArray<string> s_supersededAlias = ImmutableArray.Create("<superseded>");

99ImmutableArray.Create(error),

49var inputs = nodeTable.TrackIncrementalSteps ? ImmutableArray.Create((entry.Step!, entry.OutputIndex)) : default;

193var inputs = ImmutableArray.Create((entry.Step!, entry.OutputIndex)); 570private static readonly ImmutableArray<EntryState> s_allAddedEntries = ImmutableArray.Create(EntryState.Added); 571private static readonly ImmutableArray<EntryState> s_allCachedEntries = ImmutableArray.Create(EntryState.Cached); 572private static readonly ImmutableArray<EntryState> s_allModifiedEntries = ImmutableArray.Create(EntryState.Modified); 577private static readonly ImmutableArray<EntryState> s_allRemovedEntries = ImmutableArray.Create(EntryState.Removed); 582private static readonly ImmutableArray<EntryState> s_allRemovedDueToInputRemoval = ImmutableArray.Create(EntryState.Removed);

16public static readonly InputNode<Compilation> Compilation = new InputNode<Compilation>(b => ImmutableArray.Create(b.Compilation)); 18public static readonly InputNode<CompilationOptions> CompilationOptions = new(b => ImmutableArray.Create(b.Compilation.Options), ReferenceEqualityComparer.Instance); 20public static readonly InputNode<ParseOptions> ParseOptions = new InputNode<ParseOptions>(b => ImmutableArray.Create(b.DriverState.ParseOptions)); 26public static readonly InputNode<AnalyzerConfigOptionsProvider> AnalyzerConfigOptions = new InputNode<AnalyzerConfigOptionsProvider>(b => ImmutableArray.Create(b.DriverState.OptionsProvider));

57var inputs = tableBuilder.TrackIncrementalSteps ? ImmutableArray.Create((entry.Step!, entry.OutputIndex)) : default;

27: this(sourceNode, userFunc: (i, token) => ImmutableArray.Create(userFunc(i, token)), wrapUserFunc, comparer, name) 71var inputs = tableBuilder.TrackIncrementalSteps ? ImmutableArray.Create((entry.Step!, entry.OutputIndex)) : default;

36public static IncrementalValuesProvider<TSource> Where<TSource>(this IncrementalValuesProvider<TSource> source, Func<TSource, bool> predicate) => source.SelectMany((item, _) => predicate(item) ? ImmutableArray.Create(item) : ImmutableArray<TSource>.Empty); 38internal static IncrementalValuesProvider<TSource> Where<TSource>(this IncrementalValuesProvider<TSource> source, Func<TSource, CancellationToken, bool> predicate) => source.SelectMany((item, c) => predicate(item, c) ? ImmutableArray.Create(item) : ImmutableArray<TSource>.Empty);

854? ImmutableArray.Create(symbol) 855: ImmutableArray<TNamespaceOrTypeSymbol>.CastUp(ImmutableArray.Create((TNamedTypeSymbol)symbol));

186=> HasOneItem ? ImmutableArray.Create(_one) : _many;

3131 => ImmutableArray.Create(_item0),

567dictionary1.Add(keySelector(value), ImmutableArray.Create(value));

206return ImmutableArray.Create(new TextChangeRange(new TextSpan(0, oldText.Length), _newText.Length));

895return ImmutableArray.Create(new TextChangeRange(new TextSpan(0, oldText.Length), this.Length));

34public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(DoNotIgnoreReturnValueDiagnosticRule);

31public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(Rule);

34public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(Rule);

29public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(Rule);

79public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(s_equalityRule);

36public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(

31public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(Rule);

49public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(DoNotStorePerCompilationDataOntoFieldsRule);

32public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(Rule);

26public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(Rule);

31public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(Rule);

17public override ImmutableArray<string> FixableDiagnosticIds { get; } = ImmutableArray.Create(PreferIsKindAnalyzer.Rule.Id);

33public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(Rule);

38public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(InvalidReportDiagnosticRule);

281return ImmutableArray.Create<V>((V)_value);

854? ImmutableArray.Create(symbol) 855: ImmutableArray<TNamespaceOrTypeSymbol>.CastUp(ImmutableArray.Create((TNamedTypeSymbol)symbol));

186=> HasOneItem ? ImmutableArray.Create(_one) : _many;

3131 => ImmutableArray.Create(_item0),

567dictionary1.Add(keySelector(value), ImmutableArray.Create(value));

88return ImmutableArray.Create(operation);

65var diagnostics = ImmutableArray.Create(diagnostic ?? context.Diagnostics[0]);

41return ImmutableDictionary.CreateRange([KeyValuePair.Create(document, ImmutableArray.Create(decl.FullSpan))]); 67return ImmutableDictionary.CreateRange([KeyValuePair.Create(document, ImmutableArray.Create(decl.FullSpan))]);

80var parameters = ImmutableArray.Create(CodeGenerationSymbolFactory.CreateParameterSymbol(

36public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(UpgradeMSBuildWorkspaceDiagnosticRule);

367ReferenceAssemblies = ReferenceAssemblies.Default.AddPackages(ImmutableArray.Create(new PackageIdentity("Microsoft.CodeAnalysis", "3.3.0"))),

50ReferenceAssemblies = ReferenceAssemblies.NetStandard.NetStandard20.AddPackages(ImmutableArray.Create( 68ReferenceAssemblies = ReferenceAssemblies.NetStandard.NetStandard20.AddPackages(ImmutableArray.Create( 80ReferenceAssemblies = ReferenceAssemblies.NetStandard.NetStandard20.AddPackages(ImmutableArray.Create( 117ReferenceAssemblies = ReferenceAssemblies.NetStandard.NetStandard20.AddPackages(ImmutableArray.Create( 132ReferenceAssemblies = ReferenceAssemblies.NetStandard.NetStandard20.AddPackages(ImmutableArray.Create( 150ReferenceAssemblies = ReferenceAssemblies.NetStandard.NetStandard20.AddPackages(ImmutableArray.Create( 162ReferenceAssemblies = ReferenceAssemblies.NetStandard.NetStandard20.AddPackages(ImmutableArray.Create( 199ReferenceAssemblies = ReferenceAssemblies.NetStandard.NetStandard20.AddPackages(ImmutableArray.Create(

69ReferenceAssemblies = GetReferenceAssembliesForTargetFramework(supportedFramework).AddPackages(ImmutableArray.Create( 86ReferenceAssemblies = GetReferenceAssembliesForTargetFramework(SupportedTargetFramework.NetStandard2_0).AddPackages(ImmutableArray.Create( 103ReferenceAssemblies = GetReferenceAssembliesForTargetFramework(framework).AddPackages(ImmutableArray.Create( 124ReferenceAssemblies = GetReferenceAssembliesForTargetFramework(supportedFramework).AddPackages(ImmutableArray.Create( 141ReferenceAssemblies = GetReferenceAssembliesForTargetFramework(SupportedTargetFramework.NetStandard2_0).AddPackages(ImmutableArray.Create( 158ReferenceAssemblies = GetReferenceAssembliesForTargetFramework(framework).AddPackages(ImmutableArray.Create(

489additionalExpectedDiagnosticsInResult: ImmutableArray.Create(

262ReferenceAssemblies = AdditionalMetadataReferences.Default.WithPackages(ImmutableArray.Create(new PackageIdentity("Microsoft.CodeAnalysis.Common", "4.5.0"))),

20private static readonly ReferenceAssemblies s_withDesktopWorkspaces = ReferenceAssemblies.NetFramework.Net46.Default.AddPackages(ImmutableArray.Create(new PackageIdentity("Microsoft.CodeAnalysis.Workspaces.Common", "2.9.0")));

281return ImmutableArray.Create<V>((V)_value);

854? ImmutableArray.Create(symbol) 855: ImmutableArray<TNamespaceOrTypeSymbol>.CastUp(ImmutableArray.Create((TNamedTypeSymbol)symbol));

186=> HasOneItem ? ImmutableArray.Create(_one) : _many;

3131 => ImmutableArray.Create(_item0),

567dictionary1.Add(keySelector(value), ImmutableArray.Create(value));

88return ImmutableArray.Create(operation);

46ImmutableArray.Create<PropertySetAbstractValueKind>((PropertySetAbstractValueKind)i));

2907SetAbstractValueForArrayElementInitializer(arrayCreation, ImmutableArray.Create(abstractIndex), elementType, elementInitializer, initializerValue);

40public sealed override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(Rule);

281return ImmutableArray.Create<V>((V)_value);

854? ImmutableArray.Create(symbol) 855: ImmutableArray<TNamespaceOrTypeSymbol>.CastUp(ImmutableArray.Create((TNamedTypeSymbol)symbol));

186=> HasOneItem ? ImmutableArray.Create(_one) : _many;

3131 => ImmutableArray.Create(_item0),

567dictionary1.Add(keySelector(value), ImmutableArray.Create(value));

88return ImmutableArray.Create(operation);

65var diagnostics = ImmutableArray.Create(diagnostic ?? context.Diagnostics[0]);

41return ImmutableDictionary.CreateRange([KeyValuePair.Create(document, ImmutableArray.Create(decl.FullSpan))]); 67return ImmutableDictionary.CreateRange([KeyValuePair.Create(document, ImmutableArray.Create(decl.FullSpan))]);

80var parameters = ImmutableArray.Create(CodeGenerationSymbolFactory.CreateParameterSymbol(

67var additionalLocations = ImmutableArray.Create(member.GetLocation());

115var additionalLocations = ImmutableArray.Create(binaryLike.GetLocation());

74ImmutableArray.Create(node.GetLocation()));

107var additionalLocations = ImmutableArray.Create(

179var locations = ImmutableArray.Create(objectCreationExpression.GetLocation());

132var additionalLocations = ImmutableArray.Create(invocation.GetLocation());

120var nodes = ImmutableArray.Create<SyntaxNode>(containingStatement).AddRange(matches.Select(m => m.Statement)); 124var locations = ImmutableArray.Create(objectCreationExpression.GetLocation());

281return ImmutableArray.Create<V>((V)_value);

854? ImmutableArray.Create(symbol) 855: ImmutableArray<TNamespaceOrTypeSymbol>.CastUp(ImmutableArray.Create((TNamedTypeSymbol)symbol));

186=> HasOneItem ? ImmutableArray.Create(_one) : _many;

3131 => ImmutableArray.Create(_item0),

567dictionary1.Add(keySelector(value), ImmutableArray.Create(value));

215? ImmutableArray.Create(disposeMethod) : default;

59var kinds = ImmutableArray.Create(new SymbolKindOrTypeKind(MethodKind.Ordinary)); 60var modifiers = ImmutableArray.Create(new ModifierKind(ModifierKindEnum.IsAsync)); 78var kinds = ImmutableArray.Create(new SymbolKindOrTypeKind(MethodKind.Ordinary)); 79var modifiers = ImmutableArray.Create(new ModifierKind(ModifierKindEnum.IsAsync)); 88var kinds = ImmutableArray.Create(new SymbolKindOrTypeKind(MethodKind.Ordinary));

69var rules = ImmutableArray.Create(GetMultiLineFormattingRule());

65var diagnostics = ImmutableArray.Create(diagnostic ?? context.Diagnostics[0]);

41return ImmutableDictionary.CreateRange([KeyValuePair.Create(document, ImmutableArray.Create(decl.FullSpan))]); 67return ImmutableDictionary.CreateRange([KeyValuePair.Create(document, ImmutableArray.Create(decl.FullSpan))]);

80var parameters = ImmutableArray.Create(CodeGenerationSymbolFactory.CreateParameterSymbol(

854? ImmutableArray.Create(symbol) 855: ImmutableArray<TNamespaceOrTypeSymbol>.CastUp(ImmutableArray.Create((TNamedTypeSymbol)symbol));

186=> HasOneItem ? ImmutableArray.Create(_one) : _many;

567dictionary1.Add(keySelector(value), ImmutableArray.Create(value));

3131 => ImmutableArray.Create(_item0),

893return new BoundBlock(statement.Syntax, locals, ImmutableArray.Create(statement)) 910ImmutableArray.Create(statement))

542enclosingBinder, qvm, ImmutableArray.Create(parameter),

877(object)otherSymbol == null ? ImmutableArray<Symbol>.Empty : ImmutableArray.Create(otherSymbol), 878receiver == null ? ImmutableArray<BoundExpression>.Empty : ImmutableArray.Create(receiver), 1140getItemOrSliceHelper = getItemOrSliceHelper.AsMember(getItemOrSliceHelper.ContainingType.Construct(ImmutableArray.Create(elementAccess.Expression.Type.TryGetInlineArrayElementField().TypeWithAnnotations))); 5652ImmutableArray.Create<ParameterSymbol>(new SignatureOnlyParameterSymbol( 5666arguments = ImmutableArray.Create(elementAccess.Expression); 5667refKinds = ImmutableArray.Create(parameterRefKind); 5692ImmutableArray.Create<ParameterSymbol>(new SignatureOnlyParameterSymbol( 5706arguments = ImmutableArray.Create(inlineArray); 5707refKinds = ImmutableArray.Create(parameterRefKind);

88ImmutableArray.Create<Symbol>(receiver.ExpressionSymbol), 89ImmutableArray.Create(BindToTypeForErrorRecovery(receiver)),

1000initializer = ImmutableArray.Create(CreateTypedConstant(node, TypedConstantKind.Error, diagnostics, ref attrHasErrors, curArgumentHasErrors));

921ImmutableArray.Create((BoundExpression)element), 2470ImmutableArray.Create(tupleSyntax.Location));

62return ImmutableArray.Create<Symbol>(result); 923return ImmutableArray.Create<Symbol>(ConstructWithCrefTypeParameters(arity, typeArgumentListSyntax, symbol));

169ImmutableArray.Create(BindToTypeForErrorRecovery(childNode)), 225ImmutableArray.Create(BindToTypeForErrorRecovery(expr)), 861node, LookupResultKind.Empty, ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundExpression>(BindToTypeForErrorRecovery(BindValue(node.Expression, BindingDiagnosticBag.Discarded, BindValueKind.RefersToLocation))), 1013ImmutableArray.Create(BindValue(arguments[0].Expression, diagnostics, BindValueKind.RValue)) : 1049ImmutableArray.Create<BoundExpression>(boundArgument), CreateErrorType("void")); 1682symbols: ImmutableArray.Create(symbol), 1683childBoundNodes: ImmutableArray.Create(BindToTypeForErrorRecovery(expression)), 4247ImmutableArray.Create(boundExpression.ExpressionSymbol), 4248ImmutableArray.Create(boundExpression)); 4624typeArguments: ImmutableArray.Create(elementTypeWithAnnotations), 5469return new BoundBadExpression(node, LookupResultKind.NotInvocable, StaticCast<Symbol>.From(type.InstanceConstructors), ImmutableArray.Create(argument), type); 5479argument.Syntax, default, WellKnownMemberNames.DelegateInvokeName, ImmutableArray.Create(sourceDelegate.DelegateInvokeMethod), 5613return new BoundBadExpression(node, LookupResultKind.NotCreatable, ImmutableArray.Create<Symbol?>(type), children.ToImmutableAndFree(), type) { WasCompilerGenerated = wasCompilerGenerated }; 6369ImmutableArray.Create(boundElementInitializer), 6597ImmutableArray.Create((BoundExpression)addElementPlaceholder), 7837return new BoundBadExpression(node, LookupResultKind.Ambiguous, lookupResult.Symbols.AsImmutable(), ImmutableArray.Create(boundLeft), CreateErrorType(rightName), hasErrors: true); 7874return new BoundBadExpression(node, lookupResult.Kind, symbols.AsImmutable(), ImmutableArray.Create(boundLeft), CreateErrorType(rightName), hasErrors: true); 8321(object)symbolOpt == null ? ImmutableArray<Symbol>.Empty : ImmutableArray.Create(symbolOpt), 8322boundLeft == null ? ImmutableArray<BoundExpression>.Empty : ImmutableArray.Create(BindToTypeForErrorRecovery(boundLeft)), 9538Construct(ImmutableArray.Create(elementField.TypeWithAnnotations)); 9714var argumentPlaceholders = ImmutableArray.Create(new BoundImplicitIndexerValuePlaceholder(convertedArguments[0].Syntax, int32) { WasCompilerGenerated = true }); 10381argumentPlaceholders = ImmutableArray.Create(intPlaceholder); 10460syntax, typeArgumentsOpt: default, method.Name, ImmutableArray.Create(method), 10732methods = ImmutableArray.Create(method);

584ImmutableArray.Create(unconvertedInterpolatedString.Parts),

121return BadExpression(node, LookupResultKind.Empty, ImmutableArray.Create(symbol), args.Add(receiver), wasCompilerGenerated: true); 1792ImmutableArray.Create(arraySize),

1511var unwrappedSymbols = ImmutableArray.Create<Symbol>(unwrappedSymbol); 1536diagInfo = new CSDiagnosticInfo(ErrorCode.ERR_BadAccess, new[] { unwrappedSymbol }, ImmutableArray.Create<Symbol>(unwrappedSymbol), additionalLocations: ImmutableArray<Location>.Empty);

303ImmutableArray.Create(state.fromExpression), state.fromExpression.Type); 742yExpression = new BoundBadExpression(yExpression.Syntax, LookupResultKind.Empty, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create(yExpression), CreateErrorType()); 748yExpression = new BoundBadExpression(yExpression.Syntax, LookupResultKind.Empty, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create(yExpression), yExpression.Type); 758var lambda = MakeQueryUnboundLambda(state.RangeVariableMap(), ImmutableArray.Create(x), let.Expression, bodyFactory, diagnostics.AccumulatesDependencies); 809field2Value = new BoundBadExpression(field2Value.Syntax, LookupResultKind.Empty, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create(field2Value), field2Value.Type, true); 834return MakeQueryUnboundLambda(qvm, ImmutableArray.Create(parameter), expression, withDependencies); 850return MakeQueryUnboundLambda(expression, new QueryUnboundLambdaState(this, qvm, ImmutableArray.Create(parameter), (LambdaSymbol lambdaSymbol, Binder lambdaBodyBinder, BindingDiagnosticBag diagnostics) => 886return MakeQueryInvocation(node, receiver, receiverIsCheckedForRValue, methodName, default(SeparatedSyntaxList<TypeSyntax>), default(ImmutableArray<TypeWithAnnotations>), ImmutableArray.Create(arg), diagnostics 912return MakeQueryInvocation(node, receiver, receiverIsCheckedForRValue, methodName, new SeparatedSyntaxList<TypeSyntax>(new SyntaxNodeOrTokenList(typeArgSyntax, 0)), ImmutableArray.Create(typeArg), ImmutableArray<BoundExpression>.Empty, diagnostics 965receiver = new BoundBadExpression(receiver.Syntax, LookupResultKind.NotAValue, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create(receiver), CreateErrorType()); 987receiver = new BoundBadExpression(receiver.Syntax, LookupResultKind.NotAValue, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create(receiver), CreateErrorType());

520return new BoundBadStatement(node, ImmutableArray.Create<BoundNode>(expression), true); 539childNodes = ImmutableArray.Create<BoundNode>(value); 3571return new BoundBlock(node, locals, ImmutableArray.Create(statement)) { WasCompilerGenerated = node.Kind() != SyntaxKind.ArrowExpressionClause }; 4043arguments: ImmutableArray.Create(argument),

1317ImmutableArray.Create<Symbol>(lookupResultSymbol), 1507receiver = new BoundBadExpression(receiver.Syntax, LookupResultKind.Ambiguous, ImmutableArray<Symbol>.Empty, ImmutableArray.Create(receiver), receiver.Type, hasErrors: true).MakeCompilerGenerated();

94return ImmutableArray.Create<LocalSymbol>(iterationVariable); 741ImmutableArray.Create(collectionExpr), 858spanType = spanType.Construct(ImmutableArray.Create(elementField.TypeWithAnnotations));

120increment = new BoundBlock(increment.Syntax, locals, ImmutableArray.Create(increment))

330internal static ImmutableArray<Conversion> IdentityUnderlying = ImmutableArray.Create(Identity); 331internal static ImmutableArray<Conversion> ImplicitConstantUnderlying = ImmutableArray.Create(ImplicitConstant); 332internal static ImmutableArray<Conversion> ImplicitNumericUnderlying = ImmutableArray.Create(ImplicitNumeric); 333internal static ImmutableArray<Conversion> ExplicitNumericUnderlying = ImmutableArray.Create(ExplicitNumeric); 334internal static ImmutableArray<Conversion> ExplicitEnumerationUnderlying = ImmutableArray.Create(ExplicitEnumeration); 335internal static ImmutableArray<Conversion> PointerToIntegerUnderlying = ImmutableArray.Create(PointerToInteger); 340return new Conversion(ConversionKind.StackAllocToPointerType, ImmutableArray.Create(underlyingConversion)); 345return new Conversion(ConversionKind.StackAllocToSpanType, ImmutableArray.Create(underlyingConversion)); 360_ => new Conversion(kind, ImmutableArray.Create(nestedConversion)),

1150HasIdentityConversionInternal(((NamedTypeSymbol)destination.OriginalDefinition).Construct(ImmutableArray.Create(elementType)), destination)) 1176return new Conversion(ConversionKind.ImplicitNullable, ImmutableArray.Create(underlyingConversion)); 1312return new Conversion(ConversionKind.ImplicitNullable, ImmutableArray.Create(underlyingTupleConversion)); 1341return new Conversion(ConversionKind.ExplicitNullable, ImmutableArray.Create(underlyingTupleConversion)); 2273return new Conversion(ConversionKind.ImplicitNullable, ImmutableArray.Create(tupleConversion)); 2470return new Conversion(ConversionKind.ExplicitNullable, ImmutableArray.Create(tupleConversion));

4632return MemberAnalysisResult.BadArgumentConversions(argsToParameters, MemberAnalysisResult.CreateBadArgumentsWithPosition(argumentPosition), ImmutableArray.Create(conversion),

446return new BoundBadExpression(node, LookupResultKind.Empty, ImmutableArray<Symbol>.Empty, ImmutableArray.Create(switchGoverningExpression), switchGoverningType ?? CreateErrorType()); 547childBoundNodes: gotoCaseExpressionOpt != null ? ImmutableArray.Create<BoundNode>(gotoCaseExpressionOpt) : ImmutableArray<BoundNode>.Empty,

175return Synthesized(syntax, receiverOpt, initialBindingReceiverIsSubjectToCloning: initialBindingReceiverIsSubjectToCloning, method, ImmutableArray.Create(arg0)); 591return new BoundBlock(syntax, ImmutableArray<LocalSymbol>.Empty, ImmutableArray.Create(statement))

81protected override ImmutableArray<BoundNode?> Children => ImmutableArray.Create<BoundNode?>(this.Value); 91protected override ImmutableArray<BoundNode?> Children => ImmutableArray.Create<BoundNode?>(this.Argument); 101protected override ImmutableArray<BoundNode?> Children => ImmutableArray.Create<BoundNode?>(this.Operand); 106protected override ImmutableArray<BoundNode?> Children => ImmutableArray.Create<BoundNode?>(this.Receiver); 111protected override ImmutableArray<BoundNode?> Children => ImmutableArray.Create<BoundNode?>(this.Operand); 116protected override ImmutableArray<BoundNode?> Children => ImmutableArray.Create<BoundNode?>(this.Operand); 126protected override ImmutableArray<BoundNode?> Children => ImmutableArray.Create<BoundNode?>(this.Expression); 154protected override ImmutableArray<BoundNode?> Children => ImmutableArray.Create<BoundNode?>(this.Expression); 159protected override ImmutableArray<BoundNode?> Children => ImmutableArray.Create<BoundNode?>(this.ReceiverOpt); 175protected override ImmutableArray<BoundNode?> Children => ImmutableArray.Create<BoundNode?>(this.Expression);

35protected override ImmutableArray<BoundNode?> Children => ImmutableArray.Create<BoundNode?>(this.Operand);

342return TypeWithAnnotations.Create(taskTypeT.Construct(ImmutableArray.Create(bestResultType)));

1989var aliases = (alias != null) ? ImmutableArray.Create(alias) : ImmutableArray<string>.Empty;

322ImmutableArray.Create<BinaryOperatorSignature>(GetSignature(BinaryOperatorKind.LogicalBoolAnd)), //and 324ImmutableArray.Create<BinaryOperatorSignature>(GetSignature(BinaryOperatorKind.LogicalBoolOr)), //or

299crefSymbols = ImmutableArray.Create<Symbol>(binder.BindType(expression, BindingDiagnosticBag.Discarded).Type); 5187? ImmutableArray.Create<ISymbol>(namedType) 5193? ImmutableArray.Create(symbol)

238result = new SymbolInfo(ImmutableArray.Create<ISymbol>(info.Symbol), CandidateReason.NotATypeOrNamespace);

149F.CloseMethod(F.Block(ImmutableArray.Create<LocalSymbol>(boundLocal.LocalSymbol), assignment, retStatement));

106ImmutableArray.Create<BoundExpression>(new BoundLiteral(syntax, ConstantValue.Create(slotIndex), intType) { WasCompilerGenerated = true }), 126ImmutableArray.Create<BoundExpression>(new BoundLiteral(syntax, ConstantValue.Create(0), intType) { WasCompilerGenerated = true }), 154ImmutableArray.Create<BoundExpression>(new BoundLiteral(syntax, ConstantValue.Create(targetSubmissionIndex), intType) { WasCompilerGenerated = true }), 421compareExchangeMethod = compareExchangeMethod.Construct(ImmutableArray.Create<TypeSymbol>(delegateType)); 566ImmutableArray.Create<BoundStatement>( 574ImmutableArray.Create<BoundStatement>(

1608return new BoundBadStatement(body.Syntax, ImmutableArray.Create<BoundNode>(body), hasErrors: true); 1994body = new BoundBlock(constructor.Syntax, constructor.Locals, ImmutableArray.Create<BoundStatement>(constructor.Initializer)); 2089statements = ImmutableArray.Create(constructorInitializer);

355children: ImmutableArray.Create(decl), 519children = ImmutableArray.Create<SingleNamespaceOrTypeDeclaration>(ns);

35return new MergedNamespaceDeclaration(ImmutableArray.Create(declaration)); 63return ImmutableArray.Create<Location>(_declarations[0].NameLocation);

1593ImmutableArray.Create(new TypedConstant(byteArrayType, value))); 1612ImmutableArray.Create(new TypedConstant(byteType, TypedConstantKind.Primitive, nullableValue))); 1632ImmutableArray.Create(new TypedConstant(Compilation.GetSpecialType(SpecialType.System_Byte), TypedConstantKind.Primitive, value))); 1676var arguments = ImmutableArray.Create(new TypedConstant(boolArray, transformFlags));

251yield return new Cci.TypeReferenceWithAttributes(new Cci.ModifiedTypeReference(typeRef, ImmutableArray.Create<Cci.ICustomModifier>(modifier)));

147ImmutableArray.Create(new TypedConstant(ctor.Parameters[0].Type, TypedConstantKind.Type, ctor.ContainingAssembly.GetSpecialType(SpecialType.System_Object))),

4951return namedType.OriginalDefinition.Construct(ImmutableArray.Create(elementType)); 5107type = TypeWithAnnotations.Create(((NamedTypeSymbol)node.Type).OriginalDefinition.Construct(ImmutableArray.Create(type))); 6844var constructedType = wellKnownType.Construct(ImmutableArray.Create(parameterType)); 10152return compilation.GetSpecialType(SpecialType.System_Nullable_T).Construct(ImmutableArray.Create(underlying)); 11818getEnumeratorType = spanType.Construct(ImmutableArray.Create(convertedResult.Type!.TryGetInlineArrayElementField()!.TypeWithAnnotations));

236ImmutableArray.Create(catchAll), 459ImmutableArray.Create<LocalSymbol>(obj), 495ImmutableArray.Create(ex), 642ImmutableArray.Create(catchTemp), 688ImmutableArray.Create(catchTemp),

240ImmutableArray.Create(exceptionLocal), 265? ImmutableArray.Create<BoundExpression>(F.Local(_exprRetValue)) 583ImmutableArray.Create(notifyCompletionTemp), 649ImmutableArray.Create(thisTemp), 650ImmutableArray.Create<BoundExpression>(F.AssignmentExpression(F.Local(thisTemp), F.This())), 659return (secondOpt == null) ? ImmutableArray.Create(first) : ImmutableArray.Create(first, secondOpt);

398ImmutableArray.Create<BoundExpression>(instLocal))); 460ImmutableArray.Create(instSymbol),

95return new BoundBadStatement(bodyWithAwaitLifted.Syntax, ImmutableArray.Create<BoundNode>(bodyWithAwaitLifted), hasErrors: true); 265ImmutableArray.Create<BoundExpression>(F.Local(stateMachineVariable)))));

394DeclareLocals(_currentScope, ImmutableArray.Create<Symbol>(thisParam));

1129sideEffects: ImmutableArray.Create<BoundExpression>(rewritten), 1734return new BoundBadExpression(F.Syntax, LookupResultKind.Empty, ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundExpression>(node), node.Type);

351return new BoundBadExpression(node.Syntax, default(LookupResultKind), ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundExpression>(node), ExpressionType); 382return new BoundBadExpression(node.Syntax, 0, ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundExpression>(node), ExpressionType); 856ImmutableArray.Create<TypeSymbol>(underlyingDelegateType), 900ImmutableArray.Create(param), 901ImmutableArray.Create<BoundExpression>(_bound.AssignmentExpression(parameterReference, parameter)), 905_bound.ArrayOrEmpty(ParameterExpressionType, ImmutableArray.Create<BoundExpression>(parameterReference)))); 1091return new BoundBadExpression(node.Syntax, default(LookupResultKind), ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundExpression>(node), node.Type); 1098return new BoundBadExpression(node.Syntax, default(LookupResultKind), ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundExpression>(node), node.Type); 1130return new BoundBadExpression(node.Syntax, default(LookupResultKind), ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundExpression>(node), node.Type);

112boundStatement = new BoundBlock(syntax, fieldInit.Locals, ImmutableArray.Create(boundStatement)) { WasCompilerGenerated = fieldInit.WasCompilerGenerated };

266ImmutableArray.Create(_methodBodyFactory.MethodDefIndex(_method)))); 274ImmutableArray.Create(_methodBodyFactory.MethodDefIndex(_method)));

126return block.Update(block.Locals, block.LocalFunctions, block.HasUnsafeModifier, block.Instrumentation, ImmutableArray.Create(InstrumentFieldOrPropertyInitializer(block.Statements.Single(), syntax)));

192ImmutableArray.Create(local), 193ImmutableArray.Create<BoundExpression>(factory.AssignmentExpression(factory.Local(local), condition)),

545ImmutableArray.Create<BoundStatement>(logCallStatement)); 622return _factory.Sequence(ImmutableArray.Create(temp.LocalSymbol), builder.ToImmutableAndFree(), temp);

27_parameters = ImmutableArray.Create<ParameterSymbol>(

118ImmutableArray.Create(cachedState) : 182ImmutableArray.Create<LocalSymbol>(stateLocal), 210ImmutableArray.Create<LocalSymbol>(_methodValue), 416ImmutableArray.Create(this.cachedThis) :

218var IEnumeratorOfElementType = F.SpecialType(SpecialType.System_Collections_Generic_IEnumerator_T).Construct(ImmutableArray.Create(_elementType));

173return new BoundBadStatement(statement.Syntax, ImmutableArray.Create<BoundNode>(statement), hasErrors: true); 578return BadExpression(node.Syntax, node.Type, ImmutableArray.Create(node)); 583return BadExpression(syntax, resultType, ImmutableArray.Create(child)); 720return block.Update(locals, block.LocalFunctions, block.HasUnsafeModifier, block.Instrumentation, ImmutableArray.Create(statement)); 732ImmutableArray.Create(statement)); 849.Construct(ImmutableArray.Create(elementType)),

74sideEffects: ImmutableArray.Create<BoundExpression>(rewrittenOperand),

52locals: ImmutableArray.Create<LocalSymbol>(tempAccess.LocalSymbol), 53sideEffects: ImmutableArray.Create<BoundExpression>(tempAssignment),

108locals: ImmutableArray.Create(boundTemp.LocalSymbol), 109sideEffects: ImmutableArray.Create<BoundExpression>(tempAssignment), 712return _factory.Sequence(ImmutableArray.Create(temp.LocalSymbol), ImmutableArray.Create<BoundExpression>(tempAssignment), result); 871sideEffects: ImmutableArray.Create<BoundExpression>(nonNull), 1415sideEffects: ImmutableArray.Create<BoundExpression>(sideEffect), 1752locals: ImmutableArray.Create<LocalSymbol>(boundTemp.LocalSymbol), 1753sideEffects: ImmutableArray.Create<BoundExpression>(tempAssignment), 1983sideEffects: ImmutableArray.Create<BoundExpression>(nonNullValue),

826extraRefInitialization is object ? ImmutableArray.Create<BoundExpression>(extraRefInitialization, assignmentToTemp) : ImmutableArray.Create<BoundExpression>(assignmentToTemp), 903visitedArgumentsBuilder[argIndex] = _factory.Sequence(ImmutableArray<LocalSymbol>.Empty, ImmutableArray.Create<BoundExpression>(store), local); 1492ImmutableArray.Create<BoundExpression>( 1518arrayEmpty = arrayEmpty.Construct(ImmutableArray.Create(elementType)); 1728sideEffects: ImmutableArray.Create<BoundExpression>(boundAssignmentToTemp),

242return _factory.StaticCall(asImmutableArray.Construct(ImmutableArray.Create(elementType)), ImmutableArray.Create(arrayCreation)); 377ImmutableArray.Create(temp.LocalSymbol), 424var typeArgs = ImmutableArray.Create(elementType); 497arguments: ImmutableArray.Create(span), 570var inlineArrayType = _factory.ModuleBuilderOpt.EnsureInlineArrayTypeExists(syntax, _factory, arrayLength, _diagnostics.DiagnosticBag).Construct(ImmutableArray.Create(elementType)); 747ImmutableArray.Create<BoundExpression>( 773ImmutableArray.Create(GetKnownLengthExpression(elements, numberIncludingLastSpread, localsBuilder)), 1024var typeArguments = ImmutableArray.Create(elementType); 1070rewrittenReceiver = _factory.New(constructor, ImmutableArray.Create<BoundExpression>(knownLengthTemp)); 1075rewrittenReceiver = _factory.New(constructor, ImmutableArray.Create(knownLengthExpression)); 1347var iterationVariables = ImmutableArray.Create(iterationVariable); 1420ImmutableArray.Create(statement),

158ImmutableArray.Create<BoundExpression>(_factory.Literal(builder.Count)), 1199locals: ImmutableArray.Create(boundTemp.LocalSymbol), 1200sideEffects: ImmutableArray.Create<BoundExpression>(tempAssignment), 1475locals: ImmutableArray.Create(boundTemp.LocalSymbol), 1476sideEffects: ImmutableArray.Create<BoundExpression>(tempAssignment), 1532rewrittenArguments: ImmutableArray.Create(rewrittenOperand)); 1784var result = UserDefinedConversionResult.Valid(ImmutableArray.Create<UserDefinedConversionAnalysis>(analysis), 0); 1884var result = UserDefinedConversionResult.Valid(ImmutableArray.Create<UserDefinedConversionAnalysis>(analysis), 0);

54var rewrittenArguments = ImmutableArray.Create<BoundExpression>(rewrittenArgument); 124rewrittenArguments: ImmutableArray.Create<BoundExpression>(removeDelegate)); 128clearCall = new BoundBadExpression(syntax, LookupResultKind.NotInvocable, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create<BoundExpression>(removeDelegate), ErrorTypeSymbol.UnknownResultType); 181: ImmutableArray.Create<LocalSymbol>(boundTemp.LocalSymbol); 265getOrCreateCall = new BoundBadExpression(syntax, LookupResultKind.NotInvocable, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create<BoundExpression>(fieldAccess), ErrorTypeSymbol.UnknownResultType); 287return new BoundBadExpression(syntax, LookupResultKind.NotInvocable, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create(getOrCreateCall), ErrorTypeSymbol.UnknownResultType); 333return new BoundBadExpression(node.Syntax, LookupResultKind.NotCreatable, ImmutableArray.Create<Symbol?>(node.Event),

382sideEffects: ImmutableArray.Create<BoundExpression>(tempAssignment), 403locals: ImmutableArray.Create(nullableBoundTemp.LocalSymbol), 404sideEffects: ImmutableArray.Create<BoundExpression>(nullableTempAssignment), 546lengthCall = new BoundBadExpression(fixedInitializer.Syntax, LookupResultKind.NotInvocable, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create<BoundExpression>(factory.Local(pinnedTemp)), ErrorTypeSymbol.UnknownResultType);

265tryBlock: new BoundBlock(forEachSyntax, locals: ImmutableArray<LocalSymbol>.Empty, statements: ImmutableArray.Create(whileLoop)), 274locals: ImmutableArray.Create(enumeratorVar), 286locals: ImmutableArray.Create(enumeratorVar), 417statements: ImmutableArray.Create(alwaysOrMaybeDisposeStmt)); 471locals: ImmutableArray.Create(disposableVar), 936indices: ImmutableArray.Create<BoundExpression>(boundPositionVar), 1088ImmutableArray<BoundExpression> dimensionArgument = ImmutableArray.Create( 1142ImmutableArray<BoundExpression> dimensionArgument = ImmutableArray.Create( 1189outerLocals: ImmutableArray.Create(positionVar[dimension]), 1203ImmutableArray.Create(arrayVar).Concat(upperVar.AsImmutableOrNull()), 1204ImmutableArray.Create(arrayVarDecl).Concat(upperVarDecl.AsImmutableOrNull()).Add(forLoop));

336result = _factory.Sequence(ImmutableArray.Create(((BoundLocal)rewrittenReceiver).LocalSymbol), 337ImmutableArray.Create((BoundExpression)receiverStore), 551!CodeGenerator.IsSafeToDereferenceReceiverRefAfterEvaluatingArguments(ImmutableArray.Create(makeOffsetInput))))

92sideEffects: ImmutableArray.Create<BoundExpression>(loweredOperand),

80locals: ImmutableArray.Create(boundTemp.LocalSymbol), 117exitCallExpr = new BoundBadExpression(lockSyntax, LookupResultKind.NotInvocable, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create<BoundExpression>(boundLockTemp), ErrorTypeSymbol.UnknownResultType); 212enterCallExpr = new BoundBadExpression(lockSyntax, LookupResultKind.NotInvocable, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create<BoundExpression>(boundLockTemp), ErrorTypeSymbol.UnknownResultType); 221ImmutableArray.Create(boundLockTemp.LocalSymbol),

184locals: ImmutableArray.Create(boundTemp.LocalSymbol), 185sideEffects: ImmutableArray.Create<BoundExpression>(tempAssignment),

291locals = ImmutableArray.Create(value.LocalSymbol); 341method = method.Construct(ImmutableArray.Create<TypeSymbol>(typeParameter));

187return F.StaticCall(constructionMethod, ImmutableArray.Create(arg));

686ImmutableArray.Create(temp.LocalSymbol), 687ImmutableArray.Create<BoundExpression>(store),

287: ImmutableArray.Create(HandlerTemp.LocalSymbol);

237locals: ImmutableArray.Create<LocalSymbol>(boundTemp.LocalSymbol), 238sideEffects: ImmutableArray.Create<BoundExpression>(tempAssignment), 709ImmutableArray.Create<BoundExpression>(tempAssignment), 871locals: ImmutableArray.Create<LocalSymbol>(boundTemp.LocalSymbol), 872sideEffects: ImmutableArray.Create<BoundExpression>(tempAssignment),

83ImmutableArray.Create<BoundStatement>(result)); 258locals: ImmutableArray.Create<LocalSymbol>(boundTemp.LocalSymbol), //localSymbol will be declared by an enclosing block 463disposeCall = new BoundBadExpression(resourceSyntax, LookupResultKind.NotInvocable, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create(disposedExpression), ErrorTypeSymbol.UnknownResultType);

75return new BoundSequence(_factory.Syntax, _temps, ImmutableArray.Create(SiteInitialization), SiteInvocation, _resultType) { WasCompilerGenerated = true };

98var loweredArguments = ImmutableArray.Create(loweredOperand); 130var loweredArguments = ImmutableArray.Create(loweredOperand);

311ImmutableArray.Create<LocalSymbol>(tempLocal.LocalSymbol), 312ImmutableArray.Create<BoundExpression>(tempAssignment),

442return call.Update(ImmutableArray.Create(Spill(builder, call.Arguments[0], call.ArgumentRefKindsOpt[0]))); 455ImmutableArray.Create(Spill(builder, call.Arguments[0])));

99return _factory.Sequence(ImmutableArray.Create(sacrificialTemp), sideEffects.ToImmutableAndFree(), _factory.AssignmentExpression(_factory.Local(sacrificialTemp), replacement, isRef: true));

302ImmutableArray.Create(stateMachineVariable), 505F.CloseMethod(F.Block(ImmutableArray.Create(resultVariable), bodyBuilder.ToImmutableAndFree()));

101get { return ImmutableArray.Create(ImplementedProperty); }

844return Call(receiver, method, ImmutableArray.Create(arg0), useStrictArgumentRefKinds); 858=> Call(receiver, WellKnownMethod(method), ImmutableArray.Create(arg0)); 1005return MakeSequence(ImmutableArray.Create<LocalSymbol>(temp), parts); 1073=> SwitchSection(ImmutableArray.Create(value), statements); 1556arrayEmpty = arrayEmpty.Construct(ImmutableArray.Create(elementType)); 1568ImmutableArray.Create<BoundExpression>(Literal(elements.Length)), 1577ImmutableArray.Create<BoundExpression>(length), 1613return new BoundCatchBlock(Syntax, ImmutableArray.Create(local), source, source.Type, exceptionFilterPrologueOpt: null, exceptionFilterOpt: null, body: block, isSynthesizedAsyncCatchAll: false); 1863sideEffects: ImmutableArray.Create<BoundExpression>(nonNullValue),

402return ImmutableArray.Create(CreateVariableDeclaratorInternal((BoundLocalDeclaration)declaration, (declarationSyntax as VariableDeclarationSyntax)?.Variables[0] ?? declarationSyntax)); 1645return new ArrayElementReferenceOperation(instance, ImmutableArray.Create(argument), _semanticModel, syntax, type, isImplicit); 1726ImmutableArray<IFieldSymbol> initializedFields = ImmutableArray.Create<IFieldSymbol>(boundFieldEqualsValue.Field.GetPublicSymbol()); 1735ImmutableArray<IPropertySymbol> initializedProperties = ImmutableArray.Create<IPropertySymbol>(boundPropertyEqualsValue.Property.GetPublicSymbol()); 2147return new VariableDeclarationGroupOperation(ImmutableArray.Create(multiVariableDeclaration), _semanticModel, varStatement, isImplicit); 2169var variableDeclaration = new VariableDeclarationGroupOperation(ImmutableArray.Create(multiVariableDeclaration), _semanticModel, declarationGroupSyntax, isImplicit); 2884propertySubpatterns: ImmutableArray.Create(result), declaredSymbol: null,

30return ImmutableArray.Create(statement);

423executableCodeBlocks: ImmutableArray.Create<SyntaxNode>(expressionBody),

201interfaces = ImmutableArray.Create<NamedTypeSymbol>(SubstituteNamedType(interfaces[0]));

75return new AliasSymbolFromResolvedTarget(targetSymbol, aliasToken.ValueText, containingSymbol, ImmutableArray.Create(aliasToken.GetLocation()), isExtern); 286: base(syntax.Alias!.Name.Identifier.ValueText, containingSymbol, ImmutableArray.Create(syntax.Alias!.Name.Identifier.GetLocation()), isExtern: false) 294: base(syntax.Identifier.ValueText, containingSymbol, ImmutableArray.Create(syntax.Identifier.GetLocation()), isExtern: true)

184get { return ImmutableArray.Create<Location>(this.TypeDescriptor.Location); }

24_parameters = ImmutableArray.Create<ParameterSymbol>(

154ImmutableArray.Create(

35this(container, field, field.TypeWithAnnotations, index, ImmutableArray.Create<Location>(field.Location), includeBackingField: false)

220arguments: ImmutableArray.Create(new TypedConstant(Manager.System_String, TypedConstantKind.Primitive, displayString)), 221namedArguments: ImmutableArray.Create(new KeyValuePair<WellKnownMember, TypedConstant>(

116constructedInterfaces.Add(new ConstructedNamedTypeSymbol(iListOfT, ImmutableArray.Create(elementTypeWithAnnotations))); 123constructedInterfaces.Add(new ConstructedNamedTypeSymbol(iReadOnlyListOfT, ImmutableArray.Create(elementTypeWithAnnotations)));

487ImmutableArray.Create(ticks)); 498ImmutableArray.Create(new TypedConstant( 781ImmutableArray.Create(typedConstantDebugMode)); 804var arguments = ImmutableArray.Create(new TypedConstant(boolArray, transformFlags)); 821var args = ImmutableArray.Create(new TypedConstant(stringArray, names)); 829var arguments = ImmutableArray.Create(

70: this(containingSymbol, ImmutableArray.Create<Symbol>(guessSymbol), resultKind, errorInfo, GetArity(guessSymbol), unreported)

495Symbol found = CSharpCompilation.GetRuntimeMember(ImmutableArray.Create<Symbol>(this), descriptor, CSharpCompilation.SpecialMembersSignatureComparer.Instance,

514=> GetCustomModifierForRefKind(refKind, compilation) is { } modifier ? ImmutableArray.Create(modifier) : ImmutableArray<CustomModifier>.Empty;

154this.MetadataLocation = ImmutableArray.Create<MetadataLocation>(new MetadataLocation(this));

819return ImmutableArray.Create<NamedTypeSymbol>(new UnsupportedMetadataTypeSymbol(mrEx));

136return ImmutableArray.Create<Symbol>(ns);

173private static readonly ImmutableArray<int> s_defaultStringHandlerAttributeIndexes = ImmutableArray.Create(int.MinValue);

1291ImmutableArray.Create(new TypedConstant(declaringCompilation.GetSpecialType(SpecialType.System_String), TypedConstantKind.Primitive, nameof(CompilerFeatureRequiredFeatures.RequiredMembers)))

81_lazyModules = ImmutableArray.Create<ModuleSymbol>(moduleSymbol);

86return ImmutableArray.Create(this);

733overriddenMembers = ImmutableArray.Create<Symbol>(representativeMember);

49=> _location is null ? ImmutableArray<Location>.Empty : ImmutableArray.Create(_location); 66return ImmutableArray.Create(node.GetReference());

181return ImmutableArray.Create<Location>(_declaringSyntax.GetLocation()); 189return ImmutableArray.Create<SyntaxReference>(_declaringSyntax);

224return ImmutableArray.Create<Location>(_syntax.Location); 251return ImmutableArray.Create<SyntaxReference>(syntaxReferenceOpt);

342public override ImmutableArray<Location> Locations => ImmutableArray.Create(Syntax.Identifier.GetLocation()); 464ImmutableArray.Create(location), 465ImmutableArray.Create(parameter.GetReference()));

1205return ImmutableArray.Create(CSharpCustomModifier.CreateOptional(requiresLocationType)); 1216return ImmutableArray.Create(CSharpCustomModifier.CreateRequired(modifierType));

1839ImmutableArray.Create(typedConstantRequestMinimum), 1840ImmutableArray.Create(new KeyValuePair<WellKnownMember, TypedConstant>( 1977ImmutableArray.Create(typedConstantNoStringInterning))); 1997ImmutableArray.Create(new KeyValuePair<WellKnownMember, TypedConstant>( 2027AddSynthesizedAttribute(ref attributes, _compilation.TrySynthesizeAttribute(WellKnownMember.System_Reflection_AssemblyKeyNameAttribute__ctor, ImmutableArray.Create(typedConstant))); 2037AddSynthesizedAttribute(ref attributes, _compilation.TrySynthesizeAttribute(WellKnownMember.System_Reflection_AssemblyKeyFileAttribute__ctor, ImmutableArray.Create(typedConstant)));

1288parameterOrdinals = ImmutableArray.Create(ordinal);

170ImmutableArray.Create<EventSymbol>(explicitlyImplementedEvent);

284_refCustomModifiers = ImmutableArray.Create(CSharpCustomModifier.CreateRequired(modifierType));

49_parameters = ImmutableArray.Create<ParameterSymbol>(new SynthesizedEventAccessorValueParameterSymbol(this, 0)); 64explicitInterfaceImplementations = (object)implementedAccessor == null ? ImmutableArray<MethodSymbol>.Empty : ImmutableArray.Create<MethodSymbol>(implementedAccessor);

123return ImmutableArray.Create(_location); 134return ImmutableArray.Create<SyntaxReference>(_syntaxRef);

88return ImmutableArray.Create<CustomModifier>( 220=> ImmutableArray.Create(GetFirstLocation()); 226=> ImmutableArray.Create(_syntaxReference);

227(name == _constructor.Name) ? ImmutableArray.Create<Symbol>(_constructor) : 228(name == FixedElementFieldName) ? ImmutableArray.Create<Symbol>(_internalField) :

83: ImmutableArray.Create<Location>(_identifierNodeOrToken.GetLocation()!); 103return node == null ? ImmutableArray<SyntaxReference>.Empty : ImmutableArray.Create<SyntaxReference>(node.GetReference());

415=> ImmutableArray.Create(GetFirstLocation()); 461return ImmutableArray.Create(node.GetReference());

1660{ symbol.Name.AsMemory(), ImmutableArray.Create(symbol) }, 1686: ImmutableArray.Create((Symbol)pair.Value)); 3363return ImmutableArray.Create(InstanceInitializersForPositionalMembers.ToImmutableAndFree()); 4926ImmutableArray.Create<ParameterSymbol>(new SignatureOnlyParameterSymbol( 4979ImmutableArray.Create<ParameterSymbol>(new SignatureOnlyParameterSymbol( 5306ImmutableArray.Create<ParameterSymbol>(new SignatureOnlyParameterSymbol(

169implementingMemberAndDiagnostics = new SymbolAndDiagnostics(null, new ReadOnlyBindingDiagnostic<AssemblySymbol>(ImmutableArray.Create(diag), default)); 229var info = new CSDiagnosticInfo(ErrorCode.ERR_MixingWinRTEventWithRegular, args, ImmutableArray<Symbol>.Empty, ImmutableArray.Create<Location>(this.GetFirstLocation()));

484type = TypeWithAnnotations.Create(tokenTableType.Construct(ImmutableArray.Create(@event.TypeWithAnnotations)));

805=> ImmutableArray.Create(_location);

150ImmutableArray.Create(arg))); 156ImmutableArray.Create(arg))); 162ImmutableArray.Create(arg))); 231ImmutableArray.Create(new TypedConstant(compilation.GetSpecialType(SpecialType.System_String), TypedConstantKind.Primitive, nameof(CompilerFeatureRequiredFeatures.UserDefinedCompoundAssignmentOperators)))

104return (this.syntaxReferenceOpt == null) ? ImmutableArray<SyntaxReference>.Empty : ImmutableArray.Create(this.syntaxReferenceOpt);

653var version = ImmutableArray.Create(new TypedConstant(compilation.GetSpecialType(SpecialType.System_Int32), TypedConstantKind.Primitive, 11)); 659var includesInternals = ImmutableArray.Create(

1725ImmutableArray.Create(new TypedConstant(compilation.GetSpecialType(SpecialType.System_String), TypedConstantKind.Primitive, nameof(CompilerFeatureRequiredFeatures.RefStructs))), 1742ImmutableArray.Create(defaultMemberNameConstant))); 1774ImmutableArray.Create(new TypedConstant(compilation.GetWellKnownType(WellKnownType.System_Type), TypedConstantKind.Type, originalType)), 1940Conversions.HasIdentityConversion(((NamedTypeSymbol)returnTypeOriginalDefinition).Construct(ImmutableArray.Create(elementType)), returnType))

122_lazyRefCustomModifiers = ImmutableArray.Create(CSharpCustomModifier.CreateRequired(modifierType)); 133_lazyExplicitInterfaceImplementations = ImmutableArray.Create<MethodSymbol>(overriddenOrExplicitlyImplementedMethod);

1204var syntaxRefs = ImmutableArray.Create(parameter.GetReference()); 1205var locations = ImmutableArray.Create(location);

265=> _location is null ? ImmutableArray<Location>.Empty : ImmutableArray.Create(_location);

395var modifiers = ImmutableArray.Create<CustomModifier>( 628: ImmutableArray.Create<MethodSymbol>(implementedAccessor);

274_lazyRefCustomModifiers = ImmutableArray.Create(CSharpCustomModifier.CreateRequired(modifierType)); 281ImmutableArray.Create(explicitlyImplementedProperty); 554return ImmutableArray.Create(Location); 562return ImmutableArray.Create(_syntaxRef);

14Parameters = ImmutableArray.Create(

14Parameters = ImmutableArray.Create(

47public override ImmutableArray<PropertySymbol> ExplicitInterfaceImplementations => ImmutableArray.Create(_interfaceProperty);

273TypeParameters = ImmutableArray.Create<TypeParameterSymbol>(typeParameter); 894? ImmutableArray.Create(_enumeratorType)

30Parameters: ImmutableArray.Create<ParameterSymbol>(

24Parameters = ImmutableArray.Create(SynthesizedParameterSymbol.Create(

38Parameters: ImmutableArray.Create<ParameterSymbol>(

33Parameters: ImmutableArray.Create<ParameterSymbol>( 72F.CloseMethod(F.Block(ImmutableArray.Create<BoundStatement>(F.Return(expression))));

95Parameters: ImmutableArray.Create<ParameterSymbol>(

80F.CloseMethod(F.Block(ImmutableArray.Create(builderLocalSymbol), block.ToImmutableAndFree()));

114return (object)constructor == null ? ImmutableArray<Symbol>.Empty : ImmutableArray.Create(constructor); 120return ((object)ctor != null && name == ctor.Name) ? ImmutableArray.Create<Symbol>(ctor) : ImmutableArray<Symbol>.Empty;

252_constructors = ImmutableArray.Create<MethodSymbol>(new SynthesizedEmbeddedAttributeConstructorSymbol(this, m => ImmutableArray<ParameterSymbol>.Empty));

24_constructors = ImmutableArray.Create<MethodSymbol>( 27m => ImmutableArray.Create(SynthesizedParameterSymbol.Create(m, TypeWithAnnotations.Create(systemStringType), 0, RefKind.None, name: "name"))));

21_constructors = ImmutableArray.Create<MethodSymbol>(

37_fields = ImmutableArray.Create<FieldSymbol>( 53m => ImmutableArray.Create(SynthesizedParameterSymbol.Create(m, boolArrayType, 0, RefKind.None)), 82ImmutableArray.Create<BoundExpression>(factory.Literal(true))

41_fields = ImmutableArray.Create<FieldSymbol>( 53m => ImmutableArray.Create(SynthesizedParameterSymbol.Create(m, annotatedByteType, 0, RefKind.None)), 57m => ImmutableArray.Create(SynthesizedParameterSymbol.Create(m, byteArrayType, 0, RefKind.None)), 100ImmutableArray.Create<BoundExpression>(

29_fields = ImmutableArray.Create<FieldSymbol>( 38_constructors = ImmutableArray.Create<MethodSymbol>( 41m => ImmutableArray.Create(SynthesizedParameterSymbol.Create(m, TypeWithAnnotations.Create(systemByteType), 0, RefKind.None)),

29_fields = ImmutableArray.Create<FieldSymbol>( 38_constructors = ImmutableArray.Create<MethodSymbol>( 41m => ImmutableArray.Create(SynthesizedParameterSymbol.Create(m, TypeWithAnnotations.Create(systemBooleanType), 0, RefKind.None)),

27_fields = ImmutableArray.Create<FieldSymbol>( 36_constructors = ImmutableArray.Create<MethodSymbol>( 39m => ImmutableArray.Create(SynthesizedParameterSymbol.Create(m, TypeWithAnnotations.Create(int32Type), 0, RefKind.None)),

429statements: ImmutableArray.Create<BoundStatement>( 506ImmutableArray.Create<LocalSymbol>(scriptLocal.LocalSymbol), 544_parameters = ImmutableArray.Create(SynthesizedParameterSymbol.Create(this, 594ImmutableArray.Create<BoundExpression>(submissionArrayParameter), 623ImmutableArray.Create<LocalSymbol>(submissionLocal.LocalSymbol),

42_explicitInterfaceImplementations = ImmutableArray.Create<MethodSymbol>(interfaceMethod);

17this.SetParameters(ImmutableArray.Create<ParameterSymbol>(SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(TypeParameters[0]), 0, RefKind.Ref, "buffer")));

17this.SetParameters(ImmutableArray.Create<ParameterSymbol>(SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(TypeParameters[0]), 0, RefKind.In, "buffer")));

41_fields = ImmutableArray.Create<FieldSymbol>(field); 43TypeParameters = ImmutableArray.Create<TypeParameterSymbol>(typeParameter); 211arguments: ImmutableArray.Create(new TypedConstant(compilation.GetSpecialType(SpecialType.System_Int32), TypedConstantKind.Primitive, _arrayLength)),

54_parameters = ImmutableArray.Create<ParameterSymbol>(new SynthesizedOperatorParameterSymbol(this, container, 0, "value"));

145get { return (_syntaxOpt == null) ? ImmutableArray<Location>.Empty : ImmutableArray.Create(_syntaxOpt.GetLocation()); } 150get { return (_syntaxOpt == null) ? ImmutableArray<SyntaxReference>.Empty : ImmutableArray.Create(_syntaxOpt.GetReference()); }

56_parameters = ImmutableArray.Create(SynthesizedParameterSymbol.Create(this,

21this.SetParameters(ImmutableArray.Create<ParameterSymbol>(SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(paramType), 0, RefKind.None, "s"))); 31this.SetParameters(ImmutableArray.Create<ParameterSymbol>(SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(paramType), 0, RefKind.None, "s")));

28_parameters = ImmutableArray.Create<ParameterSymbol>(

19this.SetParameters(ImmutableArray.Create(SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(paramType), 0, RefKind.None, "unmatchedValue"))); 34var body = F.Throw(F.New(F.WellKnownMethod(WellKnownMember.System_Runtime_CompilerServices_SwitchExpressionException__ctorObject), ImmutableArray.Create<BoundExpression>(F.Parameter(unmatchedValue))));

52_locations = location == null ? ImmutableArray<Location>.Empty : ImmutableArray.Create(location);

60var locations = locationOpt is null ? ImmutableArray<Location>.Empty : ImmutableArray.Create(locationOpt); 849return elementLocation == null ? ImmutableArray<Location>.Empty : ImmutableArray.Create(elementLocation);

2012ImmutableArray.Create(type.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0]),

223=> Create(compilation.GetSpecialType(SpecialType.System_Nullable_T).Construct(ImmutableArray.Create(typeSymbol))); 1203_compilation.GetSpecialType(SpecialType.System_Nullable_T).Construct(ImmutableArray.Create(_underlying)) :

31internal NumericValueSet(T first, T last, INumericTC<T> tc) : this(ImmutableArray.Create((first, last)), tc)

19protected override ImmutableArray<SyntaxKind> BaseTypeSyntaxKinds => ImmutableArray.Create(SyntaxKind.BaseList);

19protected override ImmutableArray<SyntaxKind> BaseTypeSyntaxKinds => ImmutableArray.Create(SyntaxKind.BaseList);

73var additionalLocations = ImmutableArray.Create(statement.GetLocation());

120var additionalLocations = ImmutableArray.Create(firstStatementLocation); 139var additionalUnnecessaryLocations = ImmutableArray.Create(location);

208var locations = ImmutableArray.Create(expression.GetLocation()); 217var additionalUnnecessaryLocations = ImmutableArray.Create(

52var locations = ImmutableArray.Create(invocationExpression.GetLocation()); 68var additionalUnnecessaryLocations = ImmutableArray.Create(

48var locations = ImmutableArray.Create(invocationExpression.GetLocation());

90var locations = ImmutableArray.Create(objectCreationExpression.GetLocation());

60var locations = ImmutableArray.Create(expression.GetLocation()); 69var additionalUnnecessaryLocations = ImmutableArray.Create( 100var locations = ImmutableArray.Create(expression.GetLocation()); 109var additionalUnnecessaryLocations = ImmutableArray.Create(

104var additionalLocations = ImmutableArray.Create(declaration.GetLocation()); 123var additionalLocations = ImmutableArray.Create(declaration.GetLocation());

140var additionalLocations = ImmutableArray.Create(syntaxNode.GetLocation());

29var rules = ImmutableArray.Create(baseIndentationRule).AddRange(CSharpSyntaxFormatting.Instance.GetDefaultFormattingRules());

226editor.SetStatements(functionDeclaration, ImmutableArray.Create(statement));

4039Assert.True(parsedArgs.EmitOptions.InstrumentationKinds.SequenceEqual(ImmutableArray.Create(InstrumentationKind.TestCoverage))); 4043Assert.True(parsedArgs.EmitOptions.InstrumentationKinds.SequenceEqual(ImmutableArray.Create(InstrumentationKind.TestCoverage))); 4047Assert.True(parsedArgs.EmitOptions.InstrumentationKinds.SequenceEqual(ImmutableArray.Create(InstrumentationKind.TestCoverage))); 4051Assert.True(parsedArgs.EmitOptions.InstrumentationKinds.SequenceEqual(ImmutableArray.Create(InstrumentationKind.TestCoverage))); 4055Assert.True(parsedArgs.EmitOptions.InstrumentationKinds.SequenceEqual(ImmutableArray.Create(InstrumentationKind.TestCoverage))); 4059Assert.True(parsedArgs.EmitOptions.InstrumentationKinds.SequenceEqual(ImmutableArray.Create(InstrumentationKind.TestCoverage))); 14220var virtualSnProvider = new DesktopStrongNameProvider(ImmutableArray.Create(dir.Path)); 14899public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(_rule); 15968return ImmutableArray.Create(Info01); 15995return ImmutableArray.Create(Warning01); 16014public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Warning02);

98var contentSpans = ImmutableArray.Create(TextSpan.FromBounds(start, end));

52var spans = ImmutableArray.Create(new TextSpan(start, length)); 73var spans = ImmutableArray.Create(new TextSpan(start, length));

53var packageSources = ImmutableArray.Create(new PackageSource("My Custom Nuget Feed", "http://nuget.org/")); 90var packageSources = ImmutableArray.Create(new PackageSource("nuget.org", "http://fakenuget.org/"));

30var selectedMembers = ImmutableArray.Create("TestField"); 60var selectedMembers = ImmutableArray.Create("TestProperty"); 90var selectedMembers = ImmutableArray.Create("TestEvent"); 126var selectedMembers = ImmutableArray.Create("TestMethod"); 162var selectedMembers = ImmutableArray.Create("TestMethod"); 216var selectedMembers = ImmutableArray.Create("TestField"); 282var selectedMembers = ImmutableArray.Create("TestMethod"); 368var selectedMembers = ImmutableArray.Create("TestMethodBool"); 472var selectedMembers = ImmutableArray.Create("TestField"); 508var selectedMembers = ImmutableArray.Create("TestField"); 544var selectedMembers = ImmutableArray.Create("TestField"); 565var selectedMembers = ImmutableArray.Create("TestField"); 589var selectedMembers = ImmutableArray.Create("TestMethod"); 627var selectedMembers = ImmutableArray.Create("TestMethod"); 674var selectedMembers = ImmutableArray.Create("TestMethod"); 710var selectedMembers = ImmutableArray.Create("TestMethod"); 746var selectedMembers = ImmutableArray.Create("TestMethod"); 798var selectedMembers = ImmutableArray.Create("StaticMethod"); 845var selectedMembers = ImmutableArray.Create("TestMethod"); 899var selectedMembers = ImmutableArray.Create("TestMethod"); 944var selectedMembers = ImmutableArray.Create("TestField"); 1040var selectedMembers = ImmutableArray.Create("TestMethod"); 1092var selectedMembers = ImmutableArray.Create("TestMethod"); 1206var selectedMembers = ImmutableArray.Create("TestMethod"); 1267var selectedMembers = ImmutableArray.Create("TestMethod"); 1329var selectedMembers = ImmutableArray.Create("TestMethod"); 1407var selectedMembers = ImmutableArray.Create("TestMethod"); 1463var selectedMembers = ImmutableArray.Create("TestMethod"); 1526var selectedMembers = ImmutableArray.Create("TestMethod"); 1590var selectedMembers = ImmutableArray.Create("Foo"); 1683var selectedMembers = ImmutableArray.Create("TestMethod"); 1743var selectedMembers = ImmutableArray.Create("TestMethod"); 1806var selectedMembers = ImmutableArray.Create("TestMethod"); 1869var selectedMembers = ImmutableArray.Create("TestMethod"); 1941var selectedMembers = ImmutableArray.Create("TestMethod"); 2030var selectedMembers = ImmutableArray.Create("TestMethod"); 2131var selectedMembers = ImmutableArray.Create("TestMethod"); 2167var selectedMembers = ImmutableArray.Create("TestMethod"); 2214var selectedMembers = ImmutableArray.Create("TestField"); 2245var selectedMembers = ImmutableArray.Create("TestProperty"); 2276var selectedMembers = ImmutableArray.Create("TestEvent"); 2313var selectedMembers = ImmutableArray.Create("TestMethod"); 2350var selectedMembers = ImmutableArray.Create("TestMethod"); 2405var selectedMembers = ImmutableArray.Create("TestField"); 2436var selectedMembers = ImmutableArray.Create("TestMethod"); 2485var selectedMembers = ImmutableArray.Create("TestMethod"); 2528var selectedMembers = ImmutableArray.Create("TestMethod"); 2574var selectedMembers = ImmutableArray.Create("TestMethod"); 2669var selectedMembers = ImmutableArray.Create("TestMethod"); 2705var selectedMembers = ImmutableArray.Create("TestField"); 2735var selectedMembers = ImmutableArray.Create("TestField"); 2765var selectedMembers = ImmutableArray.Create("TestField"); 2795var selectedMembers = ImmutableArray.Create("TestField"); 2825var selectedMembers = ImmutableArray.Create("TestMethod"); 2861var selectedMembers = ImmutableArray.Create("TestField"); 3045var selectedMembers = ImmutableArray.Create("Foo"); 3086var selectedMembers = ImmutableArray.Create("Goo");

826{ LanguageNames.CSharp, ImmutableArray.Create(analyzer) }

87var rules = ImmutableArray.Create(formattingRuleProvider.CreateRule(documentSyntax, position)).AddRange(Formatter.GetDefaultFormattingRules(document));

126var results = ImmutableArray.Create<INavigateToSearchResult>(new TestNavigateToSearchResult(workspace, new TextSpan(0, 0))); 161var results = ImmutableArray.Create<INavigateToSearchResult>(new TestNavigateToSearchResult(workspace, new TextSpan(0, 0))); 238var results = ImmutableArray.Create<INavigateToSearchResult>(new TestNavigateToSearchResult(workspace, new TextSpan(0, 0))); 274var results = ImmutableArray.Create<INavigateToSearchResult>(new TestNavigateToSearchResult(workspace, new TextSpan(0, 0))); 322var results = ImmutableArray.Create<INavigateToSearchResult>(new TestNavigateToSearchResult(workspace, new TextSpan(0, 0)));

61=> Task.FromResult(ImmutableArray.Create(new TaskListItem(

996var comp = CreateCompilation(source, new[] { new CSharpCompilationReference(libComp, aliases: ImmutableArray.Create("Q")) }); 1045var comp1 = CreateCompilation(source, new[] { new CSharpCompilationReference(libComp1, aliases: ImmutableArray.Create("A")), new CSharpCompilationReference(libComp1, aliases: ImmutableArray.Create("B")) }); 1061var comp2 = CreateCompilation(source, new[] { new CSharpCompilationReference(libComp1, aliases: ImmutableArray.Create("A")), new CSharpCompilationReference(libComp2, aliases: ImmutableArray.Create("B")) });

7682CallingConvention.Unmanaged, TypeWithAnnotations.Create(@string, customModifiers: ImmutableArray.Create(testMod)), refCustomModifiers: default, 7686CallingConvention.Unmanaged, TypeWithAnnotations.Create(@string), refCustomModifiers: ImmutableArray.Create(testMod), 7767CallingConvention.Unmanaged, TypeWithAnnotations.Create(@string, customModifiers: ImmutableArray.Create(testMod)), refCustomModifiers: default, 7771CallingConvention.Unmanaged, TypeWithAnnotations.Create(@string), refCustomModifiers: ImmutableArray.Create(testMod),

897INamedTypeSymbol iNamedType = comp.CreateAnonymousTypeSymbol(ImmutableArray.Create<ITypeSymbol>(comp.ObjectType.GetPublicSymbol()), ImmutableArray.Create("qq")); 1061INamedTypeSymbol iNamedType = comp.CreateAnonymousTypeSymbol(ImmutableArray.Create<ITypeSymbol>(comp.ObjectType.GetPublicSymbol()), ImmutableArray.Create("qq"));

6331var e = Assert.Throws<ArgumentException>(() => comp.CreateAnonymousTypeSymbol(ImmutableArray.Create(vbType), ImmutableArray.Create("m1"))); 6352Assert.Throws<ArgumentException>(() => comp.CreateTupleTypeSymbol(new[] { intType, intType }.AsImmutable(), elementLocations: ImmutableArray.Create(loc1))); 16814references: new[] { comp2.ToMetadataReference(ImmutableArray.Create("alias")), comp1.ToMetadataReference() }, 16865references: new[] { comp1.ToMetadataReference().WithAliases(ImmutableArray.Create("alias")), comp2.ToMetadataReference() }, 16886references: new[] { comp1.ToMetadataReference(), comp2.ToMetadataReference().WithAliases(ImmutableArray.Create("alias1")) }, 16940references: new[] { comp1.ToMetadataReference().WithAliases(ImmutableArray.Create("alias")), comp2.ToMetadataReference() }, 16961references: new[] { comp1.ToMetadataReference(), comp2.ToMetadataReference().WithAliases(ImmutableArray.Create("alias1")) }, 17023references: s_valueTupleRefs.Concat(new[] { comp1.ToMetadataReference(), comp2.ToMetadataReference().WithAliases(ImmutableArray.Create("alias1")) }), 17046references: s_valueTupleRefs.Concat(new[] { comp1.ToMetadataReference(), comp2.ToMetadataReference().WithAliases(ImmutableArray.Create("alias1")) }), 17070comp2.ToMetadataReference().WithAliases(ImmutableArray.Create("alias1")), 17124references: new[] { comp1.ToMetadataReference(), comp2.ToMetadataReference().WithAliases(ImmutableArray.Create("alias1")) }, 17178references: new[] { comp1.ToMetadataReference(), comp2.ToMetadataReference().WithAliases(ImmutableArray.Create("alias1")) },

76var peImage = c.EmitToArray(EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage))); 220var peImage = c.EmitToArray(EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage))); 340var peImage = c.EmitToArray(EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage))); 434var peImage = c.EmitToArray(EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage))); 491var peImage = c.EmitToArray(EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage))); 530var peImage = c.EmitToArray(EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage))); 561var peImage = c.EmitToArray(EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage))); 601var peImage = c.EmitToArray(EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage))); 669var peImage = c.EmitToArray(EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage))); 750var peImage = c.EmitToArray(EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage))); 831var peImage = c.EmitToArray(EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage))); 925var peImage = c.EmitToArray(EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage))); 980var emitOptions = EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage)); 1019var emitOptions = EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage));

2450ImmutableArray<Diagnostic> diagnostics = CreateEmptyCompilation(source + InstrumentationHelperSource).GetEmitDiagnostics(EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage))); 2961var verifier = CompileAndVerify(c, emitOptions: EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage))); 2997var verifier = CompileAndVerify(c, emitOptions: EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage))); 4133emitOptions: EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage)), 4148return base.CompileAndVerify(compilation, expectedOutput: expectedOutput, emitOptions: EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage)));

236ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1))); 242ImmutableArray.Create( 341ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1))); 424ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1))); 479var ref01 = lib01.ToMetadataReference(ImmutableArray.Create("L0")); 482var ref02 = lib02.ToMetadataReference(ImmutableArray.Create("L0")); 485var ref11 = lib11.ToMetadataReference(ImmutableArray.Create("L1")); 488var ref12 = lib12.ToMetadataReference(ImmutableArray.Create("L1")); 504ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1))); 615ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, m0, m1, GetSyntaxMapFromMarkers(source0, source1)))); 624ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f1, f2, GetSyntaxMapFromMarkers(source1, source2)))); 636ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, m2, m3, GetSyntaxMapFromMarkers(source2, source3))));

258ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 319ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 391ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 449ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 502ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 561ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 615ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 670ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 726ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 781ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 849ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 924ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 998ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, ctor0, ctor1, GetSyntaxMapFromMarkers(source0, source1)))); 1065ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, ctor0, ctor1, GetSyntaxMapFromMarkers(source0, source1)))); 1124ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 1212ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 1301ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 1385ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 1476ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 1558ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 1636ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 1660ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f1, f2, GetSyntaxMapFromMarkers(source1, source2)))); 1735ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 1758ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f1, f2, GetSyntaxMapFromMarkers(source1, source2)))); 1826ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 1849ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f1, f2, GetSyntaxMapFromMarkers(source1, source2)))); 1935ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 1970ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f1, f2, GetSyntaxMapFromMarkers(source1, source2)))); 2014ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f2, f3, GetSyntaxMapFromMarkers(source2, source3)))); 2133ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 2167ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f1, f2, GetSyntaxMapFromMarkers(source1, source2)))); 2209ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f2, f3, GetSyntaxMapFromMarkers(source2, source3)))); 2343ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 2367ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f1, f2, GetSyntaxMapFromMarkers(source1, source2)))); 2481ImmutableArray.Create( 2497ImmutableArray.Create( 2598ImmutableArray.Create( 2614ImmutableArray.Create( 2754ImmutableArray.Create( 2803ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 3256ImmutableArray.Create( 3495ImmutableArray.Create( 3763ImmutableArray.Create( 3795ImmutableArray.Create( 3888ImmutableArray.Create( 3900ImmutableArray.Create( 3988ImmutableArray.Create( 4040ImmutableArray.Create( 4134ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 4219ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 4301ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 4374ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 4456ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 4639ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 4698ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 4749ImmutableArray.Create(

60ImmutableArray.Create( 124ImmutableArray.Create( 188ImmutableArray.Create( 252ImmutableArray.Create( 316ImmutableArray.Create(

62ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Insert, null, g1))); 241ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Insert, null, f1))); 358ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1))); 460ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1))); 534ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1))); 584ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1))); 1134ImmutableArray.Create( 1559ImmutableArray.Create( 2001ImmutableArray.Create( 2006ImmutableArray.Create( 2578ImmutableArray.Create( 2747ImmutableArray.Create( 3286ImmutableArray.Create( 3670ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1)))); 3774ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1)))); 3883ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1)))); 3989ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1)))); 4103ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1)))); 4255ImmutableArray.Create( 4489ImmutableArray.Create( 4649ImmutableArray.Create( 5112ImmutableArray.Create( 5460ImmutableArray.Create( 5799ImmutableArray.Create( 5804ImmutableArray.Create( 5809ImmutableArray.Create( 6704ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 7143ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 7439ImmutableArray.Create( 7806ImmutableArray.Create( 7881ImmutableArray.Create( 8188ImmutableArray.Create( 8709ImmutableArray.Create( 8718ImmutableArray.Create( 8727ImmutableArray.Create( 8736ImmutableArray.Create( 8786ImmutableArray.Create( 8791ImmutableArray.Create( 8891ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 8903ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f1, f2, GetSyntaxMapFromMarkers(source1, source2)))); 9086ImmutableArray.Create( 9208ImmutableArray.Create( 9227ImmutableArray.Create( 9365ImmutableArray.Create( 9378ImmutableArray.Create( 9520ImmutableArray.Create( 9531ImmutableArray.Create( 9627ImmutableArray.Create( 9689ImmutableArray.Create( 9757ImmutableArray.Create( 9769ImmutableArray.Create( 9783ImmutableArray.Create( 9795ImmutableArray.Create( 9807ImmutableArray.Create( 10259ImmutableArray.Create( 10569ImmutableArray.Create( 10635ImmutableArray.Create( 10702ImmutableArray.Create( 10835ImmutableArray.Create( 10888ImmutableArray.Create( 11018ImmutableArray.Create( 11069ImmutableArray.Create( 11120ImmutableArray.Create( 11174ImmutableArray.Create( 11235ImmutableArray.Create( 11290ImmutableArray.Create( 11357ImmutableArray.Create(

328ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1))); 361ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1))); 416ImmutableArray.Create( 426ImmutableArray.Create( 482ImmutableArray.Create( 529ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1))); 591ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1))); 618ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method1, method2))); 818ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1))); 1146ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1))); 1183ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method1, method2))); 1269ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1))); 1310ImmutableArray.Create( 1342ImmutableArray.Create( 1844ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1)))); 1933ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1)))); 1951ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method1, method2, GetSyntaxMapFromMarkers(source1, source2)))); 2018ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1)))); 2036ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method1, method2, GetSyntaxMapFromMarkers(source1, source2)))); 2092ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1)))); 2158ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1)))); 2178ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method1, method2, GetSyntaxMapFromMarkers(source1, source2)))); 2234ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1)))); 3110ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Insert, null, method1))); 3252ImmutableArray.Create( 3624ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Insert, null, f1))); 3658ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f1, f2))); 3954ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Insert, null, f3))); 4077ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, getP0, getP1))); 4147: ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Insert, null, r1))); 4185: ImmutableArray.Create( 5998ImmutableArray.Create( 6053ImmutableArray.Create( 6676ImmutableArray.Create( 6741ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, c0, c1))); 6762ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, c1, c2))); 6941ImmutableArray.Create( 6949ImmutableArray.Create( 7119ImmutableArray.Create( 7197ImmutableArray.Create( 7212ImmutableArray.Create( 7282ImmutableArray.Create( 7297ImmutableArray.Create( 7694ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1))); 7761ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Insert, null, method1))); 7787ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method1, method2))); 7837ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1))); 8241ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Insert, null, compilation1.GetMember<MethodSymbol>("C.M")))); 8313ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 8363ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, compilation0.GetMember("C.M"), compilation1.GetMember("C.M")))); 8465ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Insert, null, compilation1.GetMember<MethodSymbol>("C.puts")))); 8521ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Insert, null, compilation1.GetMember<NamedTypeSymbol>("B")))); 8601ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Insert, null, compilation1.GetMembers("M.C.M1")[2]))); 8634ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, compilation1.GetMember<MethodSymbol>("M.C.M2"), 8757ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, compilation0.GetMembers("C.M")[0], compilation1.GetMembers("C.M")[0]))); 8781ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, compilation1.GetMembers("C.M")[1], compilation2.GetMembers("C.M")[1]))); 8805ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, compilation2.GetMembers("C.M")[2], compilation3.GetMembers("C.M")[2]))); 8830ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, compilation3.GetMembers("C.M")[3], compilation4.GetMembers("C.M")[3]))); 8855ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, compilation4.GetMembers("C.M")[4], compilation5.GetMembers("C.M")[4]))); 8879ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, compilation5.GetMembers("C.M")[5], compilation6.GetMembers("C.M")[5]))); 8903ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, compilation6.GetMembers("C.M")[6], compilation7.GetMembers("C.M")[6]))); 8929ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, compilation7.GetMembers("C.M")[7], compilation8.GetMembers("C.M")[7]))); 8954ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, compilation8.GetMembers("C.M")[8], compilation9.GetMembers("C.M")[8]))); 8978ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, compilation9.GetMembers("C.M")[9], compilation10.GetMembers("C.M")[9]))); 9051ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, compilation10.GetMembers("C.M")[12], compilation11.GetMembers("C.M")[12]))); 9075ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, compilation11.GetMembers("C.M")[13], compilation12.GetMembers("C.M")[13]))); 9144ImmutableArray.Create( 9250ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 9330ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, compilation0.GetMembers("C.F")[1], compilation1.GetMembers("C.F")[1]))); 9359ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, compilation1.GetMembers("C.F")[1], compilation2.GetMembers("C.F")[1]))); 9423ImmutableArray.Create(SemanticEdit.Create( 9556ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 9614ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method1, method2, GetEquivalentNodesMap(method2, method1)))); 9672ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method2, method3, GetEquivalentNodesMap(method3, method2)))); 9762ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Insert, null, m1, null))); 9766ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, m1, m2, GetEquivalentNodesMap(m2, m1)))); 9850ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 9900ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1))); 9949ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1))); 10125ImmutableArray.Create( 10153ImmutableArray.Create( 10238ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 10261ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f1, f2, GetSyntaxMapFromMarkers(source1, source2)))); 10327ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 10348ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f1, f2, GetSyntaxMapFromMarkers(source1, source2)))); 10606ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetEquivalentNodesMap(f1, f0)))); 10722ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1)))); 10750ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method1, method2, GetSyntaxMapFromMarkers(source1, source2)))); 10782ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method2, method3, GetSyntaxMapFromMarkers(source2, source3)))); 10909ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetEquivalentNodesMap(f1, f0)))); 10919ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, g1, g2, GetEquivalentNodesMap(g2, g1)))); 10929ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, g2, g3, GetEquivalentNodesMap(g3, g2)))); 11015ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 11094ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, m0, m1, GetSyntaxMapFromMarkers(source0, source1)))); 11121ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, m1, m2, GetSyntaxMapFromMarkers(source1, source2)))); 11244ImmutableArray.Create( 11258ImmutableArray.Create( 11367ImmutableArray.Create( 11381ImmutableArray.Create( 11563ImmutableArray.Create( 11593ImmutableArray.Create( 11671ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 11744ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 11819ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 11912ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 12005ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 12069ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 12132ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 12142ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 12152ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 12162ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 12172ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 12182ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 12252ImmutableArray.Create( 12293ImmutableArray.Create( 12401ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 12519ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1)))); 12572ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1)))); 12667ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1A, GetEquivalentNodesMap(method1A, method0)))); 12679ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1B, GetEquivalentNodesMap(method1B, method0)))); 12745ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1))); 12891ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 13006ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0F, method1F, syntaxMap: s => null))); 13019ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method1F, method2F, syntaxMap: s => null))); 13031ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method1G, method2G, syntaxMap: s => null))); 13074ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0F, method1F, syntaxMap: s => null)), 13090ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0F, method1F, syntaxMap: s => null)), 13106ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0F, method1F, syntaxMap: s => null)), 13162ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0F, method1F, syntaxMap: s => null)), 13199ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Insert, null, compilation1.GetMember<MethodSymbol>("C.Main"))), 13239ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, compilation0.GetMember("C.Main"), compilation1.GetMember("C.Main")))); 13291ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0F, method1F, syntaxMap: s => null))); 13302ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method1F, method2F, syntaxMap: s => null))); 13426ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetEquivalentNodesMap(f1, f0)))); 13445ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f1, f2, GetEquivalentNodesMap(f2, f1)))); 13497ImmutableArray.Create( 13504ImmutableArray.Create( 13541ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1))); 13622ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1))))); 13690ImmutableArray.Create( 13733ImmutableArray.Create( 13839ImmutableArray.Create( 13872ImmutableArray.Create( 13967ImmutableArray.Create( 13991ImmutableArray.Create( 14075ImmutableArray.Create( 14100ImmutableArray.Create( 14218ImmutableArray.Create( 14270ImmutableArray.Create( 14390ImmutableArray.Create( 14424ImmutableArray.Create( 14516ImmutableArray.Create( 14545ImmutableArray.Create( 14686ImmutableArray.Create( 14743ImmutableArray.Create( 14854ImmutableArray.Create( 14882ImmutableArray.Create( 14966ImmutableArray.Create( 14989ImmutableArray.Create( 15087ImmutableArray.Create( 15136ImmutableArray.Create( 15249ImmutableArray.Create( 15290ImmutableArray.Create( 15383ImmutableArray.Create( 15407ImmutableArray.Create( 15501ImmutableArray.Create( 15545ImmutableArray.Create( 15678ImmutableArray.Create( 15732ImmutableArray.Create( 15894ImmutableArray.Create( 15965ImmutableArray.Create( 16128ImmutableArray.Create( 16178ImmutableArray.Create( 16267ImmutableArray.Create( 16279ImmutableArray.Create( 16365ImmutableArray.Create( 16446ImmutableArray.Create( 16804ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1))); 16876ImmutableArray.Create( 19573ImmutableArray.Create( 19832ImmutableArray.Create(

80ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, syntaxMap: null))); 254ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 438ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 544ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1)))); 656ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1)))); 766ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1)))); 857ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1)))); 1159ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 1222ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 1330ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 1494ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 1750ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 1862ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 2022ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 2055ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 2204ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1)))); 2252ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method1, method2, GetSyntaxMapFromMarkers(source1, source2)))); 2428ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 2490ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method1, method2, GetEquivalentNodesMap(method2, method1)))); 2612ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 2750ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 2925ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapByKind(method0, SyntaxKind.SwitchStatement)))); 3061ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapByKind(method0, SyntaxKind.SwitchStatement)))); 3224ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 3388ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapByKind(method0, SyntaxKind.IfStatement)))); 3497ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapByKind(method0, SyntaxKind.WhileStatement)))); 3607ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapByKind(method0, SyntaxKind.DoStatement)))); 3698ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapByKind(method0, SyntaxKind.ForStatement, SyntaxKind.VariableDeclarator)))); 3902ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, m0, m1, GetSyntaxMapFromMarkers(source0, source1)))); 3906ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, m1, m2, GetSyntaxMapFromMarkers(source1, source2)))); 4245ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 4292ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 4348ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 4403ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 4455ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 4511ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 4580ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 4660ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 4754ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, g0, g1, GetEquivalentNodesMap(g1, g0)))); 4814ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 4874ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 4963ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 5117ImmutableArray.Create( 5181ImmutableArray.Create(

487Assert.Equal("<>f__AnonymousType0", anonymousTypeMap0[new AnonymousTypeKey(ImmutableArray.Create(new AnonymousTypeKeyField("A", isKey: false, ignoreCase: false)))].Name); 488Assert.Equal("<>f__AnonymousType1", anonymousTypeMap0[new AnonymousTypeKey(ImmutableArray.Create(new AnonymousTypeKeyField("B", isKey: false, ignoreCase: false)))].Name); 557Assert.Equal("<>f__AnonymousType0", anonymousTypeMap0[new AnonymousTypeKey(ImmutableArray.Create(new AnonymousTypeKeyField("A", isKey: false, ignoreCase: false)))].Name); 558Assert.Equal("<>f__AnonymousType1", anonymousTypeMap0[new AnonymousTypeKey(ImmutableArray.Create(new AnonymousTypeKeyField("X", isKey: false, ignoreCase: false)))].Name); 559Assert.Equal("<>f__AnonymousType2", anonymousTypeMap0[new AnonymousTypeKey(ImmutableArray.Create(new AnonymousTypeKeyField("Y", isKey: false, ignoreCase: false)))].Name); 1112Assert.Equal("<>f__AnonymousType0", anonymousTypeMap0[new AnonymousTypeKey(ImmutableArray.Create(new AnonymousTypeKeyField("A", isKey: false, ignoreCase: false)))].Name); 1113Assert.Equal("<>f__AnonymousType1", anonymousTypeMap0[new AnonymousTypeKey(ImmutableArray.Create(new AnonymousTypeKeyField("B", isKey: false, ignoreCase: false)))].Name);

452edits: ImmutableArray.Create( 453new SemanticEdit(f0, f1, ImmutableArray.Create(InstrumentationKindExtensions.LocalStateTracing))));

577new CSharpCompilationReference(dummyCompilation1, ImmutableArray.Create("P")) , 578new CSharpCompilationReference(dummyCompilation2, ImmutableArray.Create("Q")), 579new CSharpCompilationReference(dummyCompilation3, ImmutableArray.Create("R")) 680compilation1.ToMetadataReference(ImmutableArray.Create("X")) 731compilation1.ToMetadataReference(ImmutableArray.Create("X")), 808var refA = comp.EmitToImageReference(aliases: ImmutableArray.Create("A2")); 858var refA1 = comp.EmitToImageReference(aliases: ImmutableArray.Create("A2")); 868var refA4 = comp.EmitToImageReference(aliases: ImmutableArray.Create("A5")); 944var refA1 = comp.EmitToImageReference(aliases: ImmutableArray.Create("A2")); 954var refA4 = comp.EmitToImageReference(aliases: ImmutableArray.Create("A5")); 1040var refA4 = comp.EmitToImageReference(aliases: ImmutableArray.Create("A5")); 1133var refA4 = comp.EmitToImageReference(aliases: ImmutableArray.Create("A5")); 1216var refA1 = comp.EmitToImageReference(aliases: ImmutableArray.Create("A2")); 1226var refA4 = comp.EmitToImageReference(aliases: ImmutableArray.Create("A5")); 1308var refA1 = comp.EmitToImageReference(aliases: ImmutableArray.Create("A2")); 1318var refA4 = comp.EmitToImageReference(aliases: ImmutableArray.Create("A5")); 1486references: new[] { new CSharpCompilationReference(libComp, ImmutableArray.Create("P")) }); 1562new CSharpCompilationReference(dummyCompilation1, ImmutableArray.Create("P")) , 1563new CSharpCompilationReference(dummyCompilation2, ImmutableArray.Create("Q")), 1564new CSharpCompilationReference(dummyCompilation3, ImmutableArray.Create("R")) 1868new CSharpCompilationReference(dummyCompilation1, ImmutableArray.Create("P")), 1869new CSharpCompilationReference(dummyCompilation2, ImmutableArray.Create("Q")), 1870new CSharpCompilationReference(dummyCompilation3, ImmutableArray.Create("R")), 2046new CSharpCompilationReference(dummyCompilation1, ImmutableArray.Create("P")), 2047new CSharpCompilationReference(dummyCompilation2, ImmutableArray.Create("Q")), 2048new CSharpCompilationReference(dummyCompilation3, ImmutableArray.Create("R")), 2049new CSharpCompilationReference(dummyCompilation4, ImmutableArray.Create("S")), 2694var libRef = lib.EmitToImageReference(aliases: ImmutableArray.Create("Q")); 3317var c = CreateCompilationWithMscorlib40(sources, new[] { SystemCoreRef.WithAliases(ImmutableArray.Create("A")) });

5510NamedTypeSymbol classYOfW = classY.ConstructIfGeneric(ImmutableArray.Create(TypeWithAnnotations.Create(classW))); 5517NamedTypeSymbol classYOfInt = classY.ConstructIfGeneric(ImmutableArray.Create(TypeWithAnnotations.Create(m.ContainingAssembly.GetSpecialType(SpecialType.System_Int32)))); 5526NamedTypeSymbol substNestedZ = classYOfInt.GetTypeMember("Z").ConstructIfGeneric(ImmutableArray.Create(TypeWithAnnotations.Create(classW)));

4905expectedBits = ImmutableArray.Create(addOne.GetValueOrDefault()).Concat(expectedBits);

1968namedArguments: ImmutableArray.Create(new KeyValuePair<WellKnownMember, TypedConstant>(

65new DesktopStrongNameProvider(ImmutableArray.Create(keyFilePath), strongNameFileSystem: new VirtualizedStrongNameFileSystem(_signingTempDirectory.Path)); 229ImmutableArray.Create(PathUtilities.CombineAbsoluteAndRelativePaths(keyFileDir, @"TempSubDir\")),

45return ImmutableArray.Create(s_CA9999_UseOfVariableThatStartsWithX); 240return ImmutableArray.Create(s_descriptor); 507get { return ImmutableArray.Create(desc1); } 659public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get { return ImmutableArray.Create(Rule); } } 801ImmutableArray.Create(SyntaxKind.EqualsValueClause)); 804ImmutableArray.Create(SyntaxKind.BaseConstructorInitializer)); 823}, ImmutableArray.Create(SyntaxKind.ArrowExpressionClause)); 834get { return ImmutableArray.Create(Descriptor1); } 885return ImmutableArray.Create(SupportedDescriptor); 1646get { return ImmutableArray.Create(ExpressionDescriptor); } 2245var syntaxKinds = ImmutableArray.Create(SyntaxKind.VariableDeclaration); 2246var operationKinds = ImmutableArray.Create(OperationKind.VariableDeclarator); 3266var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(new SymbolStartAnalyzer(topLevelAction: false, SymbolKind.NamedType)); 3312var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(new SymbolStartAnalyzer(topLevelAction: false, SymbolKind.NamedType)); 3358var tree1SemanticDiagnostics = await compilationWithAnalyzers.GetAnalyzerSemanticDiagnosticsAsync(semanticModel1, filterSpan: null, ImmutableArray.Create<DiagnosticAnalyzer>(analyzer1), CancellationToken.None); 3695var analyzersToQuery = singleAnalyzer ? ImmutableArray.Create<DiagnosticAnalyzer>(analyzer1) : allAnalyzers; 3814var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(analyzer); 3844public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get { return ImmutableArray.Create(Rule); } } 3885var options = new AnalyzerOptions(ImmutableArray.Create(additionalFile)); 3888var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(analyzer); 3936verifyAnalysisResult(analysisResult, analyzers, ImmutableArray.Create(additionalFile1), diagnosticSpan, additionalFilesHaveSamePaths); 3938verifyAnalysisResult(analysisResult, analyzers, ImmutableArray.Create(additionalFile2), diagnosticSpan, additionalFilesHaveSamePaths); 3940var singleAnalyzerArray = ImmutableArray.Create<DiagnosticAnalyzer>(analyzer1); 3942verifyAnalysisResult(analysisResult, singleAnalyzerArray, ImmutableArray.Create(additionalFile1), diagnosticSpan, additionalFilesHaveSamePaths); 3944verifyAnalysisResult(analysisResult, singleAnalyzerArray, ImmutableArray.Create(additionalFile2), diagnosticSpan, additionalFilesHaveSamePaths); 4012var singleAnalyzerArray = ImmutableArray.Create(analyzer); 4016verifyDiagnostics(reportedDiagnostics, singleAnalyzerArray, ImmutableArray.Create(additionalFile), diagnosticSpan, additionalFilesHaveSamePaths); 4078public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get { return ImmutableArray.Create(Rule); } } 4123public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get { return ImmutableArray.Create(Rule); } } 4230var compilationWithAnalyzers = compilation.WithAnalyzers(ImmutableArray.Create<DiagnosticAnalyzer>(analyzer)); 4315var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(analyzer); 4317var analyzerOptions = new AnalyzerOptions(ImmutableArray.Create<AdditionalText>(additionalTextFile)); 4398var analyzersArray = ImmutableArray.Create<DiagnosticAnalyzer>(analyzer);

718var analyzers = withSuppressor ? ImmutableArray.Create<DiagnosticAnalyzer>(analyzer1, suppressor) : ImmutableArray.Create<DiagnosticAnalyzer>(analyzer1); 722analyzers = withSuppressor ? ImmutableArray.Create<DiagnosticAnalyzer>(analyzer2, suppressor) : ImmutableArray.Create<DiagnosticAnalyzer>(analyzer2);

677var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(new CSharpCompilerDiagnosticAnalyzer()); 740var compilationWithAnalyzers = compilation.WithAnalyzers(ImmutableArray.Create(analyzer), analyzerOptions); 787var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(new CSharpCompilerDiagnosticAnalyzer()); 840var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(new SymbolStartAnalyzer(topLevelAction: false, SymbolKind.NamedType, OperationKind.VariableDeclaration)); 869var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(analyzer); 909var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(new CSharpCompilerDiagnosticAnalyzer()); 963var compilationWithAnalyzers = compilation.WithAnalyzers(ImmutableArray.Create<DiagnosticAnalyzer>(analyzer), AnalyzerOptions.Empty); 1189var compilationWithAnalyzers = compilation.WithAnalyzers(ImmutableArray.Create<DiagnosticAnalyzer>(compilerAnalyzer), AnalyzerOptions.Empty); 1249var compilationWithAnalyzers = compilation.WithAnalyzers(ImmutableArray.Create<DiagnosticAnalyzer>(analyzer), AnalyzerOptions.Empty); 1563var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(new CSharpCompilerDiagnosticAnalyzer()); 1598public override ImmutableArray<SuppressionDescriptor> SupportedSuppressions => ImmutableArray.Create(_descriptor); 1644var compilationWithAnalyzers = compilation.WithAnalyzers(ImmutableArray.Create<DiagnosticAnalyzer>(analyzer), AnalyzerOptions.Empty); 1823var compilationWithAnalyzers = compilation.WithAnalyzers(ImmutableArray.Create<DiagnosticAnalyzer>(analyzer), AnalyzerOptions.Empty); 1839public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor);

18802=> ImmutableArray.Create(Descriptor);

2120var ref1 = CreateCompilation(INumberBaseDefinition, assemblyName: "A").EmitToImageReference(aliases: ImmutableArray.Create("A")); 2298var ref1 = CreateCompilation(INumberBaseDefinition).EmitToImageReference(aliases: ImmutableArray.Create("A"));

3751=> ImmutableArray.Create(Descriptor); 4076=> ImmutableArray.Create(Descriptor); 4162=> ImmutableArray.Create(Descriptor); 4311=> ImmutableArray.Create(Descriptor); 4501=> ImmutableArray.Create(Descriptor); 4635=> ImmutableArray.Create(Descriptor); 4815=> ImmutableArray.Create(Descriptor); 4960=> ImmutableArray.Create(Descriptor); 5139=> ImmutableArray.Create(Descriptor); 5252=> ImmutableArray.Create(Descriptor); 5479=> ImmutableArray.Create(Descriptor); 5566=> ImmutableArray.Create(Descriptor); 5679=> ImmutableArray.Create(Descriptor); 5776=> ImmutableArray.Create(Descriptor); 5834=> ImmutableArray.Create(Descriptor); 5927=> ImmutableArray.Create(Descriptor);

26295=> ImmutableArray.Create(Descriptor); 26618=> ImmutableArray.Create(Descriptor); 26713=> ImmutableArray.Create(Descriptor); 26878=> ImmutableArray.Create(Descriptor); 27068=> ImmutableArray.Create(Descriptor); 27202=> ImmutableArray.Create(Descriptor); 27382=> ImmutableArray.Create(Descriptor); 27527=> ImmutableArray.Create(Descriptor); 27710=> ImmutableArray.Create(Descriptor);

78var serializedOptions = ImmutableArray.Create(KeyValuePair.Create(HideAdvancedMembers, options.MemberDisplayOptions.HideAdvancedMembers.ToString()));

249var additionalFilterTexts = ImmutableArray.Create(staticSymbol.Name);

64return (ImmutableArray.Create<ISymbol>(conversion), s_conversionProperties);

89var spans = ImmutableArray.Create(TextSpan.FromBounds(spanStart, spanEnd));

73var additionalLocations = ImmutableArray.Create(statement.GetLocation());

120var additionalLocations = ImmutableArray.Create(firstStatementLocation); 139var additionalUnnecessaryLocations = ImmutableArray.Create(location);

208var locations = ImmutableArray.Create(expression.GetLocation()); 217var additionalUnnecessaryLocations = ImmutableArray.Create(

52var locations = ImmutableArray.Create(invocationExpression.GetLocation()); 68var additionalUnnecessaryLocations = ImmutableArray.Create(

48var locations = ImmutableArray.Create(invocationExpression.GetLocation());

90var locations = ImmutableArray.Create(objectCreationExpression.GetLocation());

60var locations = ImmutableArray.Create(expression.GetLocation()); 69var additionalUnnecessaryLocations = ImmutableArray.Create( 100var locations = ImmutableArray.Create(expression.GetLocation()); 109var additionalUnnecessaryLocations = ImmutableArray.Create(

104var additionalLocations = ImmutableArray.Create(declaration.GetLocation()); 123var additionalLocations = ImmutableArray.Create(declaration.GetLocation());

140var additionalLocations = ImmutableArray.Create(syntaxNode.GetLocation());

423executableCodeBlocks: ImmutableArray.Create<SyntaxNode>(expressionBody),

313KeyValuePair.Create(newDocument.FilePath, ImmutableArray.Create(

1774=> ImmutableArray.Create(Descriptor);

15666var funcOfObjectNullable = funcOfT.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(objectType, NullableAnnotation.Annotated))); 15667var funcOfStringNullable = funcOfT.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(stringType, NullableAnnotation.Annotated))); 15668var funcOfStringNotNullable = funcOfT.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(stringType, NullableAnnotation.NotAnnotated)));

2051var options = new CSharpParseOptions(preprocessorSymbols: ImmutableArray.Create("CONDITIONAL"), documentationMode: DocumentationMode.None);

126ImmutableArray.Create(externAlias1)); 131ImmutableArray.Create(externAlias2));

5317var pathMap = ImmutableArray.Create(new KeyValuePair<string, string>(pathPrefix, "/_/")); 5353var pathMap = ImmutableArray.Create(new KeyValuePair<string, string>(pathPrefix, "/_/")); 5387var pathMap = ImmutableArray.Create(new KeyValuePair<string, string>(pathPrefix, "/_/")); 5496var pathMap = ImmutableArray.Create(new KeyValuePair<string, string>(pathPrefix, @"\_\")); 5531var pathMap = ImmutableArray.Create(new KeyValuePair<string, string>(pathPrefix, @"\_/")); 5573var pathMap = ImmutableArray.Create(new KeyValuePair<string, string>(pathPrefix, @"\_/")); 6014var pathMap = ImmutableArray.Create(new KeyValuePair<string, string>(pathPrefix, "/_/")); 6055var pathMap = ImmutableArray.Create(new KeyValuePair<string, string>(pathPrefix, "/_/")); 6117var pathMap = ImmutableArray.Create(new KeyValuePair<string, string>(directory2, "./"));

7748var substitutedC = c.WithTypeArguments(ImmutableArray.Create(TypeWithAnnotations.Create(handler)));

113178m1.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(a, NullableAnnotation.Annotated))), 113179m1.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(a, NullableAnnotation.NotAnnotated))), 113180m1.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(a, NullableAnnotation.Oblivious))) 113185m1.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(a, NullableAnnotation.Annotated))), 113186m1.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(a, NullableAnnotation.NotAnnotated))), 113187m1.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(a, NullableAnnotation.Oblivious))) 115860var c2 = cDefinition.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(cDefinition.TypeParameters.Single(), NullableAnnotation.NotAnnotated))); 115872var c3 = cDefinition.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(cDefinition.TypeParameters.Single(), NullableAnnotation.Annotated))); 115902var i1 = iDefinition.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(iDefinition.TypeParameters.Single(), NullableAnnotation.Annotated))); 115911var c2 = cDefinition.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(cDefinition.TypeParameters.Single(), NullableAnnotation.NotAnnotated))); 115923var i2b = i2.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(iDefinition.TypeParameters.Single(), NullableAnnotation.Annotated))); 115928var i2c = i2.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(i2.TypeParameters.Single(), NullableAnnotation.Annotated))); 115932var c3 = cDefinition.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(cDefinition.TypeParameters.Single(), NullableAnnotation.Annotated))); 115937var i3b = i3.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(i3.TypeParameters.Single(), NullableAnnotation.Annotated))); 115942var modifiers = ImmutableArray.Create(CSharpCustomModifier.CreateOptional(comp.GetSpecialType(SpecialType.System_Object))); 115943var c4 = cDefinition.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(cDefinition.TypeParameters.Single(), customModifiers: modifiers)));

5906var substitutedC = c.WithTypeArguments(ImmutableArray.Create(TypeWithAnnotations.Create(handler)));

6022=> ImmutableArray.Create(Descriptor); 6251=> ImmutableArray.Create(Descriptor); 6347=> ImmutableArray.Create(Descriptor); 6476=> ImmutableArray.Create(Descriptor); 6573=> ImmutableArray.Create(Descriptor); 6631=> ImmutableArray.Create(Descriptor); 6724=> ImmutableArray.Create(Descriptor); 6885=> ImmutableArray.Create(Descriptor);

6482=> ImmutableArray.Create(Descriptor); 6581=> ImmutableArray.Create(Descriptor); 6656=> ImmutableArray.Create(Descriptor); 6765=> ImmutableArray.Create(Descriptor); 6846=> ImmutableArray.Create(Descriptor); 6904=> ImmutableArray.Create(Descriptor); 6962=> ImmutableArray.Create(Descriptor); 7030=> ImmutableArray.Create(Descriptor); 7110=> ImmutableArray.Create(Descriptor); 7226=> ImmutableArray.Create(Descriptor); 7320=> ImmutableArray.Create(Descriptor); 7392=> ImmutableArray.Create(Descriptor); 7459=> ImmutableArray.Create(Descriptor);

181=> ImmutableArray.Create(Descriptor); 1203GeneratorDriver driver = CSharpGeneratorDriver.Create(ImmutableArray.Create(gen), parseOptions: parseOptions); 1275GeneratorDriver driver = CSharpGeneratorDriver.Create(ImmutableArray.Create(gen), parseOptions: parseOptions); 1826driver = driver.AddAdditionalTexts(ImmutableArray.Create<AdditionalText>(text2)); 4088driver = driver.AddGenerators(ImmutableArray.Create<ISourceGenerator>(generator2)); 4126driver = driver.AddGenerators(ImmutableArray.Create<ISourceGenerator>(generator2)); 4169driver = driver.AddGenerators(ImmutableArray.Create<ISourceGenerator>(generator2));

25builder.AddEntries(ImmutableArray.Create(1), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 26builder.AddEntries(ImmutableArray.Create(2), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 27builder.AddEntries(ImmutableArray.Create(3), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 79builder.AddEntries(ImmutableArray.Create(1), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 82builder.AddEntries(ImmutableArray.Create(6), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 148builder.AddEntries(ImmutableArray.Create(1), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 158builder.AddEntries(ImmutableArray.Create(1), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 169builder.AddEntries(ImmutableArray.Create(2), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 203builder.AddEntries(ImmutableArray.Create(1), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 204builder.AddEntries(ImmutableArray.Create(2), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 205builder.AddEntries(ImmutableArray.Create(3), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 206builder.AddEntries(ImmutableArray.Create(4), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 228builder.AddEntries(ImmutableArray.Create(1), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 229builder.AddEntries(ImmutableArray.Create(2), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 230builder.AddEntries(ImmutableArray.Create(3), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 312nodeBuilder.AddEntries(ImmutableArray.Create(4), EntryState.Removed, TimeSpan.Zero, emptyInputSteps, EntryState.Removed); 624AssertTableEntries(table2, new[] { (ImmutableArray.Create("B"), EntryState.Modified, 0) }); 625AssertTableEntries(table2.AsCached(), new[] { (ImmutableArray.Create("B"), EntryState.Cached, 0) }); 632var inputNode = new InputNode<int>((_) => ImmutableArray.Create(1)); 663var inputNode = new InputNode<int>((_) => ImmutableArray.Create(1)); 699var inputNode = new InputNode<int>((_) => ImmutableArray.Create(value)); 738var inputNode = new InputNode<int>((_) => ImmutableArray.Create(value)); 830var transformNode = new TransformNode<int, int>(inputNode, (i, ct) => ImmutableArray.Create(i)).WithTrackingName("TestStep"); 864var input2Node = new InputNode<int>((_) => ImmutableArray.Create(0)); 941var filterNode = new TransformNode<int, int>(transformNode, (i, ct) => i <= 2 ? ImmutableArray.Create(i) : ImmutableArray<int>.Empty, name: "Filter"); 972var inputNode = new InputNode<ImmutableArray<int>>(_ => ImmutableArray.Create(values)).WithTrackingName("Input"); 1001var inputNode = new InputNode<ImmutableArray<int>>(_ => ImmutableArray.Create(values)).WithTrackingName("Input"); 1029ImmutableArray<ImmutableArray<string>> values = ImmutableArray.Create(ImmutableArray.Create("class1"), ImmutableArray.Create("class2")); 1041values = ImmutableArray.Create(ImmutableArray.Create("class3"), ImmutableArray.Create("class2")); 1047AssertTableEntries(table.AsCached(), ImmutableArray.Create(("class2", EntryState.Cached, 0))); 1049values = ImmutableArray.Create(ImmutableArray.Create("class3"), ImmutableArray.Create("class4")); 1053AssertTableEntries(table, ImmutableArray.Create(("class4", EntryState.Modified, 0))); 1055AssertTableEntries(table.AsCached(), ImmutableArray.Create(("class4", EntryState.Cached, 0))); 1058values = ImmutableArray.Create(ImmutableArray.Create("class1")); 1064AssertTableEntries(table.AsCached(), ImmutableArray.Create(("class1", EntryState.Cached, 0))); 1099values = ImmutableArray.Create(ImmutableArray.Create("class1", "class1.1")); 1296_ => ImmutableArray.Create("1.1")

1191driver = driver.AddGenerators(ImmutableArray.Create(testGenerator2.AsSourceGenerator()));

2509ImmutableArray.Create((ITypeSymbol)null), 2522ImmutableArray.Create(true))); 2534memberLocations: ImmutableArray.Create(Location.None))); 2568ImmutableArray.Create("m1"))); 2577ImmutableArray.Create((ITypeSymbol)null), 2587ImmutableArray.Create((ITypeSymbol)null), 2588ImmutableArray.Create("m1"))); 2597ImmutableArray.Create((ITypeSymbol)compilation.GetSpecialType(SpecialType.System_Int32)), 2598ImmutableArray.Create((string)null))); 2606ImmutableArray.Create<ITypeSymbol>(compilation.GetSpecialType(SpecialType.System_Int32)), 2607ImmutableArray.Create("m1")); 2704Assert.Throws<ArgumentException>(() => comp.CreateAnonymousTypeSymbol(memberTypes, memberNames, memberNullableAnnotations: ImmutableArray.Create(CodeAnalysis.NullableAnnotation.NotAnnotated))); 3638var corlibReference = corlib.EmitToImageReference(aliases: ImmutableArray.Create("corlib")); 3666var otherReference = other.EmitToImageReference(aliases: ImmutableArray.Create("other"));

347var comp = CreateCompilation(source, new[] { new CSharpCompilationReference(lib, aliases: ImmutableArray.Create("A")) });

1043var ref1 = AssemblyMetadata.CreateFromFile(exe1.Path).GetReference(aliases: ImmutableArray.Create("A1")); 1044var ref2 = AssemblyMetadata.CreateFromFile(exe2.Path).GetReference(aliases: ImmutableArray.Create("A2")); 1252return ImmutableArray.Create(MetadataReference.CreateFromFile(path1)); 1256return ImmutableArray.Create(MetadataReference.CreateFromFile(path2)); 2271WithProperties(MetadataReferenceProperties.Assembly.WithAliases(ImmutableArray.Create("Z")).WithRecursiveAliases(true)), 2296WithProperties(MetadataReferenceProperties.Assembly.WithAliases(ImmutableArray.Create("Z")).WithRecursiveAliases(true)), 2326new[] { MscorlibRef_v4_0_30316_17626, bRef.WithAliases(ImmutableArray.Create("X")), aRef }, 2355var c = CreateSubmissionWithExactReferences(source, new[] { MscorlibRef_v4_0_30316_17626, bRef.WithAliases(ImmutableArray.Create("X")), aRef }, 2395bRef.WithAliases(ImmutableArray.Create("X")), 2397aRef.WithProperties(MetadataReferenceProperties.Assembly.WithAliases(ImmutableArray.Create("Y")).WithRecursiveAliases(true)), 2431bRef.WithAliases(ImmutableArray.Create("X")), 2432aRef.WithProperties(MetadataReferenceProperties.Assembly.WithAliases(ImmutableArray.Create("Y")).WithRecursiveAliases(true)), 2467bRef.WithAliases(ImmutableArray.Create("X")), 2469aRef.WithProperties(MetadataReferenceProperties.Assembly.WithAliases(ImmutableArray.Create("Y")).WithRecursiveAliases(true)), 2470aRef.WithProperties(MetadataReferenceProperties.Assembly.WithAliases(ImmutableArray.Create("Y")).WithRecursiveAliases(true)), 2508bRef.WithAliases(ImmutableArray.Create("X")), 2510dRef.WithProperties(MetadataReferenceProperties.Assembly.WithAliases(ImmutableArray.Create("Z")).WithRecursiveAliases(true)), 2554{ "B", bRef.WithAliases(ImmutableArray.Create("X")) } 2584var b3RefX = b3Ref.WithAliases(ImmutableArray.Create("X")); 2585var b3RefY = b3Ref.WithAliases(ImmutableArray.Create("Y"));

1259var ref1 = comp1.EmitToImageReference(aliases: ImmutableArray.Create("X")); 3872var libRef = CreateCompilation("", assemblyName: "lib").EmitToImageReference(aliases: ImmutableArray.Create("Alias"));

2135var compilation = CreateCompilationWithMscorlib40AndDocumentationComments(source, new[] { new CSharpCompilationReference(lib, aliases: ImmutableArray.Create("LibAlias")) }); 2165var compilation = CreateCompilationWithMscorlib40AndDocumentationComments(source, new[] { new CSharpCompilationReference(lib, aliases: ImmutableArray.Create("LibAlias")) }); 2195var compilation = CreateCompilationWithMscorlib40AndDocumentationComments(source, new[] { new CSharpCompilationReference(lib, aliases: ImmutableArray.Create("LibAlias")) });

373var aliasedCorlib = NetFramework.mscorlib.WithAliases(ImmutableArray.Create("Goo")); 413var libRef = libComp.EmitToImageReference(aliases: ImmutableArray.Create("myTask"));

2652return ImmutableArray.Create(MetadataReference.CreateFromFile(_data)); 2655return ImmutableArray.Create(MetadataReference.CreateFromFile(_core)); 2658return ImmutableArray.Create(MetadataReference.CreateFromFile(_system)); 2663return ImmutableArray.Create(MetadataReference.CreateFromFile(reference)); 2764return ImmutableArray.Create(MetadataReference.CreateFromFile(path, properties));

2542ImmutableArray.Create(TypeWithAnnotations.Create(intType)),

1536Assert.Throws<ArgumentNullException>("parameterTypes[0]", () => comp.CreateFunctionPointerTypeSymbol(returnType: @string, returnRefKind: RefKind.None, parameterTypes: ImmutableArray.Create((ITypeSymbol?)null)!, parameterRefKinds: ImmutableArray.Create(RefKind.None))); 1538Assert.Throws<ArgumentNullException>("callingConventionTypes[0]", () => comp.CreateFunctionPointerTypeSymbol(returnType: @string, returnRefKind: RefKind.None, parameterTypes: ImmutableArray<ITypeSymbol>.Empty, parameterRefKinds: ImmutableArray<RefKind>.Empty, callingConvention: SignatureCallingConvention.Unmanaged, ImmutableArray.Create((INamedTypeSymbol)null!))); 1539Assert.Throws<ArgumentException>(() => comp.CreateFunctionPointerTypeSymbol(returnType: @string, returnRefKind: RefKind.None, parameterTypes: ImmutableArray<ITypeSymbol>.Empty, parameterRefKinds: ImmutableArray.Create(RefKind.None))); 1542Assert.Throws<ArgumentException>(() => comp.CreateFunctionPointerTypeSymbol(returnType: @string, returnRefKind: RefKind.None, parameterTypes: ImmutableArray<ITypeSymbol>.Empty, parameterRefKinds: ImmutableArray<RefKind>.Empty, callingConvention: SignatureCallingConvention.Default, callingConventionTypes: ImmutableArray.Create(cdeclType)!)); 1543Assert.Throws<ArgumentException>(() => comp.CreateFunctionPointerTypeSymbol(returnType: @string, returnRefKind: RefKind.None, parameterTypes: ImmutableArray<ITypeSymbol>.Empty, parameterRefKinds: ImmutableArray<RefKind>.Empty, callingConvention: SignatureCallingConvention.StdCall, callingConventionTypes: ImmutableArray.Create(cdeclType)!)); 1544Assert.Throws<ArgumentException>(() => comp.CreateFunctionPointerTypeSymbol(returnType: @string, returnRefKind: RefKind.None, parameterTypes: ImmutableArray<ITypeSymbol>.Empty, parameterRefKinds: ImmutableArray<RefKind>.Empty, callingConvention: SignatureCallingConvention.FastCall, callingConventionTypes: ImmutableArray.Create(cdeclType)!)); 1545Assert.Throws<ArgumentException>(() => comp.CreateFunctionPointerTypeSymbol(returnType: @string, returnRefKind: RefKind.None, parameterTypes: ImmutableArray<ITypeSymbol>.Empty, parameterRefKinds: ImmutableArray<RefKind>.Empty, callingConvention: SignatureCallingConvention.CDecl, callingConventionTypes: ImmutableArray.Create(cdeclType)!)); 1546Assert.Throws<ArgumentException>(() => comp.CreateFunctionPointerTypeSymbol(returnType: @string, returnRefKind: RefKind.None, parameterTypes: ImmutableArray<ITypeSymbol>.Empty, parameterRefKinds: ImmutableArray<RefKind>.Empty, callingConvention: SignatureCallingConvention.ThisCall, callingConventionTypes: ImmutableArray.Create(cdeclType)!)); 1547Assert.Throws<ArgumentException>(() => comp.CreateFunctionPointerTypeSymbol(returnType: @string, returnRefKind: RefKind.None, parameterTypes: ImmutableArray<ITypeSymbol>.Empty, parameterRefKinds: ImmutableArray<RefKind>.Empty, callingConvention: SignatureCallingConvention.Unmanaged, callingConventionTypes: ImmutableArray.Create(@string)!)); 1587ImmutableArray.Create((ITypeSymbol)@string), 1588ImmutableArray.Create(RefKind.In)); 1604ImmutableArray.Create((ITypeSymbol)@string), 1605ImmutableArray.Create(RefKind.Out)); 1622ImmutableArray.Create((ITypeSymbol)@string), 1623ImmutableArray.Create(RefKind.Out)); 1660ptr = comp.CreateFunctionPointerTypeSymbol(@string, returnRefKind: RefKind.None, parameterTypes: ImmutableArray<ITypeSymbol>.Empty, parameterRefKinds: ImmutableArray<RefKind>.Empty, SignatureCallingConvention.Unmanaged, ImmutableArray.Create(cdeclType)!); 1973callingConventionTypes: ImmutableArray.Create(testConvention.GetPublicSymbol()!))); 1989var funcPtrConventionThisCallWithThiscallMod = createTypeSymbol(customModifiers: ImmutableArray.Create(thiscallMod), CallingConvention.ThisCall); 1991var funcPtrThiscall = createTypeSymbol(customModifiers: ImmutableArray.Create(thiscallMod)); 2091var funcPtrCallConv = createTypeSymbol(customModifiers: ImmutableArray.Create(callConvMod)); 2143var funcPtrThiscallOnTypeThiscallOnRef = createTypeSymbol(typeCustomModifiers: ImmutableArray.Create(thiscallMod), refCustomModifiers: ImmutableArray.Create(thiscallMod)); 2144var funcPtrThiscallOnTypeStdcallOnRef = createTypeSymbol(typeCustomModifiers: ImmutableArray.Create(thiscallMod), refCustomModifiers: ImmutableArray.Create(stdcallMod)); 2145var funcPtrStdcallOnTypeThiscallOnRef = createTypeSymbol(typeCustomModifiers: ImmutableArray.Create(stdcallMod), refCustomModifiers: ImmutableArray.Create(thiscallMod));

2633var derivedIndexerGroup = derivedIndexers.Concat(ImmutableArray.Create<PropertySymbol>(baseIndexer3)); 2735ImmutableArray.Create<PropertySymbol>(publicIndexer).GetPublicSymbols(),

274var implementedByGetter2 = ImmutableArray.Create<MethodSymbol>(interfaceProperty3.GetMethod); 277var implementedBySetter2 = ImmutableArray.Create<MethodSymbol>(interfaceProperty2.SetMethod);

1942var refA1 = compA1.EmitToImageReference(aliases: ImmutableArray.Create("A")); 1946var refB1 = compB1.EmitToImageReference(aliases: ImmutableArray.Create("B")); 1977comp = CreateCompilation(sourceProgram, references: new[] { refA1, compB2.EmitToImageReference(aliases: ImmutableArray.Create("B")), refBImpl }); 1984comp = CreateCompilation(sourceProgram, references: new[] { refA1, new CSharpCompilationReference(compB2, aliases: ImmutableArray.Create("B")), refBImpl }); 2006var refA1 = compA1.EmitToImageReference(aliases: ImmutableArray.Create("A")); 2010var refB1 = compB1.EmitToImageReference(aliases: ImmutableArray.Create("B")); 2041comp = CreateCompilation(sourceProgram, references: new[] { refA1, compB2.EmitToImageReference(aliases: ImmutableArray.Create("B")), refBImpl }); 2048comp = CreateCompilation(sourceProgram, references: new[] { refA1, new CSharpCompilationReference(compB2, aliases: ImmutableArray.Create("B")), refBImpl });

1098var ref1 = CreateCompilation(source1).ToMetadataReference(aliases: ImmutableArray.Create("Alias1")); 1099var ref2 = CreateCompilation(source1).ToMetadataReference(aliases: ImmutableArray.Create("Alias2"));

84var ofD = ImmutableArray.Create<TypeSymbol>(D); 98var ofV = ImmutableArray.Create<TypeSymbol>(D_MofV.TypeParameters[0]);

278var i_a_v2 = compilation1_v2.GetTypeByMetadataName("I`1").Construct(ImmutableArray.Create<TypeSymbol>(a_v2)); 299var i_ct_v2 = compilation1_v2.GetTypeByMetadataName("I`1").Construct(ImmutableArray.Create<TypeSymbol>(c.TypeParameters[0]));

38s_goo1 = comp.EmitToImageReference(aliases: ImmutableArray.Create("Bar")); 63s_goo2 = comp.EmitToImageReference(aliases: ImmutableArray.Create("Bar")); 217var goo1Alias = outputMetadata.GetReference(aliases: ImmutableArray.Create("Baz")); 317var goo1Alias = comp.EmitToImageReference(aliases: ImmutableArray.Create("global")); 396var ref1 = comp1.EmitToImageReference(aliases: ImmutableArray.Create("X")); 399var ref2 = comp2.EmitToImageReference(aliases: ImmutableArray.Create("X")); 471var libRef = new CSharpCompilationReference(CreateCompilation(libSource, assemblyName: "lib"), aliases: ImmutableArray.Create("A"));

841ImmutableArray.Create(new KeyValuePair<string, string>(root2, root1)));

153var customModifiers = ImmutableArray.Create(CSharpCustomModifier.CreateOptional(intType)); 161var typeMap = new TypeMap(ImmutableArray.Create(typeParamType), ImmutableArray.Create(TypeWithAnnotations.Create(intType)));

1782=> ImmutableArray.Create(Descriptor); 4835=> ImmutableArray.Create(Descriptor);

7343new CSharpCompilationReference(forwardedTypes1, aliases: ImmutableArray.Create("FT1")) 7362new CSharpCompilationReference(forwardedTypes1, ImmutableArray.Create("FT1"))

117ImmutableArray.Create(symbol)));

1981private static readonly ImmutableArray<MetadataReference> s_scriptRefs = ImmutableArray.Create(MscorlibRef_v4_0_30316_17626);

151return ImmutableArray.Create(name);

29var rules = ImmutableArray.Create(baseIndentationRule).AddRange(CSharpSyntaxFormatting.Instance.GetDefaultFormattingRules());

226editor.SetStatements(functionDeclaration, ImmutableArray.Create(statement));

567dictionary1.Add(keySelector(value), ImmutableArray.Create(value));

66return Task.FromResult(ImmutableArray.Create<CodeActionOperation>(committerOperation));

37var textSpans = ImmutableArray.Create(new TextSpan(0, text.Length));

36var textSpans = ImmutableArray.Create(new TextSpan(0, text.Length));

25return Task.FromResult(ImmutableArray.Create(

168var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(documentDiagnosticAnalyzer); 199var generators = ImmutableArray.Create<ISourceGenerator>(generator); 202var codeFixes = ImmutableArray.Create<CodeFixProvider>(codeFix); 508: this(ImmutableArray.Create((diagnosticId, category))) 518: this(ImmutableArray.Create(MockFixer.Id)) 551: this(ImmutableArray.Create(MockFixer.Id)) 616var fixableDiagnosticIds = ImmutableArray.Create(MockFixer.Id); 747var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(diagnosticAnalyzer); 798var analyzer = new MockAnalyzerReference.MockDiagnosticAnalyzer(ImmutableArray.Create(diagnosticId));

1267var getMembers = ImmutableArray.Create(getField); 1292var getMembers = ImmutableArray.Create(getField);

403var addStatements = ImmutableArray.Create<SyntaxNode>(VB.SyntaxFactory.ParseExecutableStatement("Console.WriteLine(0)")); 404var removeStatements = ImmutableArray.Create<SyntaxNode>(VB.SyntaxFactory.ParseExecutableStatement("Console.WriteLine(1)")); 405var raiseStatements = ImmutableArray.Create<SyntaxNode>(VB.SyntaxFactory.ParseExecutableStatement("Console.WriteLine(2)")); 1340var getMembers = ImmutableArray.Create(getField);

367var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(analyzer);

117OpenParenToken.With(trailingTrivia: ImmutableArray.Create(SpaceTrivia(2))),

205=> new(path.With(leadingTrivia: ImmutableArray.Create(inTrivia.HasValue ? inTrivia.Value : InTrivia)), colon, line);

139var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(new CommonDiagnosticAnalyzers.NotConfigurableDiagnosticAnalyzer());

29var references = ImmutableArray.Create(myPackage); 39var references = ImmutableArray.Create(myPackage); 49var references = ImmutableArray.Create(PackageReference("MyPackage.dll")); 51var differentReference = ImmutableArray.Create(ProjectReference("MyProject.csproj")); 60var references = ImmutableArray.Create(ProjectReference(mylibraryPath));

224ImmutableArray.Create(type));

246ImmutableArray.Create(type));

854? ImmutableArray.Create(symbol) 855: ImmutableArray<TNamespaceOrTypeSymbol>.CastUp(ImmutableArray.Create((TNamedTypeSymbol)symbol));

186=> HasOneItem ? ImmutableArray.Create(_one) : _many;

3131 => ImmutableArray.Create(_item0),

567dictionary1.Add(keySelector(value), ImmutableArray.Create(value));

22var identifiers = ImmutableArray.Create("Route");

68var quickInfo = await QuickInfoUtilities.CreateQuickInfoItemAsync(services, semanticModel, span: default, ImmutableArray.Create(symbol), options, cancellationToken).ConfigureAwait(false);

28return Task.FromResult(ImmutableArray.Create<CodeActionOperation>(

80return Task.FromResult(ImmutableArray.Create<CodeActionOperation>( 88return Task.FromResult(ImmutableArray.Create(operation));

34=> Task.FromResult(ImmutableArray.Create(_installPackageOperation));

25return Task.FromResult(ImmutableArray.Create<CodeActionOperation>(

209=> With(filterRules: ImmutableArray.Create(rule)); 212=> With(commitRules: ImmutableArray.Create(rule));

100return Task.FromResult(ImmutableArray.Create(new SymbolAndSelectionInfo(Symbol: type, Preselect: !isArray)));

99ProjectsToRestart = runningProjects.Keys.ToImmutableDictionary(keySelector: static p => p, elementSelector: static p => ImmutableArray.Create(p)),

163var diagnostics = ImmutableArray.Create(new EmbeddedDiagnostic(

96var fields = ImmutableArray.Create(field);

20var rules = ImmutableArray.Create(formattingRuleFactory.CreateRule(document, position));

67var additionalLocations = ImmutableArray.Create(member.GetLocation());

115var additionalLocations = ImmutableArray.Create(binaryLike.GetLocation());

74ImmutableArray.Create(node.GetLocation()));

107var additionalLocations = ImmutableArray.Create(

179var locations = ImmutableArray.Create(objectCreationExpression.GetLocation());

132var additionalLocations = ImmutableArray.Create(invocation.GetLocation());

120var nodes = ImmutableArray.Create<SyntaxNode>(containingStatement).AddRange(matches.Select(m => m.Statement)); 124var locations = ImmutableArray.Create(objectCreationExpression.GetLocation());

215? ImmutableArray.Create(disposeMethod) : default;

59var kinds = ImmutableArray.Create(new SymbolKindOrTypeKind(MethodKind.Ordinary)); 60var modifiers = ImmutableArray.Create(new ModifierKind(ModifierKindEnum.IsAsync)); 78var kinds = ImmutableArray.Create(new SymbolKindOrTypeKind(MethodKind.Ordinary)); 79var modifiers = ImmutableArray.Create(new ModifierKind(ModifierKindEnum.IsAsync)); 88var kinds = ImmutableArray.Create(new SymbolKindOrTypeKind(MethodKind.Ordinary));

69var rules = ImmutableArray.Create(GetMultiLineFormattingRule());

41var diagnosticAnalyzers = ImmutableArray.Create<DiagnosticAnalyzer>(DiagnosticAnalyzer);

191var debugInfos = ImmutableArray.Create(

16var capabilities = ImmutableArray.Create("Baseline"); 27var capabilities = ImmutableArray.Create("BaseLine"); 61var capabilities = ImmutableArray.Create(name);

943var openDocumentIds = open ? ImmutableArray.Create(designTimeOnlyDocumentId) : []; 953var activeStatements = ImmutableArray.Create( 1638var activeStatements = ImmutableArray.Create( 2661var trackedActiveSpans = ImmutableArray.Create( 3127var activeStatements = ImmutableArray.Create( 3359var activeStatements = ImmutableArray.Create(new ManagedActiveStatementDebugInfo( 4664var activeStatements = ImmutableArray.Create(

257var newActiveStatementsInChangedDocuments = ImmutableArray.Create( 379var newActiveStatementsInChangedDocuments = ImmutableArray.Create( 567var newActiveStatementsInChangedDocuments = ImmutableArray.Create(

132var rudeEdits = ImmutableArray.Create(new ProjectDiagnostics(document.Project.Id,

113var activeSpans1 = ImmutableArray.Create( 190var deltas = ImmutableArray.Create(new ManagedHotReloadUpdate( 211var diagnostics = ImmutableArray.Create(new ProjectDiagnostics(project.Id, [documentDiagnostic, projectDiagnostic])); 212var documentsWithRudeEdits = ImmutableArray.Create(new ProjectDiagnostics(project.Id, []));

854? ImmutableArray.Create(symbol) 855: ImmutableArray<TNamespaceOrTypeSymbol>.CastUp(ImmutableArray.Create((TNamedTypeSymbol)symbol));

186=> HasOneItem ? ImmutableArray.Create(_one) : _many;

3131 => ImmutableArray.Create(_item0),

567dictionary1.Add(keySelector(value), ImmutableArray.Create(value));

57{ WellKnownTags.Public, ImmutableArray.Create(LSP.CompletionItemKind.Keyword) }, 58{ WellKnownTags.Protected, ImmutableArray.Create(LSP.CompletionItemKind.Keyword) }, 59{ WellKnownTags.Private, ImmutableArray.Create(LSP.CompletionItemKind.Keyword) }, 60{ WellKnownTags.Internal, ImmutableArray.Create(LSP.CompletionItemKind.Keyword) }, 61{ WellKnownTags.File, ImmutableArray.Create(LSP.CompletionItemKind.File) }, 62{ WellKnownTags.Project, ImmutableArray.Create(LSP.CompletionItemKind.File) }, 63{ WellKnownTags.Folder, ImmutableArray.Create(LSP.CompletionItemKind.Folder) }, 64{ WellKnownTags.Assembly, ImmutableArray.Create(LSP.CompletionItemKind.File) }, 65{ WellKnownTags.Class, ImmutableArray.Create(LSP.CompletionItemKind.Class) }, 66{ WellKnownTags.Constant, ImmutableArray.Create(LSP.CompletionItemKind.Constant) }, 68{ WellKnownTags.Enum, ImmutableArray.Create(LSP.CompletionItemKind.Enum) }, 69{ WellKnownTags.EnumMember, ImmutableArray.Create(LSP.CompletionItemKind.EnumMember) }, 70{ WellKnownTags.Event, ImmutableArray.Create(LSP.CompletionItemKind.Event) }, 72{ WellKnownTags.Field, ImmutableArray.Create(LSP.CompletionItemKind.Field) }, 73{ WellKnownTags.Interface, ImmutableArray.Create(LSP.CompletionItemKind.Interface) }, 74{ WellKnownTags.Intrinsic, ImmutableArray.Create(LSP.CompletionItemKind.Text) }, 75{ WellKnownTags.Keyword, ImmutableArray.Create(LSP.CompletionItemKind.Keyword) }, 76{ WellKnownTags.Label, ImmutableArray.Create(LSP.CompletionItemKind.Text) }, 77{ WellKnownTags.Local, ImmutableArray.Create(LSP.CompletionItemKind.Variable) }, 79{ WellKnownTags.Method, ImmutableArray.Create(LSP.CompletionItemKind.Method) }, 80{ WellKnownTags.Module, ImmutableArray.Create(LSP.CompletionItemKind.Module) }, 81{ WellKnownTags.Operator, ImmutableArray.Create(LSP.CompletionItemKind.Operator) }, 82{ WellKnownTags.Parameter, ImmutableArray.Create(LSP.CompletionItemKind.Variable) }, 83{ WellKnownTags.Property, ImmutableArray.Create(LSP.CompletionItemKind.Property) }, 84{ WellKnownTags.RangeVariable, ImmutableArray.Create(LSP.CompletionItemKind.Variable) }, 85{ WellKnownTags.Reference, ImmutableArray.Create(LSP.CompletionItemKind.Reference) }, 86{ WellKnownTags.Structure, ImmutableArray.Create(LSP.CompletionItemKind.Struct) }, 87{ WellKnownTags.TypeParameter, ImmutableArray.Create(LSP.CompletionItemKind.TypeParameter) }, 88{ WellKnownTags.Snippet, ImmutableArray.Create(LSP.CompletionItemKind.Snippet) }, 89{ WellKnownTags.Error, ImmutableArray.Create(LSP.CompletionItemKind.Text) }, 90{ WellKnownTags.Warning, ImmutableArray.Create(LSP.CompletionItemKind.Text) }, 91{ WellKnownTags.StatusInformation, ImmutableArray.Create(LSP.CompletionItemKind.Text) }, 92{ WellKnownTags.AddReference, ImmutableArray.Create(LSP.CompletionItemKind.Text) }, 93{ WellKnownTags.NuGet, ImmutableArray.Create(LSP.CompletionItemKind.Text) } 104{ WellKnownTags.Deprecated, ImmutableArray.Create(LSP.CompletionItemTag.Deprecated) },

119var codeActionPathList = ImmutableArray.Create(codeAction.Title);

55return ImmutableArray.Create(new PreviousPullResult(diagnosticsParams.PreviousResultId, diagnosticsParams.TextDocument));

81return ImmutableArray.Create(new PreviousPullResult(diagnosticsParams.PreviousResultId, diagnosticsParams.TextDocument));

85return ImmutableArray.Create(codeSnippetsElement);

28return ImmutableArray.Create(new PreviousPullResult(requestParams.PreviousResultId, requestParams.TextDocument));

381return Task.FromResult(ImmutableArray.Create(

281return ImmutableArray.Create<V>((V)_value);

854? ImmutableArray.Create(symbol) 855: ImmutableArray<TNamespaceOrTypeSymbol>.CastUp(ImmutableArray.Create((TNamedTypeSymbol)symbol));

186=> HasOneItem ? ImmutableArray.Create(_one) : _many;

3131 => ImmutableArray.Create(_item0),

567dictionary1.Add(keySelector(value), ImmutableArray.Create(value));

88return ImmutableArray.Create(operation);

65var diagnostics = ImmutableArray.Create(diagnostic ?? context.Diagnostics[0]);

41return ImmutableDictionary.CreateRange([KeyValuePair.Create(document, ImmutableArray.Create(decl.FullSpan))]); 67return ImmutableDictionary.CreateRange([KeyValuePair.Create(document, ImmutableArray.Create(decl.FullSpan))]);

80var parameters = ImmutableArray.Create(CodeGenerationSymbolFactory.CreateParameterSymbol(

567dictionary1.Add(keySelector(value), ImmutableArray.Create(value));

281return ImmutableArray.Create<V>((V)_value);

854? ImmutableArray.Create(symbol) 855: ImmutableArray<TNamespaceOrTypeSymbol>.CastUp(ImmutableArray.Create((TNamedTypeSymbol)symbol));

186=> HasOneItem ? ImmutableArray.Create(_one) : _many;

3131 => ImmutableArray.Create(_item0),

567dictionary1.Add(keySelector(value), ImmutableArray.Create(value));

88return ImmutableArray.Create(operation);

91var key = compilation.GetDeterministicKey(additionalTexts: ImmutableArray.Create<AdditionalText>(additionalText));

196var key = compilation.GetDeterministicKey(additionalTexts: ImmutableArray.Create<AdditionalText>(additionalText));

516.WithInstrumentationKinds(ImmutableArray.Create(kind)); 580(string, string) => ImmutableArray.Create(KeyValuePair.Create(pathMapFrom, pathMapTo)), 728(string, string) => ImmutableArray.Create(KeyValuePair.Create(pathMapFrom, pathMapTo)), 735ImmutableArray.Create<AdditionalText>(additionalText), 760ImmutableArray.Create<AdditionalText>(additionalText));

281return ImmutableArray.Create<V>((V)_value);

854? ImmutableArray.Create(symbol) 855: ImmutableArray<TNamespaceOrTypeSymbol>.CastUp(ImmutableArray.Create((TNamedTypeSymbol)symbol));

186=> HasOneItem ? ImmutableArray.Create(_one) : _many;

3131 => ImmutableArray.Create(_item0),

567dictionary1.Add(keySelector(value), ImmutableArray.Create(value));

88return ImmutableArray.Create(operation);

478var modules = (moduleBuilder != null) ? moduleBuilder.ToImmutable() : ImmutableArray.Create(manifestModule);

29MetadataReferenceProperties.Assembly.WithAliases(ImmutableArray.Create("<implicit>")); 160return ImmutableArray.Create(result); 169return ImmutableArray.Create(CreateFromFile(resolvedPath, properties)); 180return ImmutableArray.Create(CreateFromFile(path, properties)); 189return ImmutableArray.Create(result);

239MetadataReferenceProperties.Assembly.WithAliases(ImmutableArray.Create("<host>")).WithRecursiveAliases(true);

17private static readonly MetadataReferenceProperties s_resolvedMissingAssemblyReferenceProperties = MetadataReferenceProperties.Assembly.WithAliases(ImmutableArray.Create("<implicit>")); 53return ImmutableArray.Create(MetadataReference.CreateFromFile(reference, properties));

30new RelativePathResolver(ImmutableArray.Create(directory.Path), directory.Path), 50searchPaths: ImmutableArray.Create(directory.Path),

87Assert.Throws<ArgumentNullException>("references[0]", () => options.WithReferences(ImmutableArray.Create((MetadataReference)null))); 93Assert.Throws<ArgumentNullException>("references[0]", () => options.WithReferences(ImmutableArray.Create((Assembly)null))); 99Assert.Throws<ArgumentNullException>("references[0]", () => options.WithReferences(ImmutableArray.Create((string)null))); 129Assert.Throws<ArgumentNullException>("imports[0]", () => options.AddImports(ImmutableArray.Create((string)null))); 150Assert.Throws<ArgumentNullException>("imports[0]", () => options.WithImports(ImmutableArray.Create((string)null)));

35get { return ImmutableArray.Create(BoxingDescriptor); }

649public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(DiagnosticDescriptor); 679ImmutableArray.Create(Rule); 718ImmutableArray.Create(Rule); 743public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(DummyRule); 760public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule); 785ImmutableArray.Create(Rule); 821public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 832public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create((DiagnosticDescriptor)null); 852public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 873public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 896public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 959public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 998public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule); 1037public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule); 1069public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 1102public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 1136public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 1199public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 1327public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 1385public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 1416public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 1461public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 1562ImmutableArray.Create(ClassDeclarationSyntaxKind)); 1691public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule); 1855public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(ParameterDescriptor); 2169=> ImmutableArray.Create(SuppressionDescriptor); 2231=> ImmutableArray.Create(SuppressionDescriptor); 2274=> ImmutableArray.Create(_descriptor); 2302=> ImmutableArray.Create(_supportedDescriptor); 2334=> ImmutableArray.Create(_supportedDescriptor); 2416public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(_rule); 2482public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 2535public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 2563public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(s_descriptor); 2595public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 2641public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 2682public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(s_descriptor); 2730public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(s_descriptor); 2878public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 2925public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(s_descriptor); 3009public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(s_descriptor); 3099public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(s_descriptor); 3240public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(_descriptor);

404builder.Add(LanguageNames.CSharp, ImmutableArray.Create(GetCompilerDiagnosticAnalyzer(LanguageNames.CSharp))); 405builder.Add(LanguageNames.VisualBasic, ImmutableArray.Create(GetCompilerDiagnosticAnalyzer(LanguageNames.VisualBasic))); 412return new AnalyzerImageReference(ImmutableArray.Create(analyzer), display: analyzer.GetType().FullName); 418builder.Add(LanguageNames.CSharp, ImmutableArray.Create(GetCompilerDiagnosticAnalyzerReference(LanguageNames.CSharp))); 419builder.Add(LanguageNames.VisualBasic, ImmutableArray.Create(GetCompilerDiagnosticAnalyzerReference(LanguageNames.VisualBasic)));

40get { return ImmutableArray.Create(UseArrayEmptyDescriptor); }

31get { return ImmutableArray.Create(FieldCouldBeReadOnlyDescriptor); }

31get { return ImmutableArray.Create(LocalCouldBeConstDescriptor); }

94get { return ImmutableArray.Create(ExpressionDescriptor); } 136get { return ImmutableArray.Create(BigForDescriptor); } 622get { return ImmutableArray.Create(SeventeenDescriptor); } 659get { return ImmutableArray.Create(NullArgumentsDescriptor); } 744get { return ImmutableArray.Create(DoNotUseMemberAssignmentDescriptor); } 786get { return ImmutableArray.Create(DoNotUseLargeListOfArrayInitializersDescriptor); } 1174public sealed override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(EqualsValueDescriptor); 1218get { return ImmutableArray.Create(NoneOperationDescriptor); } 1562=> ImmutableArray.Create(BinaryUserDefinedOperatorDescriptor); 1886get { return ImmutableArray.Create(InvalidConversionExpressionDescriptor); } 1918get { return ImmutableArray.Create(ForLoopConditionCrashDescriptor); } 2043get { return ImmutableArray.Create(LiteralDescriptor); } 2072=> ImmutableArray.Create(OperationActionDescriptor); 2100=> ImmutableArray.Create(OperationActionDescriptor); 2132=> ImmutableArray.Create(GetOperationDescriptor);

34return ImmutableArray.Create(s_rule); 84return ImmutableArray.Create(s_rule); 109return ImmutableArray.Create(s_rule); 131return ImmutableArray.Create(s_rule); 196return ImmutableArray.Create(s_rule); 235return ImmutableArray.Create(s_rule); 271return ImmutableArray.Create(s_rule);

76return ImmutableArray.Create(DefaultDiagnostic);

322var peImage = compilation.EmitToArray(EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage)));

53return map.TryGetValue(reference, out var result) ? ImmutableArray.Create(result) : ImmutableArray<PortableExecutableReference>.Empty;

96return ImmutableArray.Create((hint, string.IsNullOrWhiteSpace(source) 107return ImmutableArray.Create((hint, string.IsNullOrWhiteSpace(source)

854? ImmutableArray.Create(symbol) 855: ImmutableArray<TNamespaceOrTypeSymbol>.CastUp(ImmutableArray.Create((TNamedTypeSymbol)symbol));

186=> HasOneItem ? ImmutableArray.Create(_one) : _many;

3131 => ImmutableArray.Create(_item0),

567dictionary1.Add(keySelector(value), ImmutableArray.Create(value));

109var set = AnalyzerConfigSet.Create(ImmutableArray.Create(config)); 131var set = AnalyzerConfigSet.Create(ImmutableArray.Create(config)); 2371var set = AnalyzerConfigSet.Create(ImmutableArray.Create(config)); 2386var set = AnalyzerConfigSet.Create(ImmutableArray.Create(config));

313return ImmutableArray.Create<FullyPopulateRaceHelper>(new FullyPopulateRaceHelper()); 356return ImmutableArray.Create<FullyPopulateRaceHelper>(new FullyPopulateRaceHelper());

24a = ImmutableArray.Create<int>(2); 116var singleton1 = ImmutableArray.Create<int>(1); 117var singleton2 = ImmutableArray.Create<int>(2); 144Assert.Equal(1, ImmutableArray.Create<int>(1).Single()); 160Assert.Equal(1, ImmutableArray.Create<int>(1).Single((x, a) => x == a, 1)); 377AssertEx.Equal(new[] { 10 }, ImmutableArray.Create(1).SelectAsArray(i => 10 * i)); 401var single1 = ImmutableArray.Create(1); 402var single2 = ImmutableArray.Create(10); 403var single3 = ImmutableArray.Create(11); 433var single1 = ImmutableArray.Create(1); 434var single2 = ImmutableArray.Create(10); 435var single3 = ImmutableArray.Create(13); 478Assert.True(a.WhereAsArray(i => i == 0).SequenceEqual(ImmutableArray.Create<int>(0))); 480Assert.True(a.WhereAsArray(i => i == 5).SequenceEqual(ImmutableArray.Create<int>(5))); 495Assert.Same(x, ImmutableArray.Create<object>(x).WhereAsArray((o, arg) => o == arg, x)[0]); 565Assert.False(ImmutableArray.Create(1).HasDuplicates()); 566Assert.False(ImmutableArray.Create(1).HasDuplicates(comparer)); 567Assert.False(ImmutableArray.Create(1).HasDuplicates(i => i + 1));

68public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(s_rule);

60var analyzers = ImmutableArray.Create(analyzer);

388return ImmutableArray.Create(_descriptor);

37arguments = ImmutableArray.Create((IOperation)null); 45arguments = ImmutableArray.Create((IOperation)null); 55arguments = ImmutableArray.Create((IOperation)null); 56argumentNames = ImmutableArray.Create(name); 57argumentRefKinds = ImmutableArray.Create(refKind);

252var lambdas = ImmutableArray.Create(new LambdaDebugInfo(20, new DebugId(0, 0), LambdaDebugInfo.StaticClosureOrdinal)); 654(LocalName: "a", SlotIndex: 1, ScopeStart: 0, ScopeEnd: 0, Names: ImmutableArray.Create("e")),

67TestProperty((old, value) => old.WithInstrumentationKinds(value), opt => opt.InstrumentationKinds, ImmutableArray.Create(InstrumentationKind.TestCoverage)); 127instrumentationKinds: ImmutableArray.Create(InstrumentationKind.TestCoverage)); 141instrumentationKinds: ImmutableArray.Create(InstrumentationKind.TestCoverage),

38var instrumentation = new MethodInstrumentation() { Kinds = ImmutableArray.Create(InstrumentationKind.TestCoverage) }; 47instrumentation: new MethodInstrumentation() { Kinds = ImmutableArray.Create(InstrumentationKindExtensions.LocalStateTracing) })); 50instrumentation: new MethodInstrumentation() { Kinds = ImmutableArray.Create((InstrumentationKind)123) }));

48Verify(OneOrMany.Create(ImmutableArray.Create(2)), 2); 51Verify(new OneOrMany<int>(ImmutableArray.Create(2)), 2); 72Verify(OneOrMany.Create(ImmutableArray.Create(1)).Add(4), 1, 4); 73Verify(OneOrMany.Create(ImmutableArray.Create(1)), 1); 86Assert.True(OneOrMany.Create(ImmutableArray.Create(1)).Contains(1)); 87Assert.False(OneOrMany.Create(ImmutableArray.Create(1)).Contains(0)); 111Verify(OneOrMany.Create(ImmutableArray.Create(1)).Select(i => i + 1), 2); 120Verify(OneOrMany.Create(ImmutableArray.Create(1)).Select((i, a) => i + a, 1), 2); 130Assert.Equal(1, OneOrMany.Create(ImmutableArray.Create(1)).FirstOrDefault(i => i < 2)); 131Assert.Equal(0, OneOrMany.Create(ImmutableArray.Create(1)).FirstOrDefault(i => i > 2)); 142Assert.Equal(1, OneOrMany.Create(ImmutableArray.Create(1)).FirstOrDefault((i, a) => i < a, 2)); 143Assert.Equal(0, OneOrMany.Create(ImmutableArray.Create(1)).FirstOrDefault((i, a) => i > a, 2)); 235Assert.True(OneOrMany.Create(1).SequenceEqual(OneOrMany.Create(ImmutableArray.Create(1)))); 256Assert.False(ImmutableArray.Create(1).SequenceEqual(OneOrMany<int>.Empty)); 258Assert.True(ImmutableArray.Create(1).SequenceEqual(OneOrMany.Create(1))); 259Assert.False(ImmutableArray.Create(1).SequenceEqual(OneOrMany.Create(2)));

39Assert.Throws<ArgumentNullException>(() => AssemblyMetadata.Create(ImmutableArray.Create((ModuleMetadata)null)));

43Assert.Throws<ArgumentException>(() => new MetadataReferenceProperties(MetadataImageKind.Module, ImmutableArray.Create("blah"))); 45Assert.Throws<ArgumentException>(() => new MetadataReferenceProperties(MetadataImageKind.Module, ImmutableArray.Create(""))); 46Assert.Throws<ArgumentException>(() => new MetadataReferenceProperties(MetadataImageKind.Module, ImmutableArray.Create("x\0x"))); 48Assert.Throws<ArgumentException>(() => MetadataReferenceProperties.Module.WithAliases(ImmutableArray.Create("blah"))); 56var a = new MetadataReferenceProperties(MetadataImageKind.Assembly, ImmutableArray.Create("a"), embedInteropTypes: true); 63Assert.Equal(a.WithEmbedInteropTypes(false), new MetadataReferenceProperties(MetadataImageKind.Assembly, ImmutableArray.Create("a"), embedInteropTypes: false)); 64Assert.Equal(a.WithRecursiveAliases(true), new MetadataReferenceProperties(MetadataImageKind.Assembly, ImmutableArray.Create("a"), embedInteropTypes: true, hasRecursiveAliases: true));

292aliases: ImmutableArray.Create("a"), 330var r6 = r.WithProperties(new MetadataReferenceProperties(MetadataImageKind.Assembly, ImmutableArray.Create("x"), embedInteropTypes: true)); 358var r3 = r.WithProperties(new MetadataReferenceProperties(MetadataImageKind.Assembly, ImmutableArray.Create("x"), embedInteropTypes: true)); 389var r3 = r.WithProperties(new MetadataReferenceProperties(MetadataImageKind.Assembly, ImmutableArray.Create("x"), embedInteropTypes: true));

35ImmutableArray.Create(""), 37ImmutableArray.Create(KeyValuePair.Create<string, string>("key", null))); 47ImmutableArray.Create(""), 49ImmutableArray.Create(KeyValuePair.Create("key", "")));

36searchPaths: ImmutableArray.Create(subdir)); 37var subdirSearchPath = ImmutableArray.Create(subdir);

1154arguments:=ImmutableArray.Create(Of BoundExpression)(argument),

1271statementList = ImmutableArray.Create(returnstmt)

297Return New BoundBadExpression(node, LookupResultKind.Empty, ImmutableArray(Of Symbol).Empty, ImmutableArray.Create(expr), resultType, hasErrors:=True) 305Return New BoundBadExpression(node, resultKind, ImmutableArray(Of Symbol).Empty, ImmutableArray.Create(expr), resultType, hasErrors:=True) 326Return New BoundBadExpression(wrappedExpression.Syntax, resultKind, ImmutableArray(Of Symbol).Empty, ImmutableArray.Create(wrappedExpression), wrappedExpression.Type, hasErrors:=True) 1665initializers = ImmutableArray.Create(Of BoundExpression)(arrayInitialization) 3134If(receiver IsNot Nothing, ImmutableArray.Create(receiver), ImmutableArray(Of BoundExpression).Empty), 3768Dim boundArguments = ImmutableArray.Create(Of BoundExpression)(arg) 3792boundArguments:=ImmutableArray.Create(Of BoundExpression)(arg),

532ImmutableArray.Create(boundInitValue),

1627childBoundNodes = ImmutableArray.Create(Of BoundExpression)(groupOpt) 3268ImmutableArray.Create(Of BoundExpression)(argument),

469ImmutableArray.Create(Of BoundStatement)(boundReturn),

495ImmutableArray.Create(Of Symbol)(methodResult.Candidate.UnderlyingSymbol),

1259ImmutableArray.Create(Of BoundExpression)(operand), 1269ImmutableArray.Create(Of BoundExpression)(operand),

221ImmutableArray.Create(Of Binder)(intoBinder), 238ImmutableArray.Create(Of Binder)(intoBinder), 271ImmutableArray.Create(Of Binder)(intoBinder), 357ImmutableArray.Create(Of BoundExpression)(letSelectorLambda), 552ImmutableArray.Create(Of BoundExpression)(selectSelectorLambda), 623ImmutableArray.Create(Of BoundExpression)(selectorLambda), 694ImmutableArray.Create(Of BoundExpression)(selectorLambda), 703ImmutableArray.Create(Of Binder)(selectorBinder), 780ImmutableArray.Create(Me), 840ImmutableArray.Create(Of BoundExpression)(selectorLambda), 849ImmutableArray.Create(Of Binder)(selectorBinder), 987ImmutableArray.Create(Me), 995ImmutableArray.Create(Me), 1119lambdaBinders = ImmutableArray.Create(Of Binder)(manySelectorBinder) 1808ImmutableArray.Create(Of BoundExpression)(source).AddRange(groupByArguments), 2385ImmutableArray.Create(Of BoundExpression)(filterLambda), 2394ImmutableArray.Create(Of Binder)(filterBinder), 2493ImmutableArray.Create(boundCount), 2536ImmutableArray.Create(Me), 2606ImmutableArray.Create(Of BoundExpression)(keyLambda), 2625ImmutableArray.Create(Of Binder)(keyBinder), 3947arguments = ImmutableArray.Create(Of BoundExpression)(aggregationLambda) 3955ImmutableArray.Create(m_GroupReference).AddRange(arguments), 3975ImmutableArray.Create(Of Binder)(aggregationBinder), 4294ImmutableArray.Create(Of BoundExpression)(selectorLambda), 4304ImmutableArray.Create(Of Binder)(selectorBinder), 4691childBoundNodes = ImmutableArray.Create(If(methodGroup, source))

72Return New BoundBadStatement(node, ImmutableArray.Create(Of BoundNode)(condition), hasErrors:=True) 847Return New BoundBadStatement(node, ImmutableArray.Create(Of BoundNode)(boundLabelExpression), hasErrors:=True) 2469Return New BoundBadStatement(node, ImmutableArray.Create(Of BoundNode)(target), True) 3064nextVariables = ImmutableArray.Create(boundVariable) 3611ImmutableArray.Create(controlVariable), 3802ImmutableArray.Create(collection), 3855ImmutableArray.Create(collection),

291Return Binder.GetErrorSymbol(GetBaseNamesForDiagnostic(typeSyntax), diagInfo, ImmutableArray.Create(Of Symbol)(sym), LookupResultKind.NotATypeOrNamespace)

27ImmutableArray.Create(Of BoundExpression)(str), 188ImmutableArray.Create(Of BoundExpression)(argument), 303sideEffectBuilder.Add(BindInvocationExpressionIfGroupNotNothing(syntax, addGroup, ImmutableArray.Create(Of BoundExpression)(expr), diagnostics)) 319sideEffectBuilder.Add(BindInvocationExpressionIfGroupNotNothing(syntax, addGroup, ImmutableArray.Create(Of BoundExpression)(attribute), diagnostics)) 327sideEffectBuilder.Add(BindInvocationExpressionIfGroupNotNothing(syntax, addGroup, ImmutableArray.Create(Of BoundExpression)(xmlnsAttributesPlaceholder), diagnostics)) 713arguments = ImmutableArray.Create(Of BoundExpression)(name) 894Dim objectCreation = BindInvocationExpressionIfGroupNotNothing(syntax, group, ImmutableArray.Create(Of BoundExpression)([namespace]), diagnostics) 919ImmutableArray.Create(Of BoundExpression)(value),

161Return ImmutableArray.Create(Of Symbol)(p)

231ImmutableArray.Create(Of Symbol)(result))

49Return ImmutableArray.Create(Of Symbol)(result)

48Return ImmutableArray.Create(Of Symbol)(symbol)

1958_guardedBoundNodeMap.Add(bindingRoot, ImmutableArray.Create(Of BoundNode)(boundRoot))

74boundMeReference, ImmutableArray.Create(Of BoundExpression)(boundTryCast), 276ImmutableArray.Create(Of BoundExpression)(boundLocalOtherFieldBoxed),

19Return New BoundBlock(Me.Syntax, Nothing, ImmutableArray(Of LocalSymbol).Empty, ImmutableArray.Create(Of BoundStatement)(returnStmt))

85locals = ImmutableArray.Create(Of LocalSymbol)(local) 284ImmutableArray.Create(Of BoundExpression)(parameterAccess),

26Return ImmutableArray.Create(Of BoundLocalDeclarationBase)(Me)

35Return ImmutableArray.Create(Of BoundNode)(Me.ReceiverOpt) 43Return ImmutableArray.Create(Of BoundNode)(Me.MethodGroup) 52Return ImmutableArray.Create(Of BoundNode)(Me.ReceiverOpt) 65Return ImmutableArray.Create(Of BoundNode)(Me.Operand) 71Return ImmutableArray.Create(Of BoundNode)(Me.Operand) 95Return ImmutableArray.Create(Of BoundNode)(Me.MemberAccess) 111Return ImmutableArray.Create(Of BoundNode)(Me.Value) 127Return ImmutableArray.Create(Of BoundNode)(Me.LastOperator) 139Return ImmutableArray.Create(Of BoundNode)(Me.Expression) 147Return ImmutableArray.Create(Of BoundNode)(Me.ConversionCall) 155Return ImmutableArray.Create(Of BoundNode)(Me.Source) 163Return ImmutableArray.Create(Of BoundNode)(Me.UnderlyingExpression) 171Return ImmutableArray.Create(Of BoundNode)(Me.UnderlyingExpression) 179Return ImmutableArray.Create(Of BoundNode)(Me.Expression) 187Return ImmutableArray.Create(Of BoundNode)(Me.Value) 203Return ImmutableArray.Create(Of BoundNode)(Me.Group) 219Return ImmutableArray.Create(Of BoundNode)(Me.Argument)

78Return ImmutableArray.Create(Of BoundNode)(Me.EventInvocation) 86Return ImmutableArray.Create(Of BoundNode)(Me.LabelExpressionOpt) 94Return ImmutableArray.Create(Of BoundNode)(Me.LabelExpressionOpt) 102Return ImmutableArray.Create(Of BoundNode)(Me.Body)

3370Return ImmutableArray.Create(symbol)

95Return SymbolInfoFactory.Create(ImmutableArray.Create(Of ISymbol)(aliasSymbol), If(aliasSymbol IsNot Nothing, LookupResultKind.Good, LookupResultKind.Empty))

157children:=ImmutableArray.Create(Of SingleNamespaceOrTypeDeclaration)(decl)) 328children = ImmutableArray.Create(Of SingleNamespaceOrTypeDeclaration)(ns)

63Return ImmutableArray.Create(loc)

122Return ImmutableArray.Create(Declarations(0).NameLocation)

204Return New AnonymousTypeKey(ImmutableArray.Create(properties))

214Return ImmutableArray.Create(result)

86factory.Array(payloadArrayType.ElementType, ImmutableArray.Create(factory.MaximumMethodDefIndex()), ImmutableArray(Of BoundExpression).Empty)))

890Dim allExpressions = ImmutableArray.Create(Of BoundExpression)(expression).Concat(indices)

89ImmutableArray.Create(Of BoundExpression)( 96ImmutableArray.Create(Of BoundExpression)( 150arguments:=ImmutableArray.Create(Of BoundExpression)(expression), 228ImmutableArray.Create(Of BoundExpression)(parameter),

472indices:=ImmutableArray.Create(Of BoundExpression)(statementFactory.Literal(spansIndex)))

536ImmutableArray.Create(Of BoundExpression)(frameAccess)) 1428ImmutableArray.Create(Of BoundExpression)(_meProxyDeferredInit))

63Me._locations = ImmutableArray.Create(lambdaNode.Syntax.GetLocation())

514ImmutableArray.Create(result),

239ImmutableArray.Create(handler),

105ImmutableArray.Create(Of BoundExpression)(result), 321ImmutableArray.Create(Of BoundExpression)(result), 452ImmutableArray.Create(result), Nothing, getObjectValueMethod.ReturnType)

589ImmutableArray.Create(left), Nothing, memberSymbol.ReturnType) 594ImmutableArray.Create(right), Nothing, memberSymbol.ReturnType) 1014ImmutableArray.Create(Of BoundExpression)(leftInit), 1040ImmutableArray.Create(If(operandHasValue, NullableValueOrDefault(operand), operand)), 1139ImmutableArray.Create(tempInit),

105ImmutableArray.Create(Of BoundExpression)(node), 136arguments = ImmutableArray.Create(Of BoundExpression)(receiver) 246Return New BoundSequence(rewrittenArgument.Syntax, ImmutableArray(Of LocalSymbol).Empty, ImmutableArray.Create(storeVal), boundTemp, rewrittenArgument.Type) 382Return New BoundSequence(argument.Syntax, ImmutableArray(Of LocalSymbol).Empty, ImmutableArray.Create(storeVal), boundTemp, argument.Type)

165result = New BoundSequence(node.Syntax, ImmutableArray.Create(temp), ImmutableArray.Create(assignment), result, result.Type)

676ImmutableArray.Create(inputToOperatorMethod), 812ImmutableArray.Create(operand), Nothing, memberSymbol.ReturnType) 890ImmutableArray.Create(operand), Nothing, memberSymbol.ReturnType) 984ImmutableArray.Create(operand), 990ImmutableArray.Create(operand), Nothing, memberSymbol.ReturnType) 1035ImmutableArray.Create(operand), Nothing, memberSymbol.ReturnType) 1123ImmutableArray.Create(operand), 1129ImmutableArray.Create(operand), Nothing, memberSymbol.ReturnType) 1172ImmutableArray.Create(operand), Nothing, memberSymbol.ReturnType) 1225ImmutableArray.Create(operand), Nothing, mathRound.ReturnType)

64ImmutableArray.Create(Of BoundExpression)(capture),

76ImmutableArray.Create(rewrittenReceiver),

282ImmutableArray.Create(Of BoundExpression)(boundIndex.MakeRValue()), 297ImmutableArray.Create(Of BoundExpression)(boundIndex.MakeRValue()), 302ImmutableArray.Create(Of BoundExpression)(boundIndex.MakeRValue()), elementType, hasErrors:=True) 664ImmutableArray.Create(Of BoundStatement)(disposalStatement)), 720ImmutableArray.Create(Of BoundExpression)(rewrittenBoundLocal)),

128statementList = ImmutableArray.Create(returnstmt)

80Return New BoundArrayCreation(node, ImmutableArray.Create(bounds), initializer, booleanArrayType) 113Dim arrayCreation = New BoundArrayCreation(node, ImmutableArray.Create(bounds), Nothing, objectArrayType) 140Dim indices = ImmutableArray.Create(indexExpr) 177rewrittenArguments = ImmutableArray.Create(rewrittenValue) 202Dim arrayCreation = New BoundArrayCreation(node, ImmutableArray.Create(bounds), Nothing, objectArrayType) 253ImmutableArray.Create(indexExpr), 273Return New BoundArrayCreation(node, ImmutableArray.Create(bounds), Nothing, objectArrayType) 294Return New BoundArrayCreation(node, ImmutableArray.Create(bounds), initializer, objectArrayType) 327Return New BoundArrayCreation(node, ImmutableArray.Create(bounds), initializer, stringArrayType) 344Dim indices = ImmutableArray.Create(index) 349ImmutableArray.Create(index), 455ImmutableArray.Create(assignment), 531Return New BoundSequence(syntax, ImmutableArray(Of LocalSymbol).Empty, ImmutableArray.Create(Of BoundExpression)(memberAccess), Nothing, Me.GetSpecialType(SpecialType.System_Void)) 536Return New BoundSequence(syntax, ImmutableArray(Of LocalSymbol).Empty, ImmutableArray.Create(Of BoundExpression)(memberAccess), Nothing, Me.GetSpecialType(SpecialType.System_Void)) 610Return New BoundSequence(syntax, ImmutableArray(Of LocalSymbol).Empty, ImmutableArray.Create(Of BoundExpression)(invocation), Nothing, Me.GetSpecialType(SpecialType.System_Void)) 615Return New BoundSequence(syntax, ImmutableArray(Of LocalSymbol).Empty, ImmutableArray.Create(Of BoundExpression)(invocation), Nothing, Me.GetSpecialType(SpecialType.System_Void)) 842ImmutableArray.Create(Of BoundExpression)(store).Concat(copyBackBuilder.ToImmutableAndFree), 959Return New BoundArrayCreation(node, ImmutableArray.Create(bounds), initializer, typeArrayType)

310statementsInTry = ImmutableArray.Create(Of BoundStatement)(conditionalValueInit)

21ImmutableArray.Create(expr), 26Return New BoundBadExpression(expr.Syntax, LookupResultKind.NotReferencable, ImmutableArray(Of Symbol).Empty, ImmutableArray.Create(expr), nullableType, hasErrors:=True) 206Return If(isOptional, Nothing, New BoundBadExpression(expr.Syntax, LookupResultKind.NotReferencable, ImmutableArray(Of Symbol).Empty, ImmutableArray.Create(expr), expr.Type.GetNullableUnderlyingType(), hasErrors:=True)) 219ImmutableArray.Create(defaultValue), 255Return New BoundBadExpression(expr.Syntax, LookupResultKind.NotReferencable, ImmutableArray(Of Symbol).Empty, ImmutableArray.Create(expr), expr.Type.GetNullableUnderlyingType(), hasErrors:=True) 283Return New BoundBadExpression(expr.Syntax, LookupResultKind.NotReferencable, ImmutableArray(Of Symbol).Empty, ImmutableArray.Create(expr), 529ImmutableArray.Create(sideeffects),

202ImmutableArray.Create(rewrittenBody)).MakeCompilerGenerated()

138arguments:=ImmutableArray.Create(Of BoundExpression)(rewrittenReceiver), 165Return New BoundBadExpression(syntax, LookupResultKind.NotReferencable, ImmutableArray(Of Symbol).Empty, ImmutableArray.Create(rewrittenReceiver), ErrorTypeSymbol.UnknownResultType, hasErrors:=True)

91ImmutableArray.Create(Of BoundExpression)(assignmentOperator),

288Return factory.Call(Nothing, memberSymbol, ImmutableArray.Create(Of BoundExpression)(argArray))

99ImmutableArray.Create(Of BoundExpression)(boundLockObjectLocal), 124tryStatements = ImmutableArray.Create(Of BoundStatement)(DirectCast(Visit(node.Body), BoundBlock)) 138ImmutableArray.Create(Of BoundStatement)(statementInFinally)) 205parameters = ImmutableArray.Create(Of BoundExpression)(boundLockObject) 244ImmutableArray.Create(Of BoundExpression)(boundLockObject), 249boundMonitorExitCall = New BoundBadExpression(syntaxNode, LookupResultKind.NotReferencable, ImmutableArray(Of Symbol).Empty, ImmutableArray.Create(boundLockObject), ErrorTypeSymbol.UnknownResultType, hasErrors:=True)

30ImmutableArray.Create(Of BoundExpression)(expressionOpt),

132ImmutableArray.Create(node.Operand), Nothing, memberSymbol.ReturnType) 156ImmutableArray.Create(node.Operand), Nothing, memberSymbol.ReturnType) 204ImmutableArray.Create(tempInit), 272ImmutableArray.Create(Of BoundExpression)(callInput),

284ImmutableArray.Create(Of BoundExpression)(nodeFactory.Literal(E_INTERNALERROR)), 412ImmutableArray.Create(Of BoundExpression)(nodeFactory.Literal(E_RESUMEWITHOUTERROR)),

169Return New BoundStatementList(node.UsingInfo.UsingStatementSyntax, ImmutableArray.Create(Of BoundStatement)(currentBody)) 246finallyStatements = ImmutableArray.Create(disposeCall)

320arguments:=ImmutableArray.Create([namespace]), 352result = New BoundArrayCreation(syntax, ImmutableArray.Create(Of BoundExpression)(size), initializer, arrayType)

174Me._locations = ImmutableArray.Create(Of Location)(syntax.GetLocation())

40Me._locations = ImmutableArray.Create(syntax.GetLocation())

1039Return New BoundArrayCreation(_syntax, ImmutableArray.Create(Of BoundExpression)(Literal(elements.Length)), boundArrayInit, arrayType)

90receiver = New Result(New BoundSequence(capture.Syntax, ImmutableArray(Of LocalSymbol).Empty, ImmutableArray.Create(Of BoundExpression)(capture), boundTemp, boundTemp.Type), 97receiver = New Result(New BoundSequence(capture.Syntax, ImmutableArray(Of LocalSymbol).Empty, ImmutableArray.Create(Of BoundExpression)(capture), boundTemp, boundTemp.Type), 323receiver = New Result(New BoundSequence(capture.Syntax, ImmutableArray(Of LocalSymbol).Empty, ImmutableArray.Create(Of BoundExpression)(capture), boundTemp, boundTemp.Type), 347ImmutableArray.Create(Of BoundExpression)(clone), 358ImmutableArray.Create(Of BoundExpression)(receiver.First.MakeRValue()),

3251ImmutableArray.Create(argument1),

77Me._aliasLocations = ImmutableArray.Create(aliasLocation)

73_parameters = ImmutableArray.Create(Of ParameterSymbol)(

79Return ImmutableArray.Create(Me._container.TypeDescriptor.Fields(Me.PropertyIndex).Location)

74Dim equatableInterface As NamedTypeSymbol = Me.Manager.System_IEquatable_T.Construct(ImmutableArray.Create(Of TypeSymbol)(Me)) 75Me._interfaces = ImmutableArray.Create(Of NamedTypeSymbol)(equatableInterface) 112method.SetParameters(ImmutableArray.Create(Of ParameterSymbol)( 124method.SetParameters(ImmutableArray.Create(Of ParameterSymbol)(

179Return ImmutableArray.Create(Of Location)(Me.TypeDescriptor.Location)

184ImmutableArray.Create(value), 213Return ImmutableArray.Create(TypeDescr.Location)

22_parameters = ImmutableArray.Create(Of ParameterSymbol)(New SynthesizedParameterSimpleSymbol(Me, container.Manager.System_Object, 0, "obj"))

22_parameters = ImmutableArray.Create(Of ParameterSymbol)(New SynthesizedParameterSimpleSymbol(Me, container, 0, "val")) 23_interfaceMethod = ImmutableArray.Create(interfaceMethod)

92_parameters = ImmutableArray.Create(Of ParameterSymbol)(

77Dim equatableInterface As NamedTypeSymbol = Me.Manager.System_IEquatable_T.Construct(ImmutableArray.Create(Of TypeSymbol)(Me)) 78_interfaces = ImmutableArray.Create(Of NamedTypeSymbol)(equatableInterface)

86Return ImmutableArray.Create(iReadOnlyListOfT.Construct(elementType)) 89Return ImmutableArray.Create(iListOfT.Construct(elementType))

84_candidateSymbols = ImmutableArray.Create(Of Symbol)(nonErrorGuessType)

59Me.FieldsOrProperties = ImmutableArray.Create(Of Symbol)(field) 87Me.FieldsOrProperties = ImmutableArray.Create(Of Symbol)([property])

206members.Add(ns.Name, ImmutableArray.Create(Of Symbol)(ns))

73_lazyModules = ImmutableArray.Create(Of ModuleSymbol)(m_ModuleSymbol)

97Return ImmutableArray.Create(Of NamespaceSymbol)(Me)

106Return ImmutableArray.Create(Of SyntaxReference)(Me._syntaxReference) 112Return ImmutableArray.Create(Of Location)(Me._syntaxReference.GetLocation())

28MyBase.New(container, flags, syntaxRef, locations:=ImmutableArray.Create(location))

33_location = ImmutableArray.Create(Of Location)(location)

260Return ImmutableArray.Create(_syntaxNode.GetLocation()) 266Return ImmutableArray.Create(_syntaxNode.GetReference())

194Return ImmutableArray.Create(Me.IdentifierLocation) 588Return ImmutableArray.Create(_identifierToken.Parent.GetReference())

185Return ImmutableArray.Create(Of Location)(_identifierToken.GetLocation()) 267Return ImmutableArray.Create(Of Location)(_syntax.GetLocation())

1549ImmutableArray.Create(typedConstantNoStringInterning))) 1605ImmutableArray.Create(typedConstantDebugMode))) 1619AddSynthesizedAttribute(attributes, _compilation.TrySynthesizeAttribute(WellKnownMember.System_Reflection_AssemblyKeyNameAttribute__ctor, ImmutableArray.Create(typedConstant))) 1628AddSynthesizedAttribute(attributes, _compilation.TrySynthesizeAttribute(WellKnownMember.System_Reflection_AssemblyKeyFileAttribute__ctor, ImmutableArray.Create(typedConstant)))

447Return ImmutableArray.Create(_location)

621Return ImmutableArray.Create(Of Location)(GetSymbolLocation(_syntaxRef))

56Return ImmutableArray.Create(Of Location)(_labelName.GetLocation()) 64Return ImmutableArray.Create(Of SyntaxReference)(DirectCast(parentNode.GetReference(), SyntaxReference))

815ImmutableArray.Create(Of MethodSymbol)(handlingMethod),

843ImmutableArray.Create(location)), 1200Return New BoundBlock(methodBlock, methodBlock.Statements, ImmutableArray(Of LocalSymbol).Empty, ImmutableArray.Create(boundStatement))

201interfaces = ImmutableArray.Create(comClassInterface)

72Return ImmutableArray.Create(Of Location)(_location)

62Return ImmutableArray.Create(valueParameter)

454Return ImmutableArray.Create(_location)

340Return ImmutableArray.Create(GetSymbolLocation(_syntaxRef))

321_parameters = ImmutableArray.Create(Of ParameterSymbol)(New SynthesizedParameterSymbol(Me, submissionArrayType, ordinal:=0, isByRef:=False, name:="submissionArray")) 369ImmutableArray.Create(Of BoundExpression)(submissionArrayParameter),

62Dim parameterList = ImmutableArray.Create(Of ParameterSymbol)(parameter) 201arguments:=ImmutableArray.Create(Of BoundExpression)(fieldAccess), 220arguments:=ImmutableArray.Create(Of BoundExpression)(parameterAccess), 233statements:=ImmutableArray.Create(Of BoundStatement)(returnStatement)).MakeCompilerGenerated() 299ImmutableArray.Create(Of BoundStatement)([return]) 372compareExchangeMethod = compareExchangeMethod.Construct(ImmutableArray.Create(Of TypeSymbol)(delegateType))

140ImmutableArray.Create(FunctionLocal),

75New BoundMethodGroup(syntaxNode, Nothing, ImmutableArray.Create(runMethod), LookupResultKind.Good, Nothing, QualificationKind.QualifiedViaTypeName), 76ImmutableArray.Create(instance), Nothing, diagnostics,

128Return New BoundBlock(accessorBlock, Nothing, ImmutableArray(Of LocalSymbol).Empty, ImmutableArray.Create(Of BoundStatement)(boundStatement))

222Return ImmutableArray.Create(_syntaxRef.GetLocation())

36Return If(_syntaxOpt Is Nothing, ImmutableArray(Of Location).Empty, ImmutableArray.Create(_syntaxOpt.GetLocation())) 42Return If(_syntaxOpt Is Nothing, ImmutableArray(Of SyntaxReference).Empty, ImmutableArray.Create(_syntaxOpt.GetReference()))

193Return ImmutableArray.Create(Of SyntaxReference)(node.GetReference)

429Me._locations = ImmutableArray.Create(Of location)(location)

37ImmutableArray.Create(Of MethodSymbol)(interfaceMethod))

47Me._locations = If((location Is Nothing), ImmutableArray(Of Location).Empty, ImmutableArray.Create(Of Location)(location))

151Me._locations = If((location Is Nothing), ImmutableArray(Of Location).Empty, ImmutableArray.Create(Of Location)(location))

341Me.New(If((locationOpt Is Nothing), ImmutableArray(Of Location).Empty, ImmutableArray.Create(Of Location)(locationOpt)), 408Return TupleTypeSymbol.Create(If((locationOpt Is Nothing), ImmutableArray(Of Location).Empty, ImmutableArray.Create(Of Location)(locationOpt)),