104=> ImmutableArray.Create(fileNameAndContentGroups.Select(x => CreateAdditionalFile(x.FileName, x.Content)).ToArray()); 107=> ImmutableArray.Create(fileNames.Select(x => CreateAdditionalFile(x)).ToArray());

41var builder = ImmutableArray.CreateBuilder<int>(count);

222ImmutableArray.Create<PropertySetAbstractValueKind>( 503ImmutableArray.Create<PropertySetAbstractValueKind>( 632ImmutableArray.Create<PropertySetAbstractValueKind>( // Order is the same as the PropertyMappers below. 988ImmutableArray.Create<PropertySetAbstractValueKind>( 1084ImmutableArray.Create<PropertySetAbstractValueKind>( 1229defaultReferences = defaultReferences.AddPackages(ImmutableArray.Create(new PackageIdentity("System.DirectoryServices", "6.0.1")));

35var symbolNames = ImmutableArray.Create("a", "b"); 59var symbolNames = ImmutableArray.Create("MyNamespace", "MyClass", "MyMethod()", "MyProperty", "MyEvent", "MyField"); 88var symbolNames = ImmutableArray.Create( 123var symbolNames = ImmutableArray.Create( 145var symbolNames = ImmutableArray.Create( 167var symbolNames = ImmutableArray.Create( 187var symbolNames = ImmutableArray.Create( 216var symbolNames = ImmutableArray.Create( 251var symbolNames = ImmutableArray.Create( 370var symbolNames = ImmutableArray.Create(patternName);

135var incrementalAnalyzerNames = ImmutableArray.CreateBuilder<string>();

88var builder = ImmutableArray.CreateBuilder<string>(value.ListValue.Values.Count); 113var builder = ImmutableArray.CreateBuilder<bool>(value.ListValue.Values.Count);

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))),

424var relationships = ImmutableArray.CreateBuilder<RelationshipSnapshot>();

691builder = ImmutableArray.CreateBuilder<ResourceCommandSnapshot>(previousState.Commands.Length); 707builder = ImmutableArray.CreateBuilder<ResourceCommandSnapshot>(previousState.Commands.Length);

48var builder = ImmutableArray.CreateBuilder<DcpInstance>(replicas);

77var ports = ImmutableArray.CreateBuilder<int>(); 213var launchArgsBuilder = ImmutableArray.CreateBuilder<string>(); 214var argsAreSensitiveBuilder = ImmutableArray.CreateBuilder<int>(); 233var urls = ImmutableArray.CreateBuilder<UrlSnapshot>(); 290var environment = ImmutableArray.CreateBuilder<EnvironmentVariableSnapshot>(effectiveSource.Count);

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]); 166case 2: return ImmutableArray.Create(span[0], span[1]); 167case 3: return ImmutableArray.Create(span[0], span[1], span[2]); 168case 4: return ImmutableArray.Create(span[0], span[1], span[2], span[3]); 170var builder = ImmutableArray.CreateBuilder<T>(span.Length);

368ImmutableArray.Create(name));

24var builder = ImmutableArray.CreateBuilder<Type>();

47builder ??= ImmutableArray.CreateBuilder<CodeFixProvider>();

343var customTagsToGenerateRulesets = ImmutableArray.Create(

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

28numerals = ImmutableArray.Create("0", "1", "2", "3", "4", "5", "6", "7", "8", "9");

64return ImmutableArray.Create<T>(); 72return ImmutableArray.CreateRange<T>(items); 92return ImmutableArray.CreateRange(items);

38return ImmutableArray.CreateRange<T>(items); 55return ImmutableArray.CreateRange<T>(items); 72return ImmutableArray.CreateRange<T>(items); 84return ImmutableArray.Create<T>(items); 101return ImmutableArray.Create<T>(items); 117return ImmutableArray.Create<T>(items); 127return ImmutableArray.Create<byte>(stream.ToArray()); 140return ImmutableArray.CreateRange(items, map); 155return ImmutableArray.CreateRange(items, map, arg); 854? ImmutableArray.Create(symbol) 855: ImmutableArray<TNamespaceOrTypeSymbol>.CastUp(ImmutableArray.Create((TNamedTypeSymbol)symbol)); 1261/// Variant of <see cref="System.Collections.Immutable.ImmutableArray.BinarySearch{T}(ImmutableArray{T}, T, IComparer{T}?)"/>

40private static readonly ImmutableArray<int> s_primes = ImmutableArray.Create(

186=> HasOneItem ? ImmutableArray.Create(_one) : _many; 273=> new OneOrMany<T>(ImmutableArray.Create(one, two));

3131 => ImmutableArray.Create(_item0), 3142 => ImmutableArray.Create(_item0, _item1), 3153 => ImmutableArray.Create(_item0, _item1, _item2), 3164 => ImmutableArray.Create(_item0, _item1, _item2, _item3),

62_builder = ImmutableArray.CreateBuilder<T>(size); 567dictionary1.Add(keySelector(value), ImmutableArray.Create(value));

557ImmutableArray<IMethodSymbol>.Builder originalDefinitionsBuilder = ImmutableArray.CreateBuilder<IMethodSymbol>();

88return ImmutableArray.Create(operation); 91var builder = ImmutableArray.CreateBuilder<IOperation>(); 383ImmutableArray.Create(OperationKind.AnonymousFunction, OperationKind.LocalFunction);

24ImmutableArray<IPropertySymbol>.Builder originalDefinitionsBuilder = ImmutableArray.CreateBuilder<IPropertySymbol>();

13= ImmutableArray.Create(

21private static readonly ImmutableArray<IOption2>.Builder s_editorConfigOptionsBuilder = ImmutableArray.CreateBuilder<IOption2>();

14private static readonly ImmutableArray<IOption2>.Builder s_allOptionsBuilder = ImmutableArray.CreateBuilder<IOption2>();

31return ImmutableArray.Create<T>(items);

128var nodes = ImmutableArray.CreateBuilder<Node>(_builderNodes.Length); 132var edges = ImmutableArray.CreateBuilder<Edge>(Math.Max(0, _builderNodes.Length - 1));

226var builder = ImmutableArray.CreateBuilder<byte>(count);

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))]);

135newTypeParameter.ConstraintTypes = ImmutableArray.CreateRange(newTypeParameter.ConstraintTypes, t => t.SubstituteTypes(mapping, typeGenerator));

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

52var formattingRules = ImmutableArray.Create(

173private static readonly ImmutableArray<string> s_assemblies = ImmutableArray.Create(

60incrementalAnalyzerNames: ImmutableArray.Create(AnalyzerName));

76var builder = ImmutableArray.CreateBuilder<GenericParameterProxy>(Method.GenericParameters.Count);

40var builder = ImmutableArray.CreateBuilder<MultiValue>(); 55var argumentsBuilder = ImmutableArray.CreateBuilder<MultiValue>();

24var builder = ImmutableArray.CreateBuilder<GenericParameterProxy>(Type.GenericParameters.Count);

1667var builder = ImmutableArray.CreateBuilder<GenericParameterValue>(genericParameters.Length);

28var diagDescriptorsArrayBuilder = ImmutableArray.CreateBuilder<DiagnosticDescriptor>();

20public static ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(

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]); 154case 2: return ImmutableArray.Create(span[0], span[1]); 155case 3: return ImmutableArray.Create(span[0], span[1], span[2]); 156case 4: return ImmutableArray.Create(span[0], span[1], span[2], span[3]); 158var builder = ImmutableArray.CreateBuilder<T>(span.Length);

63var finallyRegions = ImmutableArray.CreateBuilder<RegionProxy>();

308ImmutableArray<TValue>.Builder arguments = ImmutableArray.CreateBuilder<TValue>(); 344var argumentsBuilder = ImmutableArray.CreateBuilder<TValue>(); 526HandleMethodCallHelper(addMethod, instanceValue, ImmutableArray.Create(value), operation, state); 534HandleMethodCallHelper(removeMethod, instanceValue, ImmutableArray.Create(value), operation, state); 717ImmutableArray<TValue>.Builder arguments = ImmutableArray.CreateBuilder<TValue>(); 765return HandleMethodCallHelper(getMethod, instanceValue, ImmutableArray.Create(indexArgumentValue), operation, state); 926var argumentsBuilder = ImmutableArray.CreateBuilder<TValue>();

28ImmutableArray.Create<RequiresAnalyzerBase>( 35var diagDescriptorsArrayBuilder = ImmutableArray.CreateBuilder<DiagnosticDescriptor>(26);

37public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(s_locationRule, s_getFilesRule, s_requiresAssemblyFilesRule, s_requiresAssemblyFilesAttributeMismatch, s_requiresAssemblyFilesOnStaticCtor, s_requiresAssemblyFilesOnEntryPoint); 85var dangerousPatternsBuilder = ImmutableArray.CreateBuilder<ISymbol>();

29ImmutableArray.Create(s_requiresDynamicCodeRule, s_requiresDynamicCodeAttributeMismatch, s_requiresDynamicCodeOnStaticCtor, s_requiresDynamicCodeOnEntryPoint, s_referenceNotMarkedIsAotCompatibleRule); 168ImmutableArray.Create<Action<CompilationAnalysisContext>>((context) =>

31ImmutableArray.Create(s_makeGenericMethodRule, s_makeGenericTypeRule, s_requiresUnreferencedCodeRule, s_requiresUnreferencedCodeAttributeMismatch, s_requiresUnreferencedCodeOnStaticCtor, s_requiresUnreferencedCodeOnEntryPoint, s_referenceNotMarkedIsTrimmableRule); 82ImmutableArray.Create<Action<CompilationAnalysisContext>>((context) =>

66: ImmutableArray.Create(parts._publicKeyOrToken);

125genericArgs = ImmutableArray.CreateBuilder<TypeName>(2);

1667var builder = ImmutableArray.CreateBuilder<GenericParameterValue>(genericParameters.Length);

41var builder = ImmutableArray.CreateBuilder<GenericParameterProxy>(Method.TypeParameters.Length);

41var builder = ImmutableArray.CreateBuilder<MultiValue>(); 63var argumentsBuilder = ImmutableArray.CreateBuilder<MultiValue>();

20var builder = ImmutableArray.CreateBuilder<GenericParameterProxy>(namedType.TypeParameters.Length);

132return ImmutableArray.Create(text.Split(["\r\n"], StringSplitOptions.RemoveEmptyEntries));

267var builder = ImmutableArray.CreateBuilder<(string, CodeAnalysisMetricData)>();

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

28numerals = ImmutableArray.Create("0", "1", "2", "3", "4", "5", "6", "7", "8", "9");

64return ImmutableArray.Create<T>(); 72return ImmutableArray.CreateRange<T>(items); 92return ImmutableArray.CreateRange(items);

38return ImmutableArray.CreateRange<T>(items); 55return ImmutableArray.CreateRange<T>(items); 72return ImmutableArray.CreateRange<T>(items); 84return ImmutableArray.Create<T>(items); 101return ImmutableArray.Create<T>(items); 117return ImmutableArray.Create<T>(items); 127return ImmutableArray.Create<byte>(stream.ToArray()); 140return ImmutableArray.CreateRange(items, map); 155return ImmutableArray.CreateRange(items, map, arg); 854? ImmutableArray.Create(symbol) 855: ImmutableArray<TNamespaceOrTypeSymbol>.CastUp(ImmutableArray.Create((TNamedTypeSymbol)symbol)); 1261/// Variant of <see cref="System.Collections.Immutable.ImmutableArray.BinarySearch{T}(ImmutableArray{T}, T, IComparer{T}?)"/>

40private static readonly ImmutableArray<int> s_primes = ImmutableArray.Create(

186=> HasOneItem ? ImmutableArray.Create(_one) : _many; 273=> new OneOrMany<T>(ImmutableArray.Create(one, two));

3131 => ImmutableArray.Create(_item0), 3142 => ImmutableArray.Create(_item0, _item1), 3153 => ImmutableArray.Create(_item0, _item1, _item2), 3164 => ImmutableArray.Create(_item0, _item1, _item2, _item3),

62_builder = ImmutableArray.CreateBuilder<T>(size); 567dictionary1.Add(keySelector(value), ImmutableArray.Create(value));

80var builder = ImmutableArray.CreateBuilder<INamespaceOrTypeSymbol>();

82var builder = ImmutableArray.CreateBuilder<INamespaceOrTypeSymbol>();

557ImmutableArray<IMethodSymbol>.Builder originalDefinitionsBuilder = ImmutableArray.CreateBuilder<IMethodSymbol>();

88return ImmutableArray.Create(operation); 91var builder = ImmutableArray.CreateBuilder<IOperation>(); 383ImmutableArray.Create(OperationKind.AnonymousFunction, OperationKind.LocalFunction);

24ImmutableArray<IPropertySymbol>.Builder originalDefinitionsBuilder = ImmutableArray.CreateBuilder<IPropertySymbol>();

13= ImmutableArray.Create(

21private static readonly ImmutableArray<IOption2>.Builder s_editorConfigOptionsBuilder = ImmutableArray.CreateBuilder<IOption2>();

14private static readonly ImmutableArray<IOption2>.Builder s_allOptionsBuilder = ImmutableArray.CreateBuilder<IOption2>();

31return ImmutableArray.Create<T>(items);

128var nodes = ImmutableArray.CreateBuilder<Node>(_builderNodes.Length); 132var edges = ImmutableArray.CreateBuilder<Edge>(Math.Max(0, _builderNodes.Length - 1));

226var builder = ImmutableArray.CreateBuilder<byte>(count);

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

28numerals = ImmutableArray.Create("0", "1", "2", "3", "4", "5", "6", "7", "8", "9");

64return ImmutableArray.Create<T>(); 72return ImmutableArray.CreateRange<T>(items); 92return ImmutableArray.CreateRange(items);

38return ImmutableArray.CreateRange<T>(items); 55return ImmutableArray.CreateRange<T>(items); 72return ImmutableArray.CreateRange<T>(items); 84return ImmutableArray.Create<T>(items); 101return ImmutableArray.Create<T>(items); 117return ImmutableArray.Create<T>(items); 127return ImmutableArray.Create<byte>(stream.ToArray()); 140return ImmutableArray.CreateRange(items, map); 155return ImmutableArray.CreateRange(items, map, arg); 854? ImmutableArray.Create(symbol) 855: ImmutableArray<TNamespaceOrTypeSymbol>.CastUp(ImmutableArray.Create((TNamedTypeSymbol)symbol)); 1261/// Variant of <see cref="System.Collections.Immutable.ImmutableArray.BinarySearch{T}(ImmutableArray{T}, T, IComparer{T}?)"/>

40private static readonly ImmutableArray<int> s_primes = ImmutableArray.Create(

186=> HasOneItem ? ImmutableArray.Create(_one) : _many; 273=> new OneOrMany<T>(ImmutableArray.Create(one, two));

3131 => ImmutableArray.Create(_item0), 3142 => ImmutableArray.Create(_item0, _item1), 3153 => ImmutableArray.Create(_item0, _item1, _item2), 3164 => ImmutableArray.Create(_item0, _item1, _item2, _item3),

62_builder = ImmutableArray.CreateBuilder<T>(size); 567dictionary1.Add(keySelector(value), ImmutableArray.Create(value));

267var builder = ImmutableArray.CreateBuilder<(string, CodeAnalysisMetricData)>();

80var builder = ImmutableArray.CreateBuilder<INamespaceOrTypeSymbol>();

82var builder = ImmutableArray.CreateBuilder<INamespaceOrTypeSymbol>();

557ImmutableArray<IMethodSymbol>.Builder originalDefinitionsBuilder = ImmutableArray.CreateBuilder<IMethodSymbol>();

88return ImmutableArray.Create(operation); 91var builder = ImmutableArray.CreateBuilder<IOperation>(); 383ImmutableArray.Create(OperationKind.AnonymousFunction, OperationKind.LocalFunction);

24ImmutableArray<IPropertySymbol>.Builder originalDefinitionsBuilder = ImmutableArray.CreateBuilder<IPropertySymbol>();

13= ImmutableArray.Create(

21private static readonly ImmutableArray<IOption2>.Builder s_editorConfigOptionsBuilder = ImmutableArray.CreateBuilder<IOption2>();

14private static readonly ImmutableArray<IOption2>.Builder s_allOptionsBuilder = ImmutableArray.CreateBuilder<IOption2>();

31return ImmutableArray.Create<T>(items);

128var nodes = ImmutableArray.CreateBuilder<Node>(_builderNodes.Length); 132var edges = ImmutableArray.CreateBuilder<Edge>(Math.Max(0, _builderNodes.Length - 1));

226var builder = ImmutableArray.CreateBuilder<byte>(count);

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

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.CoalesceAssignment, DiagDescriptors.Coalesce);

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);

17var immutableFiles = ImmutableArray.Create(files, 0, files.Length);

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

22=> ImmutableArray.Create(

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

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

17var immutableFiles = ImmutableArray.Create(files, 0, files.Length);

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));

23var middleware = ImmutableArray.CreateBuilder<MiddlewareItem>();

24var options = ImmutableArray.CreateBuilder<OptionsItem>();

23var services = ImmutableArray.CreateBuilder<ServicesItem>();

41var items = ImmutableArray.CreateBuilder<T>();

42public static readonly ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics = ImmutableArray.Create<DiagnosticDescriptor>(new[]

22var references = ImmutableArray.CreateBuilder<MetadataReference>();

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));

70var routeParameters = ImmutableArray.CreateBuilder<RouteParameter>(); 72var diagnostics = ImmutableArray.CreateBuilder<EmbeddedDiagnostic>(); 228var policies = ImmutableArray.CreateBuilder<string>(); 350var result = ImmutableArray.CreateBuilder<RoutePatternRootPartNode>(); 369var result = ImmutableArray.CreateBuilder<RoutePatternSegmentPartNode>(); 494var parts = ImmutableArray.CreateBuilder<RoutePatternParameterPartNode>(); 574var fragments = ImmutableArray.CreateBuilder<RoutePatternNode>();

24public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create( 113: ImmutableArray.Create(GetHttpMethod(match.Value)!); 121var httpMethodsBuilder = ImmutableArray.CreateBuilder<string>();

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))); 411var builder = ImmutableArray.CreateBuilder<string>();

21var resolvedParameterSymbols = ImmutableArray.CreateBuilder<ParameterSymbol>();

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

158var httpMethodsBuilder = ImmutableArray.CreateBuilder<string>(); 349return ImmutableArray.Create(info.Symbol);

21public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(new[]

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

50var highlightSpans = ImmutableArray.CreateBuilder<AspNetCoreHighlightSpan>(); 69return ImmutableArray.Create(new AspNetCoreDocumentHighlights(highlightSpans.ToImmutable()));

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

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

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

75var trees = ImmutableArray.Create(tree); 98public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(new[]

64return net10Ref.AddAssemblies(ImmutableArray.Create(

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(

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

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

24SupportedDiagnostics = ImmutableArray.Create(new[]

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

17SupportedDiagnostics = ImmutableArray.Create(new[]

20SupportedDiagnostics = ImmutableArray.Create(

20SupportedDiagnostics = ImmutableArray.Create(

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

10public static ImmutableArray<TElement>.Builder CreateBuffer() => ImmutableArray.CreateBuilder<TElement>();

809var expected = ImmutableArray.CreateRange(new[] { 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 });

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

19SupportedDiagnostics = ImmutableArray.Create(new[]

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

17SupportedDiagnostics = ImmutableArray.Create(new[]

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

10public static ImmutableArray<TElement>.Builder CreateBuffer() => ImmutableArray.CreateBuilder<TElement>();

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

86public override ImmutableArray<SuppressionDescriptor> SupportedSuppressions => ImmutableArray.Create(SuppressRUCDiagnostic, SuppressRDCDiagnostic);

23builder = ImmutableArray.CreateBuilder<TElement>(); 29ImmutableArray.CreateBuilder<(TSource, int, ImmutableArray<TElement>)>();

39var attributeBuilder = ImmutableArray.CreateBuilder<AttributeData>();

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

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

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

15SupportedDiagnostics = ImmutableArray.Create(new[] { SupportedDiagnostic });

16public override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(

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

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

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

21var result = ImmutableArray.CreateBuilder<ISymbol>(); 53var results = ImmutableArray.CreateBuilder<ITypeParameterSymbol>(); 74var results = ImmutableArray.CreateBuilder<ITypeSymbol>();

23builder = ImmutableArray.CreateBuilder<TElement>(); 29ImmutableArray.CreateBuilder<(TSource, int, ImmutableArray<TElement>)>();

28var builder = ImmutableArray.CreateBuilder<string>(); 89return ImmutableArray.CreateRange(assemblyReferences);

333_nestedScopes = ImmutableArray.CreateBuilder<ScopeInfo>(1); 343_localVariables = ImmutableArray.CreateBuilder<LocalDefinition>(1); 355_localConstants = ImmutableArray.CreateBuilder<LocalConstantDefinition>(1); 367_stateMachineUserHoistedLocalSlotIndices = ImmutableArray.CreateBuilder<int>(1); 409Blocks = ImmutableArray.CreateBuilder<BasicBlock>(4); 684_handlers = ImmutableArray.CreateBuilder<ExceptionHandlerScope>(2);

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

71_sortedCaseLabels = ImmutableArray.Create(caseLabels);

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

46return new UnionCollection<T>(ImmutableArray.Create(coll1, coll2)); 62return new UnionCollection<T>(ImmutableArray.CreateRange(collections, selector));

195var namedSectionBuilder = ImmutableArray.CreateBuilder<Section>();

491var analyzerBuilder = ImmutableArray.CreateBuilder<DiagnosticAnalyzer>(); 492var generatorBuilder = ImmutableArray.CreateBuilder<ISourceGenerator>();

456var embeddedTextBuilder = ImmutableArray.CreateBuilder<EmbeddedText?>(embeddedFileOrderedSet.Count);

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

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

38return ImmutableArray.Create<byte>(); 177return ImmutableArray.Create(hashProvider.ComputeHash(stream)); 194return ImmutableArray.Create(hashProvider.ComputeHash(bytes)); 203return ImmutableArray.Create(incrementalHash.GetHashAndReset()); 212return ImmutableArray.Create(incrementalHash.GetHashAndReset()); 222return ImmutableArray.Create(incrementalHash.GetHashAndReset()); 238return ImmutableArray.Create(incrementalHash.GetHashAndReset());

181private static readonly ImmutableArray<byte> s_NETCF_PUBLIC_KEY_TOKEN_1 = ImmutableArray.Create(new byte[] { 0x1c, 0x9e, 0x25, 0x96, 0x86, 0xf9, 0x21, 0xe0 }); 182private static readonly ImmutableArray<byte> s_NETCF_PUBLIC_KEY_TOKEN_2 = ImmutableArray.Create(new byte[] { 0x5f, 0xd5, 0x7c, 0x54, 0x3a, 0x9c, 0x02, 0x47 }); 183private static readonly ImmutableArray<byte> s_NETCF_PUBLIC_KEY_TOKEN_3 = ImmutableArray.Create(new byte[] { 0x96, 0x9d, 0xb8, 0x05, 0x3d, 0x33, 0x22, 0xac }); 184private static readonly ImmutableArray<byte> s_SQL_PUBLIC_KEY_TOKEN = ImmutableArray.Create(new byte[] { 0x89, 0x84, 0x5d, 0xcd, 0x80, 0x80, 0xcc, 0x91 }); 185private static readonly ImmutableArray<byte> s_SQL_MOBILE_PUBLIC_KEY_TOKEN = ImmutableArray.Create(new byte[] { 0x3b, 0xe2, 0x35, 0xdf, 0x1c, 0x8d, 0x2a, 0xd3 }); 186private static readonly ImmutableArray<byte> s_ECMA_PUBLICKEY_STR_L = ImmutableArray.Create(new byte[] { 0xb7, 0x7a, 0x5c, 0x56, 0x19, 0x34, 0xe0, 0x89 }); 187private static readonly ImmutableArray<byte> s_SHAREDLIB_PUBLICKEY_STR_L = ImmutableArray.Create(new byte[] { 0x31, 0xbf, 0x38, 0x56, 0xad, 0x36, 0x4e, 0x35 }); 188private static readonly ImmutableArray<byte> s_MICROSOFT_PUBLICKEY_STR_L = ImmutableArray.Create(new byte[] { 0xb0, 0x3f, 0x5f, 0x7f, 0x11, 0xd5, 0x0a, 0x3a }); 189private static readonly ImmutableArray<byte> s_SILVERLIGHT_PLATFORM_PUBLICKEY_STR_L = ImmutableArray.Create(new byte[] { 0x7c, 0xec, 0x85, 0xd7, 0xbe, 0xa7, 0x79, 0x8e }); 190private static readonly ImmutableArray<byte> s_SILVERLIGHT_PUBLICKEY_STR_L = ImmutableArray.Create(new byte[] { 0x31, 0xbf, 0x38, 0x56, 0xad, 0x36, 0x4e, 0x35 }); 191private static readonly ImmutableArray<byte> s_RIA_SERVICES_KEY_TOKEN = ImmutableArray.Create(new byte[] { 0xdd, 0xd0, 0xda, 0x4d, 0x3e, 0x67, 0x82, 0x17 });

37private static readonly ImmutableArray<string> s_compilerErrorCustomTags = ImmutableArray.Create(WellKnownDiagnosticTags.Compiler, WellKnownDiagnosticTags.Telemetry, WellKnownDiagnosticTags.NotConfigurable); 38private static readonly ImmutableArray<string> s_compilerNonErrorCustomTags = ImmutableArray.Create(WellKnownDiagnosticTags.Compiler, WellKnownDiagnosticTags.Telemetry);

100var builder = ImmutableArray.CreateBuilder<Diagnostic>();

360analyzerDiagnostics = ImmutableArray.CreateBuilder<Diagnostic>(); 380currentDiagnostics = ImmutableArray.CreateBuilder<Diagnostic>(); 414var builder = ImmutableArray.CreateBuilder<Diagnostic>();

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

1218var builder = ImmutableArray.CreateBuilder<Diagnostic>(); 1720await OnEventProcessedCoreAsync(processedContainerEvent, ImmutableArray.Create(analyzer), analysisScope, cancellationToken).ConfigureAwait(false);

303return ImmutableArray.Create(LanguageNames.CSharp); 408var builder = ImmutableArray.CreateBuilder<TExtension>(); 449var builder = ImmutableArray.CreateBuilder<TExtension>();

1014return ImmutableArray.Create<CompilationEvent>(compilationStartedEvent, compilationUnitCompletedEvent); 1298var analysisScope = _compilationAnalysisScope.WithAnalyzers(ImmutableArray.Create(analyzer), this);

204var builder = ImmutableArray.CreateBuilder<Diagnostic>();

569parameters = delegateInvokeMethod?.Parameters ?? ImmutableArray.Create<IParameterSymbol>(); 593ImmutableArray.Create(SymbolKind.Method, SymbolKind.Property, SymbolKind.NamedType));

61var mappedLocals = ImmutableArray.CreateRange(Locals, MapLocalInfo, map); 64ImmutableArray.CreateRange(StateMachineHoistedLocalSlotsOpt, MapHoistedLocalSlot, map); 67ImmutableArray.CreateRange(StateMachineAwaiterSlotsOpt, static (typeRef, map) => (typeRef is null) ? null : map.MapReference(typeRef), map);

177return ImmutableArray.Create(sizes); 233tableEntriesAdded: ImmutableArray.Create(tableSizes),

65private static readonly ImmutableArray<int> s_emptyTableSizes = ImmutableArray.Create(new int[MetadataTokens.TableCount]); 498return ImmutableArray.Create(sizes);

28numerals = ImmutableArray.Create("0", "1", "2", "3", "4", "5", "6", "7", "8", "9");

135var builder = ImmutableArray.CreateBuilder<MemberDescriptor>(count); 136var signatureBuilder = ImmutableArray.CreateBuilder<byte>();

374typeSymbol = MakeFunctionPointerTypeSymbol(Cci.CallingConventionUtils.FromSignatureConvention(signatureHeader.CallingConvention), ImmutableArray.Create(parameters));

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));

188return ImmutableArray.Create(hash); 440var builder = ImmutableArray.CreateBuilder<EmbeddedResource>(); 1115private static readonly ImmutableArray<bool> s_simpleTransformFlags = ImmutableArray.Create(true); 1481return (ImmutableArray.Create(paramName), true);

537ImmutableArray<byte> publicKey = (publicKeyBytes != null) ? ImmutableArray.Create(publicKeyBytes) : ImmutableArray<byte>.Empty; 556ImmutableArray.Create(name.GetPublicKeyToken()),

103_initialModules = ImmutableArray.Create(manifestModule); 186return new AssemblyMetadata(ImmutableArray.Create(module)); 245return Create(ImmutableArray.CreateRange(modules)); 330moduleBuilder = ImmutableArray.CreateBuilder<ModuleMetadata>(1 + additionalModuleNames.Length);

54return this.WithAliases(ImmutableArray.CreateRange(aliases));

52return WithAliases(ImmutableArray.CreateRange(aliases));

157return CreateFromImage(ImmutableArray.CreateRange(peImage));

81return this.WithAliases(ImmutableArray.CreateRange(aliases));

3290return new InvalidOperation(ImmutableArray.Create<IOperation>(child), 3297return MakeInvalidOperation(syntax, type, ImmutableArray.Create<IOperation>(child1, child2)); 4310ImmutableArray.Create(lockStatement.LockTakenSymbol) : 4343ImmutableArray.Create<IArgumentOperation>( 4371ImmutableArray.Create<IArgumentOperation>( 4426ImmutableArray.Create<IArgumentOperation>( 4482regionForCollection = new RegionBuilder(ControlFlowRegionKind.LocalLifetime, locals: ImmutableArray.Create(local)); 5856initializer = new InvalidOperation(ImmutableArray.Create(initializer, operationInitializer), 6063var validKinds = ImmutableArray.Create(OperationKind.Invocation, OperationKind.DynamicInvocation, OperationKind.Increment, OperationKind.Literal, 7521var visitedReDimOperation = new ReDimOperation(ImmutableArray.Create(visitedReDimClause), operation.Preserve,

88ImmutableArray.Create(

244BlobHandle partIndex = GetOrAddBlob(ImmutableArray.Create(MetadataWriter.s_utf8Encoding.GetBytes(part)));

437return ImmutableArray.CreateRange(referenceMap);

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

121return ImmutableArray.CreateRange(algorithm.ComputeHash(stream));

193var arrayBuilder = ImmutableArray.CreateBuilder<string>();

100var includes = ImmutableArray.CreateBuilder<RuleSetInclude>();

40_state = new GeneratorDriverState(parseOptions, optionsProvider, generators, incrementalGenerators, additionalTexts, ImmutableArray.Create(new GeneratorState[generators.Length]), DriverStateTable.Empty, SyntaxStore.Empty, driverOptions, runtime: TimeSpan.Zero);

99ImmutableArray.Create(error),

65var stepInputs = tableBuilder.TrackIncrementalSteps ? ImmutableArray.Create((entry1.Step!, entry1.OutputIndex), (input2Step!, 0)) : default; 95var stepInputs = ImmutableArray.Create((entry.Step!, entry.OutputIndex), (input2Step!, 0));

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;

138var builder = ImmutableArray.CreateBuilder<(SyntaxTree Tree, SourceGeneratorSyntaxTreeInfo Info)>(count);

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);

113yield return new CustomDebugInfoRecord(kind, version, ImmutableArray.Create(customDebugInfo, offset, bodySize - alignmentSize));

64return ImmutableArray.Create<T>(); 72return ImmutableArray.CreateRange<T>(items); 92return ImmutableArray.CreateRange(items);

38return ImmutableArray.CreateRange<T>(items); 55return ImmutableArray.CreateRange<T>(items); 72return ImmutableArray.CreateRange<T>(items); 84return ImmutableArray.Create<T>(items); 101return ImmutableArray.Create<T>(items); 117return ImmutableArray.Create<T>(items); 127return ImmutableArray.Create<byte>(stream.ToArray()); 140return ImmutableArray.CreateRange(items, map); 155return ImmutableArray.CreateRange(items, map, arg); 854? ImmutableArray.Create(symbol) 855: ImmutableArray<TNamespaceOrTypeSymbol>.CastUp(ImmutableArray.Create((TNamedTypeSymbol)symbol)); 1261/// Variant of <see cref="System.Collections.Immutable.ImmutableArray.BinarySearch{T}(ImmutableArray{T}, T, IComparer{T}?)"/>

40private static readonly ImmutableArray<int> s_primes = ImmutableArray.Create(

186=> HasOneItem ? ImmutableArray.Create(_one) : _many; 273=> new OneOrMany<T>(ImmutableArray.Create(one, two));

3131 => ImmutableArray.Create(_item0), 3142 => ImmutableArray.Create(_item0, _item1), 3153 => ImmutableArray.Create(_item0, _item1, _item2), 3164 => ImmutableArray.Create(_item0, _item1, _item2, _item3),

62_builder = ImmutableArray.CreateBuilder<T>(size); 567dictionary1.Add(keySelector(value), ImmutableArray.Create(value));

76private static readonly ImmutableArray<byte> s_ecmaKey = ImmutableArray.Create(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0 });

82var fileContent = ImmutableArray.Create(FileSystem.ReadAllBytes(resolvedKeyFile));

112var fileContent = ImmutableArray.Create(File.ReadAllBytes(keyFilePath));

220_idToNodeMap = map.ToImmutableSegmentedDictionary(kv => kv.Key, kv => (IReadOnlyList<SyntaxNode>)ImmutableArray.CreateRange(kv.Value));

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

693return ImmutableArray.Create(algorithm.ComputeHash(buffer, offset, count)); 706return ImmutableArray.Create(algorithm.ComputeHash(stream)); 895return ImmutableArray.Create(new TextChangeRange(new TextSpan(0, oldText.Length), this.Length));

69ImmutableArray.Create(CreateCodeActionEquivalenceKeyRule, OverrideCodeActionEquivalenceKeyRule, OverrideGetFixAllProviderRule);

34public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(DoNotIgnoreReturnValueDiagnosticRule); 42private static readonly ImmutableArray<string> s_immutableMethodNames = ImmutableArray.Create( 56var builder = ImmutableArray.CreateBuilder<INamedTypeSymbol>();

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);

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

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

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

33private static readonly ImmutableArray<string> s_WorkspaceAssemblyNames = ImmutableArray.Create( 61public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(DoNotUseTypesFromAssemblyDirectRule, DoNotUseTypesFromAssemblyIndirectRule);

43public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(MissingDiagnosticAnalyzerAttributeRule, AddLanguageSupportToAnalyzerRule);

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

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

279var infoList = ImmutableArray.CreateBuilder<(string? prefix, int start, int end)>(ranges.Length);

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);

43ImmutableArray.Create(DiagnosticIds.DeclareDiagnosticIdInAnalyzerReleaseRuleId, DiagnosticIds.UpdateDiagnosticIdInAnalyzerReleaseRuleId, DiagnosticIds.EnableAnalyzerReleaseTrackingRuleId);

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

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

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

38public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(InvalidReportDiagnosticRule); 181ImmutableArray<IFieldSymbol>.Builder builder = ImmutableArray.CreateBuilder<IFieldSymbol>();

46public sealed override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(SymbolIsBannedInAnalyzersAnalyzer.SymbolIsBannedRule, SymbolIsBannedInAnalyzersAnalyzer.NoSettingSpecifiedSymbolIsBannedRule);

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

28numerals = ImmutableArray.Create("0", "1", "2", "3", "4", "5", "6", "7", "8", "9");

64return ImmutableArray.Create<T>(); 72return ImmutableArray.CreateRange<T>(items); 92return ImmutableArray.CreateRange(items);

38return ImmutableArray.CreateRange<T>(items); 55return ImmutableArray.CreateRange<T>(items); 72return ImmutableArray.CreateRange<T>(items); 84return ImmutableArray.Create<T>(items); 101return ImmutableArray.Create<T>(items); 117return ImmutableArray.Create<T>(items); 127return ImmutableArray.Create<byte>(stream.ToArray()); 140return ImmutableArray.CreateRange(items, map); 155return ImmutableArray.CreateRange(items, map, arg); 854? ImmutableArray.Create(symbol) 855: ImmutableArray<TNamespaceOrTypeSymbol>.CastUp(ImmutableArray.Create((TNamedTypeSymbol)symbol)); 1261/// Variant of <see cref="System.Collections.Immutable.ImmutableArray.BinarySearch{T}(ImmutableArray{T}, T, IComparer{T}?)"/>

40private static readonly ImmutableArray<int> s_primes = ImmutableArray.Create(

186=> HasOneItem ? ImmutableArray.Create(_one) : _many; 273=> new OneOrMany<T>(ImmutableArray.Create(one, two));

3131 => ImmutableArray.Create(_item0), 3142 => ImmutableArray.Create(_item0, _item1), 3153 => ImmutableArray.Create(_item0, _item1, _item2), 3164 => ImmutableArray.Create(_item0, _item1, _item2, _item3),

62_builder = ImmutableArray.CreateBuilder<T>(size); 567dictionary1.Add(keySelector(value), ImmutableArray.Create(value));

80var builder = ImmutableArray.CreateBuilder<INamespaceOrTypeSymbol>();

82var builder = ImmutableArray.CreateBuilder<INamespaceOrTypeSymbol>();

557ImmutableArray<IMethodSymbol>.Builder originalDefinitionsBuilder = ImmutableArray.CreateBuilder<IMethodSymbol>();

88return ImmutableArray.Create(operation); 91var builder = ImmutableArray.CreateBuilder<IOperation>(); 383ImmutableArray.Create(OperationKind.AnonymousFunction, OperationKind.LocalFunction);

24ImmutableArray<IPropertySymbol>.Builder originalDefinitionsBuilder = ImmutableArray.CreateBuilder<IPropertySymbol>();

13= ImmutableArray.Create(

21private static readonly ImmutableArray<IOption2>.Builder s_editorConfigOptionsBuilder = ImmutableArray.CreateBuilder<IOption2>();

14private static readonly ImmutableArray<IOption2>.Builder s_allOptionsBuilder = ImmutableArray.CreateBuilder<IOption2>();

31return ImmutableArray.Create<T>(items);

128var nodes = ImmutableArray.CreateBuilder<Node>(_builderNodes.Length); 132var edges = ImmutableArray.CreateBuilder<Edge>(Math.Max(0, _builderNodes.Length - 1));

226var builder = ImmutableArray.CreateBuilder<byte>(count);

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))]);

135newTypeParameter.ConstraintTypes = ImmutableArray.CreateRange(newTypeParameter.ConstraintTypes, t => t.SubstituteTypes(mapping, typeGenerator));

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

52var formattingRules = ImmutableArray.Create(

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

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

1639=> ReferenceAssemblies.NetCore.NetCoreApp31.AddPackages(ImmutableArray.Create(

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"))); 22private static readonly ReferenceAssemblies s_withMSBuildWorkspaces = ReferenceAssemblies.NetFramework.Net461.Default.AddPackages(ImmutableArray.Create(

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

28numerals = ImmutableArray.Create("0", "1", "2", "3", "4", "5", "6", "7", "8", "9");

64return ImmutableArray.Create<T>(); 72return ImmutableArray.CreateRange<T>(items); 92return ImmutableArray.CreateRange(items);

38return ImmutableArray.CreateRange<T>(items); 55return ImmutableArray.CreateRange<T>(items); 72return ImmutableArray.CreateRange<T>(items); 84return ImmutableArray.Create<T>(items); 101return ImmutableArray.Create<T>(items); 117return ImmutableArray.Create<T>(items); 127return ImmutableArray.Create<byte>(stream.ToArray()); 140return ImmutableArray.CreateRange(items, map); 155return ImmutableArray.CreateRange(items, map, arg); 854? ImmutableArray.Create(symbol) 855: ImmutableArray<TNamespaceOrTypeSymbol>.CastUp(ImmutableArray.Create((TNamedTypeSymbol)symbol)); 1261/// Variant of <see cref="System.Collections.Immutable.ImmutableArray.BinarySearch{T}(ImmutableArray{T}, T, IComparer{T}?)"/>

40private static readonly ImmutableArray<int> s_primes = ImmutableArray.Create(

186=> HasOneItem ? ImmutableArray.Create(_one) : _many; 273=> new OneOrMany<T>(ImmutableArray.Create(one, two));

3131 => ImmutableArray.Create(_item0), 3142 => ImmutableArray.Create(_item0, _item1), 3153 => ImmutableArray.Create(_item0, _item1, _item2), 3164 => ImmutableArray.Create(_item0, _item1, _item2, _item3),

62_builder = ImmutableArray.CreateBuilder<T>(size); 567dictionary1.Add(keySelector(value), ImmutableArray.Create(value));

80var builder = ImmutableArray.CreateBuilder<INamespaceOrTypeSymbol>();

82var builder = ImmutableArray.CreateBuilder<INamespaceOrTypeSymbol>();

557ImmutableArray<IMethodSymbol>.Builder originalDefinitionsBuilder = ImmutableArray.CreateBuilder<IMethodSymbol>();

88return ImmutableArray.Create(operation); 91var builder = ImmutableArray.CreateBuilder<IOperation>(); 383ImmutableArray.Create(OperationKind.AnonymousFunction, OperationKind.LocalFunction);

24ImmutableArray<IPropertySymbol>.Builder originalDefinitionsBuilder = ImmutableArray.CreateBuilder<IPropertySymbol>();

13= ImmutableArray.Create(

32builder ??= ImmutableArray.CreateBuilder<T>();

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

46ImmutableArray<TaintedDataSourceSink>.Builder builder = ImmutableArray.CreateBuilder<TaintedDataSourceSink>();

32var dependencyFullTypeNames = ImmutableArray.Create(WellKnownTypeNames.MicrosoftAspNetCoreMvcControllerBase,

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

21private static readonly ImmutableArray<IOption2>.Builder s_editorConfigOptionsBuilder = ImmutableArray.CreateBuilder<IOption2>();

14private static readonly ImmutableArray<IOption2>.Builder s_allOptionsBuilder = ImmutableArray.CreateBuilder<IOption2>();

31return ImmutableArray.Create<T>(items);

128var nodes = ImmutableArray.CreateBuilder<Node>(_builderNodes.Length); 132var edges = ImmutableArray.CreateBuilder<Edge>(Math.Max(0, _builderNodes.Length - 1));

226var builder = ImmutableArray.CreateBuilder<byte>(count);

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

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

28numerals = ImmutableArray.Create("0", "1", "2", "3", "4", "5", "6", "7", "8", "9");

64return ImmutableArray.Create<T>(); 72return ImmutableArray.CreateRange<T>(items); 92return ImmutableArray.CreateRange(items);

38return ImmutableArray.CreateRange<T>(items); 55return ImmutableArray.CreateRange<T>(items); 72return ImmutableArray.CreateRange<T>(items); 84return ImmutableArray.Create<T>(items); 101return ImmutableArray.Create<T>(items); 117return ImmutableArray.Create<T>(items); 127return ImmutableArray.Create<byte>(stream.ToArray()); 140return ImmutableArray.CreateRange(items, map); 155return ImmutableArray.CreateRange(items, map, arg); 854? ImmutableArray.Create(symbol) 855: ImmutableArray<TNamespaceOrTypeSymbol>.CastUp(ImmutableArray.Create((TNamedTypeSymbol)symbol)); 1261/// Variant of <see cref="System.Collections.Immutable.ImmutableArray.BinarySearch{T}(ImmutableArray{T}, T, IComparer{T}?)"/>

40private static readonly ImmutableArray<int> s_primes = ImmutableArray.Create(

186=> HasOneItem ? ImmutableArray.Create(_one) : _many; 273=> new OneOrMany<T>(ImmutableArray.Create(one, two));

3131 => ImmutableArray.Create(_item0), 3142 => ImmutableArray.Create(_item0, _item1), 3153 => ImmutableArray.Create(_item0, _item1, _item2), 3164 => ImmutableArray.Create(_item0, _item1, _item2, _item3),

62_builder = ImmutableArray.CreateBuilder<T>(size); 567dictionary1.Add(keySelector(value), ImmutableArray.Create(value));

80var builder = ImmutableArray.CreateBuilder<INamespaceOrTypeSymbol>();

82var builder = ImmutableArray.CreateBuilder<INamespaceOrTypeSymbol>();

557ImmutableArray<IMethodSymbol>.Builder originalDefinitionsBuilder = ImmutableArray.CreateBuilder<IMethodSymbol>();

88return ImmutableArray.Create(operation); 91var builder = ImmutableArray.CreateBuilder<IOperation>(); 383ImmutableArray.Create(OperationKind.AnonymousFunction, OperationKind.LocalFunction);

24ImmutableArray<IPropertySymbol>.Builder originalDefinitionsBuilder = ImmutableArray.CreateBuilder<IPropertySymbol>();

13= ImmutableArray.Create(

21private static readonly ImmutableArray<IOption2>.Builder s_editorConfigOptionsBuilder = ImmutableArray.CreateBuilder<IOption2>();

14private static readonly ImmutableArray<IOption2>.Builder s_allOptionsBuilder = ImmutableArray.CreateBuilder<IOption2>();

31return ImmutableArray.Create<T>(items);

128var nodes = ImmutableArray.CreateBuilder<Node>(_builderNodes.Length); 132var edges = ImmutableArray.CreateBuilder<Edge>(Math.Max(0, _builderNodes.Length - 1));

226var builder = ImmutableArray.CreateBuilder<byte>(count);

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))]);

135newTypeParameter.ConstraintTypes = ImmutableArray.CreateRange(newTypeParameter.ConstraintTypes, t => t.SubstituteTypes(mapping, typeGenerator));

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

52var formattingRules = ImmutableArray.Create(

48ImmutableArray.Create(SymbolIsBannedAnalyzer.SymbolIsBannedRule, SymbolIsBannedAnalyzer.DuplicateBannedSymbolRule);

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

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

76var customTagsBuilder = ImmutableArray.CreateBuilder<string>();

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

107var additionalLocations = ImmutableArray.Create( 109var additionalUnnecessaryLocations = ImmutableArray.Create(

214var notifications = ImmutableArray.Create(unusedParametersOption.Notification, unusedValueExpressionStatementSeverity, unusedValueAssignmentSeverity);

648var additionalLocations = ImmutableArray.Create(

119var locations = ImmutableArray.Create(

123var locations = ImmutableArray.Create(

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

35var additionalUnnecessaryLocations = ImmutableArray.Create( 47var additionalUnnecessaryLocations = ImmutableArray.Create(

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

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

128var allLocations = ImmutableArray.Create(

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

28numerals = ImmutableArray.Create("0", "1", "2", "3", "4", "5", "6", "7", "8", "9");

64return ImmutableArray.Create<T>(); 72return ImmutableArray.CreateRange<T>(items); 92return ImmutableArray.CreateRange(items);

38return ImmutableArray.CreateRange<T>(items); 55return ImmutableArray.CreateRange<T>(items); 72return ImmutableArray.CreateRange<T>(items); 84return ImmutableArray.Create<T>(items); 101return ImmutableArray.Create<T>(items); 117return ImmutableArray.Create<T>(items); 127return ImmutableArray.Create<byte>(stream.ToArray()); 140return ImmutableArray.CreateRange(items, map); 155return ImmutableArray.CreateRange(items, map, arg); 854? ImmutableArray.Create(symbol) 855: ImmutableArray<TNamespaceOrTypeSymbol>.CastUp(ImmutableArray.Create((TNamedTypeSymbol)symbol)); 1261/// Variant of <see cref="System.Collections.Immutable.ImmutableArray.BinarySearch{T}(ImmutableArray{T}, T, IComparer{T}?)"/>

40private static readonly ImmutableArray<int> s_primes = ImmutableArray.Create(

186=> HasOneItem ? ImmutableArray.Create(_one) : _many; 273=> new OneOrMany<T>(ImmutableArray.Create(one, two));

3131 => ImmutableArray.Create(_item0), 3142 => ImmutableArray.Create(_item0, _item1), 3153 => ImmutableArray.Create(_item0, _item1, _item2), 3164 => ImmutableArray.Create(_item0, _item1, _item2, _item3),

62_builder = ImmutableArray.CreateBuilder<T>(size); 567dictionary1.Add(keySelector(value), ImmutableArray.Create(value));

21private static readonly ImmutableArray<IOption2>.Builder s_editorConfigOptionsBuilder = ImmutableArray.CreateBuilder<IOption2>();

14private static readonly ImmutableArray<IOption2>.Builder s_allOptionsBuilder = ImmutableArray.CreateBuilder<IOption2>();

31return ImmutableArray.Create<T>(items);

128var nodes = ImmutableArray.CreateBuilder<Node>(_builderNodes.Length); 132var edges = ImmutableArray.CreateBuilder<Edge>(Math.Max(0, _builderNodes.Length - 1));

226var builder = ImmutableArray.CreateBuilder<byte>(count);

126return (ImmutableArray.Create<ISymbol>(disposeImplMethod, disposeInterfaceMethod), finalizer); 215? ImmutableArray.Create(disposeMethod) : default;

53var diagnostics = ImmutableArray.CreateBuilder<Diagnostic>();

59var kinds = ImmutableArray.Create(new SymbolKindOrTypeKind(MethodKind.Ordinary)); 60var modifiers = ImmutableArray.Create(new ModifierKind(ModifierKindEnum.IsAsync)); 69var kinds = ImmutableArray.Create(new SymbolKindOrTypeKind(SymbolKind.Field), new SymbolKindOrTypeKind(SymbolKind.Parameter), new SymbolKindOrTypeKind(SymbolKind.Local)); 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))]);

135newTypeParameter.ConstraintTypes = ImmutableArray.CreateRange(newTypeParameter.ConstraintTypes, t => t.SubstituteTypes(mapping, typeGenerator));

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

52var formattingRules = ImmutableArray.Create(

64return ImmutableArray.Create<T>(); 72return ImmutableArray.CreateRange<T>(items); 92return ImmutableArray.CreateRange(items);

38return ImmutableArray.CreateRange<T>(items); 55return ImmutableArray.CreateRange<T>(items); 72return ImmutableArray.CreateRange<T>(items); 84return ImmutableArray.Create<T>(items); 101return ImmutableArray.Create<T>(items); 117return ImmutableArray.Create<T>(items); 127return ImmutableArray.Create<byte>(stream.ToArray()); 140return ImmutableArray.CreateRange(items, map); 155return ImmutableArray.CreateRange(items, map, arg); 854? ImmutableArray.Create(symbol) 855: ImmutableArray<TNamespaceOrTypeSymbol>.CastUp(ImmutableArray.Create((TNamedTypeSymbol)symbol)); 1261/// Variant of <see cref="System.Collections.Immutable.ImmutableArray.BinarySearch{T}(ImmutableArray{T}, T, IComparer{T}?)"/>

40private static readonly ImmutableArray<int> s_primes = ImmutableArray.Create(

186=> HasOneItem ? ImmutableArray.Create(_one) : _many; 273=> new OneOrMany<T>(ImmutableArray.Create(one, two));

62_builder = ImmutableArray.CreateBuilder<T>(size); 567dictionary1.Add(keySelector(value), ImmutableArray.Create(value));

3131 => ImmutableArray.Create(_item0), 3142 => ImmutableArray.Create(_item0, _item1), 3153 => ImmutableArray.Create(_item0, _item1, _item2), 3164 => ImmutableArray.Create(_item0, _item1, _item2, _item3),

13public static readonly ImmutableArray<byte> PublicKey_ce65828c82a341f2 = ImmutableArray.Create(new byte[] 27public static readonly ImmutableArray<byte> PublicKey_b03f5f7f11d50a3a = ImmutableArray.Create(new byte[] 41public static readonly ImmutableArray<byte> PublicKey_31bf3856ad364e35 = ImmutableArray.Create(new byte[]

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), 1538ImmutableArray.Create<BoundExpression>(methodGroup.ReceiverOpt, new BoundValuePlaceholder(syntax, secondArgumentType) { WasCompilerGenerated = true }), 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); 10453argumentPlaceholders = ImmutableArray.Create(startArgumentPlaceholder, lengthArgumentPlaceholder); 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); 1807ImmutableArray.Create(arraySize),

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

263result = MakeQueryInvocation(state.selectOrGroup, e, receiverIsCheckedForRValue: false, "GroupBy", ImmutableArray.Create(lambdaLeft, lambdaRight), d 303ImmutableArray.Create(state.fromExpression), state.fromExpression.Type); 424var resultSelectorLambda = MakeQueryUnboundLambda(state.RangeVariableMap(), ImmutableArray.Create(x1, x2), select.Expression, diagnostics.AccumulatesDependencies); 431ImmutableArray.Create(inExpression, outerKeySelectorLambda, innerKeySelectorLambda, resultSelectorLambda), 453var resultSelectorLambda = MakeQueryUnboundLambda(state.RangeVariableMap(), ImmutableArray.Create(x1, g), select.Expression, diagnostics.AccumulatesDependencies); 460ImmutableArray.Create(inExpression, outerKeySelectorLambda, innerKeySelectorLambda, resultSelectorLambda), 501ImmutableArray.Create(inExpression, outerKeySelectorLambda, innerKeySelectorLambda, resultSelectorLambda), 532ImmutableArray.Create(inExpression, outerKeySelectorLambda, innerKeySelectorLambda, resultSelectorLambda), 613var resultSelectorLambda = MakeQueryUnboundLambda(state.RangeVariableMap(), ImmutableArray.Create(x1, x2), select.Expression, diagnostics.AccumulatesDependencies); 620ImmutableArray.Create(collectionSelectorLambda, resultSelectorLambda), 668ImmutableArray.Create(collectionSelectorLambda, resultSelectorLambda), 705var result = MakeQueryUnboundLambda(state.RangeVariableMap(), ImmutableArray.Create(x1, x2), node, bodyFactory, withDependencies); 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); 813ImmutableArray.Create( 821return MakeConstruction(node, anonymousType, ImmutableArray.Create(field1Value, field2Value), diagnostics); 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();

1775/// intermediary allocations for <see cref="ImmutableArray"/>s.

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)); 1228return Conversion.MakeConditionalExpression(ImmutableArray.Create(trueConversion, falseConversion)); 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)); 180return Synthesized(syntax, receiverOpt, initialBindingReceiverIsSubjectToCloning: initialBindingReceiverIsSubjectToCloning, method, ImmutableArray.Create(arg0, arg1)); 254: this(syntax, constructor, ImmutableArray.Create<BoundExpression>(arguments), default(ImmutableArray<string?>), default(ImmutableArray<RefKind>), false, default(ImmutableArray<int>), default(BitVector), null, null, constructor.ContainingType) 591return new BoundBlock(syntax, ImmutableArray<LocalSymbol>.Empty, ImmutableArray.Create(statement))

44protected override ImmutableArray<BoundNode?> Children => ImmutableArray.Create<BoundNode?>(this.Left, this.Right); 81protected override ImmutableArray<BoundNode?> Children => ImmutableArray.Create<BoundNode?>(this.Value); 91protected override ImmutableArray<BoundNode?> Children => ImmutableArray.Create<BoundNode?>(this.Argument); 96protected override ImmutableArray<BoundNode?> Children => ImmutableArray.Create<BoundNode?>(this.Expression, this.Index); 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); 180protected override ImmutableArray<BoundNode?> Children => ImmutableArray.Create<BoundNode?>(this.Receiver, Argument);

30protected override ImmutableArray<BoundNode?> Children => ImmutableArray.Create<BoundNode?>(this.Declarations, this.Body); 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) 5188: ImmutableArray.Create<ISymbol>(namedType, primaryConstructor.GetPublicSymbol()); 5193? ImmutableArray.Create(symbol)

826return ImmutableArray.Create<ISymbol>();

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 }), 402arguments: ImmutableArray.Create<BoundExpression>(boundBackingField, boundParameter)), 416statements: ImmutableArray.Create<BoundStatement>( 421compareExchangeMethod = compareExchangeMethod.Construct(ImmutableArray.Create<TypeSymbol>(delegateType)); 467arguments: ImmutableArray.Create<BoundExpression>(boundTmps[1], boundParameter)), 485arguments: ImmutableArray.Create<BoundExpression>(boundBackingField, boundTmps[2], boundTmps[1])); 517statements: ImmutableArray.Create<BoundStatement>( 566ImmutableArray.Create<BoundStatement>( 574ImmutableArray.Create<BoundStatement>(

83ImmutableArray.Create<LocalSymbol>(hashCode, i), 175ImmutableArray.Create<LocalSymbol>(hashCode, i),

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

949return ImmutableArray.Create<ISymbol>(); 962return ImmutableArray.Create<ISymbol>(); 975return ImmutableArray.Create<ISymbol>(); 991return ImmutableArray.Create<IPropertySymbol>();

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

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

189return ImmutableArray.Create(result);

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)));

279ImmutableArray.Create(new TypedConstant(stringType, TypedConstantKind.Primitive, guidString),

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

57ImmutableArray.CreateRange(AsEnumerable());

392return ImmutableArray.CreateRange(data.Where(s => s.CanBeReferencedByName).OrderBy(s => s, LexicalOrderSymbolComparer.Instance).GetPublicSymbols()); 397return ImmutableArray.CreateRange(data.Where(s => s.CanBeReferencedByName).OrderBy(s => s, LexicalOrderSymbolComparer.Instance).Select(p => p.GetPublicSymbol()));

294private static readonly ImmutableArray<BoundKind> s_skippedExpressions = ImmutableArray.Create(BoundKind.ArrayInitialization, 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));

210ImmutableArray.CreateRange(_variableSlot),

236ImmutableArray.Create(catchAll), 459ImmutableArray.Create<LocalSymbol>(obj), 495ImmutableArray.Create(ex), 552ImmutableArray.Create<LocalSymbol>( 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);

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

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

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

667var frameTypeParameters = ImmutableArray.Create(_currentTypeParameters.SelectAsArray(t => TypeWithAnnotations.Create(t)), 0, frame.Arity); 1030var realTypeArguments = ImmutableArray.Create(_currentTypeParameters.SelectAsArray(t => TypeWithAnnotations.Create(t)), 0, totalTypeArgumentCount - originalMethod.Arity); 1038var containerTypeArguments = ImmutableArray.Create(realTypeArguments, 0, containerAsFrame.Arity); 1039realTypeArguments = ImmutableArray.Create(realTypeArguments, containerAsFrame.Arity, realTypeArguments.Length - containerAsFrame.Arity); 1129sideEffects: ImmutableArray.Create<BoundExpression>(rewritten), 1251ImmutableArray.Create<LocalSymbol>(), 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);

129typeArguments = ImmutableArray.Create(typeArguments, 0, lambdaFrame.Arity);

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))); 299ImmutableArray.Create<BoundStatement>(foreachKeywordSequencePoint,

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

450return ImmutableArray.Create(_factory.Sequence(new[] { value }, refAssignmentSourceIndex), index); 464return ImmutableArray.Create(addressOf, _factory.Sizeof(targetType), index); 484return ImmutableArray.Create(toString, index); 487return ImmutableArray.Create(_factory.Convert(parameter.Type, value), index); 544ImmutableArray.Create<BoundStatement>(logCallStatement, rewrittenFilterPrologue) : 545ImmutableArray.Create<BoundStatement>(logCallStatement)); 622return _factory.Sequence(ImmutableArray.Create(temp.LocalSymbol), builder.ToImmutableAndFree(), temp);

27_parameters = ImmutableArray.Create<ParameterSymbol>(

118ImmutableArray.Create(cachedState) : 119ImmutableArray.Create(cachedState, cachedThis), 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)); 588return BadExpression(syntax, resultType, ImmutableArray.Create(child1, child2)); 720return block.Update(locals, block.LocalFunctions, block.HasUnsafeModifier, block.Instrumentation, ImmutableArray.Create(statement)); 732ImmutableArray.Create(statement)); 849.Construct(ImmutableArray.Create(elementType)), 850ImmutableArray.Create(

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), 1116locals: ImmutableArray.Create<LocalSymbol>(boundTempX.LocalSymbol, boundTempY.LocalSymbol), 1117sideEffects: ImmutableArray.Create<BoundExpression>(tempAssignmentX, tempAssignmentY), 1305locals: ImmutableArray.Create<LocalSymbol>(boundTempX.LocalSymbol, boundTempY.LocalSymbol), 1306sideEffects: ImmutableArray.Create<BoundExpression>(tempAssignmentX, tempAssignmentY), 1415sideEffects: ImmutableArray.Create<BoundExpression>(sideEffect), 1752locals: ImmutableArray.Create<LocalSymbol>(boundTemp.LocalSymbol), 1753sideEffects: ImmutableArray.Create<BoundExpression>(tempAssignment), 1813locals: ImmutableArray.Create<LocalSymbol>(boundTempX.LocalSymbol, boundTempY.LocalSymbol), 1814sideEffects: ImmutableArray.Create<BoundExpression>(tempAssignmentX, tempAssignmentY), 1901locals: ImmutableArray.Create<LocalSymbol>(boundTempX.LocalSymbol, boundTempY.LocalSymbol), 1902sideEffects: ImmutableArray.Create<BoundExpression>(tempAssignmentX, tempAssignmentY), 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)); 575Construct(ImmutableArray.Create(TypeWithAnnotations.Create(inlineArrayType), elementType)); 604inlineArrayAsSpan = inlineArrayAsSpan.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(inlineArrayType), 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);

69ImmutableArray.Create<BoundStatement>(rewrittenBody,

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); 137marshalArguments = ImmutableArray.Create<BoundExpression>(removeDelegate, rewrittenArgument); 152marshalArguments = ImmutableArray.Create<BoundExpression>(addDelegate, removeDelegate, rewrittenArgument); 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), 334ImmutableArray.Create(rewrittenReceiver, rewrittenArgument), ErrorTypeSymbol.UnknownResultType);

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), 275statements: ImmutableArray.Create<BoundStatement>(enumeratorVarDecl, tryFinally)); 286locals: ImmutableArray.Create(enumeratorVar), 287statements: ImmutableArray.Create<BoundStatement>(enumeratorVarDecl, whileLoop)); 417statements: ImmutableArray.Create(alwaysOrMaybeDisposeStmt)); 471locals: ImmutableArray.Create(disposableVar), 472statements: ImmutableArray.Create(disposableVarDecl, ifStmt)); 622arrayVarDecl = new BoundStatementList(arrayVarDecl.Syntax, ImmutableArray.Create(collectionVarInitializationPreamble, arrayVarDecl)).MakeCompilerGenerated(); 652statements: ImmutableArray.Create<BoundStatement>(arrayVarDecl, positionVarDecl)); 685outerLocals: preambleLocal is null ? ImmutableArray.Create<LocalSymbol>(collectionTemp, positionVar) : ImmutableArray.Create<LocalSymbol>(preambleLocal, collectionTemp, positionVar), 847statements: ImmutableArray.Create(iteratorVariableInitialization, rewrittenBody)); 936indices: ImmutableArray.Create<BoundExpression>(boundPositionVar), 945statements: ImmutableArray.Create<BoundStatement>(arrayVarDecl, positionVarDecl)); 981outerLocals: ImmutableArray.Create<LocalSymbol>(arrayVar, positionVar), 1088ImmutableArray<BoundExpression> dimensionArgument = ImmutableArray.Create( 1115indices: ImmutableArray.Create((BoundExpression[])boundPositionVar), 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), 81statements: ImmutableArray.Create(expressionStatement, tryFinally)); 117exitCallExpr = new BoundBadExpression(lockSyntax, LookupResultKind.NotInvocable, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create<BoundExpression>(boundLockTemp), ErrorTypeSymbol.UnknownResultType); 170ImmutableArray.Create(boundLockTemp.LocalSymbol, boundLockTakenTemp.LocalSymbol), 171ImmutableArray.Create( 176BoundBlock.SynthesizedNoLocals(lockSyntax, ImmutableArray.Create<BoundStatement>( 212enterCallExpr = new BoundBadExpression(lockSyntax, LookupResultKind.NotInvocable, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create<BoundExpression>(boundLockTemp), ErrorTypeSymbol.UnknownResultType); 221ImmutableArray.Create(boundLockTemp.LocalSymbol), 222ImmutableArray.Create(

142var alternative = _factory.Sequence(ImmutableArray<LocalSymbol>.Empty, ImmutableArray.Create(tmpAssignment, transformedLhsAssignment), tmp);

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

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

461rewrittenAccess = getSubArrayCall.Update(ImmutableArray.Create(getSubArrayCall.Arguments[0], rangeTemp));

175return F.New(constructionMethod, ImmutableArray.Create(left, right)); 187return F.StaticCall(constructionMethod, ImmutableArray.Create(arg)); 205ImmutableArray.Create<BoundExpression>(F.Literal(0), F.Literal(fromEnd)));

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

133return new InterpolationHandlerResult(ImmutableArray.Create(_factory.ExpressionStatement(handlerConstructionAssignment), resultIf), builderTemp, appendShouldProceedLocal.LocalSymbol, this); 286? ImmutableArray.Create(HandlerTemp.LocalSymbol, _outTemp) 287: ImmutableArray.Create(HandlerTemp.LocalSymbol);

54ImmutableArray<BoundExpression> smallestCtorArguments = ImmutableArray.Create(rewrittenArguments, 88ImmutableArray<BoundExpression> ctorArguments = ImmutableArray.Create(rewrittenArguments,

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)); 196statements: ImmutableArray.Create<BoundStatement>(expressionStatement, tryFinally)); 258locals: ImmutableArray.Create<LocalSymbol>(boundTemp.LocalSymbol), //localSymbol will be declared by an enclosing block 259statements: ImmutableArray.Create<BoundStatement>( 463disposeCall = new BoundBadExpression(resourceSyntax, LookupResultKind.NotInvocable, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create(disposedExpression), ErrorTypeSymbol.UnknownResultType);

150ImmutableArray.Create(

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

98var loweredArguments = ImmutableArray.Create(loweredOperand); 130var loweredArguments = ImmutableArray.Create(loweredOperand); 173var loweredArguments = ImmutableArray.Create<BoundExpression>(loweredLeft, loweredRight);

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]))); 469ImmutableArray.Create(Spill(builder, call.Arguments[0]), Spill(builder, call.Arguments[1]))); 523return call.Update(ImmutableArray.Create(Spill(builder, call.Arguments[0], call.ArgumentRefKindsOpt[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); }

463return Block(ImmutableArray.Create(statements)); 468return Block(locals, ImmutableArray.Create(statements)); 478return Block(locals, localFunctions, ImmutableArray.Create(statements)); 508return new BoundStatementList(Syntax, ImmutableArray.Create(first, second)) { WasCompilerGenerated = true }; 844return Call(receiver, method, ImmutableArray.Create(arg0), useStrictArgumentRefKinds); 849return Call(receiver, method, ImmutableArray.Create(arg0, arg1), useStrictArgumentRefKinds); 854return Call(receiver, method, ImmutableArray.Create<BoundExpression>(args)); 858=> Call(receiver, WellKnownMethod(method), ImmutableArray.Create(arg0)); 1005return MakeSequence(ImmutableArray.Create<LocalSymbol>(temp), parts); 1073=> SwitchSection(ImmutableArray.Create(value), statements); 1076=> new(values, ImmutableArray.Create(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])); 206interfaces = ImmutableArray.Create<NamedTypeSymbol>(SubstituteNamedType(interfaces[0]), SubstituteNamedType(interfaces[1]));

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); }

68return ImmutableArray.Create<Symbol>(constructor, invokeMethod);

217=> ImmutableArray.Create<Symbol>(constructor, invokeMethod);

24_parameters = ImmutableArray.Create<ParameterSymbol>(

154ImmutableArray.Create(

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

87this.SpecialMembers = ImmutableArray.Create<MethodSymbol>( 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)));

114ImmutableArray.Create<TypedConstant>(lazyConstructorArguments)); 117ImmutableArray.Create<KeyValuePair<string, TypedConstant>>(lazyNamedArguments));

472ImmutableArray.Create( 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( 831var namedArguments = 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;

233return ImmutableArray.CreateRange<NamedTypeSymbol>(GetMembersUnordered().OfType<NamedTypeSymbol>()); 238return ImmutableArray.CreateRange<NamedTypeSymbol>(GetMembers().OfType<NamedTypeSymbol>()); 244return ImmutableArray.CreateRange<NamedTypeSymbol>(_cachedLookup[name].OfType<NamedTypeSymbol>());

852var builder = ImmutableArray.CreateBuilder<ParameterSymbol>(count); 945var ownedParams = ImmutableArray.CreateBuilder<TypeParameterSymbol>(gpHandles.Count);

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

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

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

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

387return ImmutableArray.Create(_elementNames, start, numberOfElements);

847return this.Construct(ImmutableArray.Create(typeArguments)); 1284ImmutableArray.Create( 1291ImmutableArray.Create(new TypedConstant(declaringCompilation.GetSpecialType(SpecialType.System_String), TypedConstantKind.Primitive, nameof(CompilerFeatureRequiredFeatures.RequiredMembers)))

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

86return ImmutableArray.Create(this);

100var involvedAssemblies = ImmutableArray.Create<Symbol>(ownerAssembly, dependentAssembly);

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);

220InitializeParameters(ImmutableArray.Create<ParameterSymbol>( 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);

52ImmutableArray.Create<TypedConstant>(item1, item2))); 221return ImmutableArray.Create<Symbol>(_constructor, _internalField); 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(

1718ImmutableArray.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);

412return OneOrMany.Create(ImmutableArray.Create(AttributeDeclarationSyntaxList, this.SourcePartialImplementation.AttributeDeclarationSyntaxList)); 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);

135ImmutableInterlocked.InterlockedInitialize(ref _lazyDescriptions, ImmutableArray.Create(description0, description1));

14Parameters = ImmutableArray.Create(

14Parameters = ImmutableArray.Create(

39_interfaces = ImmutableArray.Create(

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

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

30Parameters: ImmutableArray.Create<ParameterSymbol>(

24Parameters = ImmutableArray.Create(SynthesizedParameterSymbol.Create(

72Parameters: ImmutableArray.Create<ParameterSymbol>(

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;

20_parameters = ImmutableArray.Create<ParameterSymbol>(

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>( 46_constructors = ImmutableArray.Create<MethodSymbol>( 53m => ImmutableArray.Create(SynthesizedParameterSymbol.Create(m, boolArrayType, 0, RefKind.None)), 82ImmutableArray.Create<BoundExpression>(factory.Literal(true))

41_fields = ImmutableArray.Create<FieldSymbol>( 50_constructors = ImmutableArray.Create<MethodSymbol>( 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)),

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

56ImmutableArray.Create<BoundStatement>(

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

15this.SetTypeParameters(ImmutableArray.Create<TypeParameterSymbol>(new SynthesizedSimpleMethodTypeParameterSymbol(this, 0, "TBuffer"), new SynthesizedSimpleMethodTypeParameterSymbol(this, 1, "TElement"))); 17this.SetParameters(ImmutableArray.Create<ParameterSymbol>(SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(TypeParameters[0]), 0, RefKind.In, "buffer"),

15this.SetTypeParameters(ImmutableArray.Create<TypeParameterSymbol>(new SynthesizedSimpleMethodTypeParameterSymbol(this, 0, "TBuffer"), new SynthesizedSimpleMethodTypeParameterSymbol(this, 1, "TElement"))); 17this.SetParameters(ImmutableArray.Create<ParameterSymbol>(SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(TypeParameters[0]), 0, RefKind.Ref, "buffer"),

15this.SetTypeParameters(ImmutableArray.Create<TypeParameterSymbol>(new SynthesizedSimpleMethodTypeParameterSymbol(this, 0, "TBuffer"), new SynthesizedSimpleMethodTypeParameterSymbol(this, 1, "TElement"))); 17this.SetParameters(ImmutableArray.Create<ParameterSymbol>(SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(TypeParameters[0]), 0, RefKind.Ref, "buffer"),

15this.SetTypeParameters(ImmutableArray.Create<TypeParameterSymbol>(new SynthesizedSimpleMethodTypeParameterSymbol(this, 0, "TBuffer"), new SynthesizedSimpleMethodTypeParameterSymbol(this, 1, "TElement"))); 17this.SetParameters(ImmutableArray.Create<ParameterSymbol>(SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(TypeParameters[0]), 0, RefKind.In, "buffer"),

15this.SetTypeParameters(ImmutableArray.Create<TypeParameterSymbol>(new SynthesizedSimpleMethodTypeParameterSymbol(this, 0, "TBuffer"), new SynthesizedSimpleMethodTypeParameterSymbol(this, 1, "TElement"))); 17this.SetParameters(ImmutableArray.Create<ParameterSymbol>(SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(TypeParameters[0]), 0, RefKind.Ref, "buffer")));

15this.SetTypeParameters(ImmutableArray.Create<TypeParameterSymbol>(new SynthesizedSimpleMethodTypeParameterSymbol(this, 0, "TBuffer"), new SynthesizedSimpleMethodTypeParameterSymbol(this, 1, "TElement"))); 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)),

45_parameters = ImmutableArray.Create<ParameterSymbol>(new SynthesizedOperatorParameterSymbol(this, leftType, 0, "left"), 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); 239NamedTypeSymbol currentSymbol = firstTupleType.Construct(ImmutableArray.Create(elementTypes, (chainLength - 1) * (ValueTupleRestPosition - 1), remainder)); 243var chainedTypes = ImmutableArray.Create(elementTypes, (loop - 1) * (ValueTupleRestPosition - 1), ValueTupleRestPosition - 1).Add(TypeWithAnnotations.Create(currentSymbol)); 849return elementLocation == null ? ImmutableArray<Location>.Empty : ImmutableArray.Create(elementLocation);

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

216customModifiers: ImmutableArray.Create(t2.CustomModifiers, t1.CustomModifiers.Length, t2.CustomModifiers.Length - t1.CustomModifiers.Length))); 235customModifiers: ImmutableArray.Create(t1.CustomModifiers, t2.CustomModifiers.Length, t1.CustomModifiers.Length - t2.CustomModifiers.Length)));

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)

43public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(DiagnosticDescriptor, FieldDiagnosticDescriptor);

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

16ImmutableArray.Create(

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

229var allLocations = ImmutableArray.Create(

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

39Interlocked.CompareExchange(ref _spans, ImmutableArray.CreateBuilder<TextSpan>(), null);

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

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

29private const string CreateBuilderName = nameof(ImmutableArray.CreateBuilder); 52var locations = ImmutableArray.Create(invocationExpression.GetLocation()); 68var additionalUnnecessaryLocations = ImmutableArray.Create(

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

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

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

863const string CreateName = nameof(ImmutableArray.Create); 864const string CreateRangeName = nameof(ImmutableArray.CreateRange);

12ImmutableArray.Create(

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

133var additionalLocations = ImmutableArray.Create(

253var additionalLocations = ImmutableArray.Create(

147var additionalLocations = ImmutableArray.Create(

113var additionalLocations = ImmutableArray.Create(

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

18private static readonly ImmutableArray<IOption2>.Builder s_editorConfigOptionsBuilder = ImmutableArray.CreateBuilder<IOption2>();

17private static readonly ImmutableArray<IOption2>.Builder s_editorConfigOptionsBuilder = ImmutableArray.CreateBuilder<IOption2>();

70static t => (t.invocationOrCreation, ImmutableArray.Create<SyntaxNode>(t.identifier, t.declarator)),

291var deduplicatedUsingsBuilder = ImmutableArray.CreateBuilder<UsingDirectiveSyntax>();

69.SelectMany(t => ImmutableArray.Create(SyntaxFactory.Space, t, SyntaxFactory.ElasticCarriageReturnLineFeed))

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

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

37var builder = ImmutableArray.CreateBuilder<(DiagnosticDescriptor, ImmutableHashSet<IOption2>)>();

525AssertEx.Equal(ImmutableArray.Create<string>(), parser.KeyFileSearchPaths); 537AssertEx.Equal(ImmutableArray.Create<string>(), parser.KeyFileSearchPaths); 551AssertEx.Equal(ImmutableArray.Create<string>(), parser.KeyFileSearchPaths); 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))); 11516Assert.Equal(ImmutableArray.Create<KeyValuePair<string, string>>(), parsedArgs.PathMap); 11533Assert.Equal(ImmutableArray.Create<KeyValuePair<string, string>>(), parsedArgs.PathMap); 12040$"Could not load file or assembly '{typeof(ImmutableArray).Assembly.FullName}' or one of its dependencies. The system cannot find the file specified.", 14220var virtualSnProvider = new DesktopStrongNameProvider(ImmutableArray.Create(dir.Path)); 14899public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(_rule); 15944return ImmutableArray.Create(Hidden01, Hidden02); 15968return ImmutableArray.Create(Info01); 15995return ImmutableArray.Create(Warning01); 16014public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Warning02); 16037return ImmutableArray.Create(Error01, Error02);

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

52var spans = ImmutableArray.Create(new TextSpan(start, length)); 73var spans = ImmutableArray.Create(new TextSpan(start, length)); 140var spans = ImmutableArray.Create( 144var expected = ImmutableArray.Create(Keyword("class"),

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

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"); 322var selectedMembers = ImmutableArray.Create("TestMethodInt", "TestMethodBool"); 368var selectedMembers = ImmutableArray.Create("TestMethodBool"); 414var selectedMembers = ImmutableArray.Create( 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"); 983var selectedMembers = ImmutableArray.Create("TestProperty", "_testProperty"); 1040var selectedMembers = ImmutableArray.Create("TestMethod"); 1092var selectedMembers = ImmutableArray.Create("TestMethod"); 1150var selectedMembers = ImmutableArray.Create("TestMethod", "TestGeneric"); 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"); 2619var selectedMembers = ImmutableArray.Create("IsValidWorkflowType", "validWorkflowTypes"); 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"); 2891var selectedMembers = ImmutableArray.Create("Goo", "Foo"); 2922var selectedMembers = ImmutableArray.Create("Goo", "Foo", "DoSomething"); 2963var selectedMembers = ImmutableArray.Create("Goo", "Foo"); 3004var selectedMembers = ImmutableArray.Create("Goo", "Foo", "DoSomething"); 3045var selectedMembers = ImmutableArray.Create("Foo"); 3086var selectedMembers = ImmutableArray.Create("Goo");

2708var symbolSpecifications = ImmutableArray.Create( 2721var namingStyles = ImmutableArray.Create(

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

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

26var builder = ImmutableArray.CreateBuilder<string>();

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)));

924classificationTypeNames: ImmutableArray.Create(

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

35var fieldsBuilder = ImmutableArray.CreateBuilder<string>(MaxVariables);

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), 12627publicKeyOrToken: metadata.GetOrAddBlob(ImmutableArray.Create<byte>(0xB7, 0x7A, 0x5C, 0x56, 0x19, 0x34, 0xE0, 0x89)),

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

5855var tupleWithoutNames = comp.CreateTupleTypeSymbol(vt1, ImmutableArray.Create(new[] { (string)null })); 5873var tupleWithoutNames = comp.CreateTupleTypeSymbol(vt2, ImmutableArray.Create<string>(null, null)); 5913vt2, ImmutableArray.Create<string>("i1", "i2"), ImmutableArray.Create(loc1, loc2)); 5972var tupleWithNames = comp.CreateTupleTypeSymbol(vt2, ImmutableArray.Create("Alice", "Bob")); 5991var tupleWithSomeNames = comp.CreateTupleTypeSymbol(vt3, ImmutableArray.Create(null, "Item2", "Charlie")); 6009var tupleWithNames = comp.CreateTupleTypeSymbol(vt2, ImmutableArray.Create("Item2", "Item1")); 6083var tuple8WithNames = comp.CreateTupleTypeSymbol(vt8, ImmutableArray.Create("Alice1", "Alice2", "Alice3", "Alice4", "Alice5", "Alice6", "Alice7", "Alice8")); 6133var tuple9WithNames = comp.CreateTupleTypeSymbol(vt9, ImmutableArray.Create("Alice1", "Alice2", "Alice3", "Alice4", "Alice5", "Alice6", "Alice7", "Alice8", "Alice9")); 6165var tuple9WithNames = comp.CreateTupleTypeSymbol(vt9, ImmutableArray.Create("Item1", "Item2", "Item3", "Item4", "Item5", "Item6", "Item7", "Item8", "Item9")); 6275var tuple2 = comp.CreateTupleTypeSymbol(vt3, ImmutableArray.Create("123", " ", null)); 6279var tuple3 = comp.CreateTupleTypeSymbol(vt2, ImmutableArray.Create("return", "class")); 6296var e = Assert.Throws<ArgumentException>(() => comp.CreateTupleTypeSymbol(vt2, ImmutableArray.Create("123", ""))); 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))); 6367var tupleWithoutNames = comp.CreateTupleTypeSymbol(ImmutableArray.Create(intType, stringType), ImmutableArray.Create<string>(null, null)); 6390ImmutableArray.Create<TypeSymbol>(intType, stringType), 6391ImmutableArray.Create<string>(null, null), 6392ImmutableArray.Create(loc1, loc2)); 6415var tupleWithoutNames = comp.CreateTupleTypeSymbol(ImmutableArray.Create(intType, stringType), default(ImmutableArray<string>)); 6431var tupleWithNames = comp.CreateTupleTypeSymbol(ImmutableArray.Create(intType, stringType), ImmutableArray.Create("Alice", "Bob")); 6446var tupleWithNames = comp.CreateTupleTypeSymbol(ImmutableArray.Create(intType, intType), ImmutableArray.Create("Item2", "Item1")); 6462var tuple8WithoutNames = comp.CreateTupleTypeSymbol(ImmutableArray.Create(intType, stringType, intType, stringType, intType, stringType, intType, stringType), 6482var tuple8WithNames = comp.CreateTupleTypeSymbol(ImmutableArray.Create(intType, stringType, intType, stringType, intType, stringType, intType, stringType), 6483ImmutableArray.Create("Alice1", "Alice2", "Alice3", "Alice4", "Alice5", "Alice6", "Alice7", "Alice8")); 6502var tuple9WithoutNames = comp.CreateTupleTypeSymbol(ImmutableArray.Create(intType, stringType, intType, stringType, intType, stringType, intType, stringType, intType), 6523var tuple9WithNames = comp.CreateTupleTypeSymbol(ImmutableArray.Create(intType, stringType, intType, stringType, intType, stringType, intType, stringType, intType), 6524ImmutableArray.Create("Alice1", "Alice2", "Alice3", "Alice4", "Alice5", "Alice6", "Alice7", "Alice8", "Alice9")); 6545var tupleWithoutNames = comp.CreateTupleTypeSymbol(ImmutableArray.Create(intType, ErrorTypeSymbol.UnknownResultType), default(ImmutableArray<string>)); 6563var tuple2 = comp.CreateTupleTypeSymbol(ImmutableArray.Create(intType, intType), ImmutableArray.Create("123", " ")); 6567var tuple3 = comp.CreateTupleTypeSymbol(ImmutableArray.Create(intType, intType), ImmutableArray.Create("return", "class")); 6586Assert.Throws<ArgumentException>(() => comp.CreateTupleTypeSymbol(ImmutableArray.Create(intType, vbType), default(ImmutableArray<string>))); 6606var twoStringsWithNames = comp.CreateTupleTypeSymbol(twoStrings, ImmutableArray.Create("a", "b")); 6610var tuple3 = comp.CreateTupleTypeSymbol(ImmutableArray.Create<ITypeSymbol>(intType, intType, intType, intType, intType, intType, intType, stringType, stringType), 6611ImmutableArray.Create("Item1", "Item2", "Item3", "Item4", "Item5", "Item6", "Item7", "a", "b")); 6613var tuple4 = comp.CreateTupleTypeSymbol(tuple1, ImmutableArray.Create("Item1", "Item2", "Item3", "Item4", "Item5", "Item6", "Item7", "a", "b")); 6807elementNullableAnnotations: ImmutableArray.Create(CodeAnalysis.NullableAnnotation.None, CodeAnalysis.NullableAnnotation.None)); 6813elementNullableAnnotations: ImmutableArray.Create(CodeAnalysis.NullableAnnotation.NotAnnotated, CodeAnalysis.NullableAnnotation.Annotated)); 6820elementNullableAnnotations: ImmutableArray.Create(CodeAnalysis.NullableAnnotation.Annotated, CodeAnalysis.NullableAnnotation.None)); 6876elementNullableAnnotations: ImmutableArray.Create(CodeAnalysis.NullableAnnotation.None, CodeAnalysis.NullableAnnotation.None)); 6882elementNullableAnnotations: ImmutableArray.Create(CodeAnalysis.NullableAnnotation.NotAnnotated, CodeAnalysis.NullableAnnotation.Annotated)); 6889elementNullableAnnotations: ImmutableArray.Create(CodeAnalysis.NullableAnnotation.Annotated, CodeAnalysis.NullableAnnotation.None)); 6925ImmutableArray.CreateRange(Enumerable.Range(0, n).Select(_ => annotation)); 13595var t3 = NamedTypeSymbol.CreateTuple(m1Tuple, ImmutableArray.Create("a", "b")); 13596var t4 = NamedTypeSymbol.CreateTuple(m1Tuple, ImmutableArray.Create("a", "b")); 13597var t5 = NamedTypeSymbol.CreateTuple(m1Tuple, ImmutableArray.Create("b", "a")); 13612var t6 = NamedTypeSymbol.CreateTuple(m1Tuple, ImmutableArray.Create("Item1", "Item2")); 13613var t7 = NamedTypeSymbol.CreateTuple(m1Tuple, ImmutableArray.Create("Item1", "Item2")); 13623var t8 = NamedTypeSymbol.CreateTuple(m1Tuple, ImmutableArray.Create("Item2", "Item1")); 13645ImmutableArray.Create("a", "b", "c", "d", "e", "f", "g", "h", "i")); 13647ImmutableArray.Create("a", "b", "c", "d", "e", "f", "g", "h", "i")); 13649ImmutableArray.Create("a", "b", "c", "d", "e", "f", "g", "i", "h")); 13665ImmutableArray.Create("Item1", "Item2", "Item3", "Item4", "Item5", "Item6", "Item7", "Item8", "Item9")); 13667ImmutableArray.Create("Item1", "Item2", "Item3", "Item4", "Item5", "Item6", "Item7", "Item8", "Item9")); 13678ImmutableArray.Create("Item1", "Item2", "Item3", "Item4", "Item5", "Item6", "Item7", "Item9", "Item8")); 13691ImmutableArray.Create("a", "b", "c", "d", "e", "f", "g", "Item1", "Item2")); 13693ImmutableArray.Create("a", "b", "c", "d", "e", "f", "g", "Item1", "Item2")); 13701ImmutableArray.Create("a", "b")))) 13757ImmutableArray.Create("Item1", "Item2")))) 13759ImmutableArray.Create("Item1", "Item2", "Item3", "Item4", "Item5", "Item6", "Item7", "Item8", "Item9")); 13818ImmutableArray.Create("a", "b")))) 13820ImmutableArray.Create("Item1", "Item2", "Item3", "Item4", "Item5", "Item6", "Item7", "Item8", "item9")); 13834var t3 = NamedTypeSymbol.CreateTuple(m3Tuple, ImmutableArray.Create("a", "b", "c")); 13835var t4 = NamedTypeSymbol.CreateTuple(m3Tuple, ImmutableArray.Create("a", "b", "c")); 13836var t5 = NamedTypeSymbol.CreateTuple(m3Tuple, ImmutableArray.Create("c", "b", "a")); 13851var t6 = NamedTypeSymbol.CreateTuple(m3Tuple, ImmutableArray.Create("Item1", "Item2", "Item3")); 13852var t7 = NamedTypeSymbol.CreateTuple(m3Tuple, ImmutableArray.Create("Item1", "Item2", "Item3")); 13862var t8 = NamedTypeSymbol.CreateTuple(m3Tuple, ImmutableArray.Create("Item2", "Item3", "Item1")); 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")) }, 18846var int_string1 = comp.CreateTupleTypeSymbol(ImmutableArray.Create(intType, stringType)); 18847var int_string2 = comp.CreateTupleTypeSymbol(ImmutableArray.Create(intType, stringType)); 18848var int_stringNamed = comp.CreateTupleTypeSymbol(ImmutableArray.Create(intType, stringType), ImmutableArray.Create("a", "b")); 18865var int_string2 = comp.CreateTupleTypeSymbol(ImmutableArray.Create(intType, stringType)); 18866var int_stringNamed = comp.CreateTupleTypeSymbol(ImmutableArray.Create(intType, stringType), ImmutableArray.Create("a", "b")); 18884var int_int = comp.CreateTupleTypeSymbol(ImmutableArray.Create(intType, intType)); 18885var int_int_int = comp.CreateTupleTypeSymbol(ImmutableArray.Create(intType, intType, intType)); 18886var string_string = comp.CreateTupleTypeSymbol(ImmutableArray.Create(stringType, stringType)); 18908var int_string = comp.CreateTupleTypeSymbol(ImmutableArray.Create(intType, stringType)); 18909var int_object = comp.CreateTupleTypeSymbol(ImmutableArray.Create(intType, objectType)); 18925var int_string1 = comp.CreateTupleTypeSymbol(ImmutableArray.Create(intType, stringType)); 18926var int_object1 = comp.CreateTupleTypeSymbol(ImmutableArray.Create(intType, objectType)); 18951var int_string1 = tupleComp1.CreateTupleTypeSymbol(ImmutableArray.Create(intType, stringType)); 18952var int_string2 = tupleComp2.CreateTupleTypeSymbol(ImmutableArray.Create(intType, stringType)); 18954var int_object = tupleComp1.CreateTupleTypeSymbol(ImmutableArray.Create(intType, objectType)); 18976var int_string1 = tupleComp1.CreateTupleTypeSymbol(ImmutableArray.Create(intType, stringType)); 18977var int_string2 = tupleComp2.CreateTupleTypeSymbol(ImmutableArray.Create(intType, stringType)); 18978var int_object = tupleComp1.CreateTupleTypeSymbol(ImmutableArray.Create(intType, objectType)); 19001var int_string1 = tupleComp1.CreateTupleTypeSymbol(ImmutableArray.Create(intType, stringType)); 19002var int_string2 = tupleComp2.CreateTupleTypeSymbol(ImmutableArray.Create(intType, stringType)); 19003var int_object = tupleComp1.CreateTupleTypeSymbol(ImmutableArray.Create(intType, objectType)); 19027var int_string1 = tupleComp1.CreateTupleTypeSymbol(ImmutableArray.Create(intType, stringType)); 19028var int_string2 = tupleComp2.CreateTupleTypeSymbol(ImmutableArray.Create(intType, stringType)); 19029var int_object = tupleComp1.CreateTupleTypeSymbol(ImmutableArray.Create(intType, objectType)); 19069var int_string1 = tupleComp1.CreateTupleTypeSymbol(ImmutableArray.Create(intType, stringType)); 19070var int_object = tupleComp1.CreateTupleTypeSymbol(ImmutableArray.Create(intType, objectType)); 19071var int_object_object = tupleComp1.CreateTupleTypeSymbol(ImmutableArray.Create(intType, objectType, objectType)); 19108var int_string1 = tupleComp1.CreateTupleTypeSymbol(ImmutableArray.Create(intType, stringType)); 19109var int_object = tupleComp1.CreateTupleTypeSymbol(ImmutableArray.Create(intType, objectType)); 19110var int_object_object = tupleComp1.CreateTupleTypeSymbol(ImmutableArray.Create(intType, objectType, objectType)); 28995elementTypesWithAnnotations: ImmutableArray.Create(obliviousObject, obliviousObject, obliviousObject, obliviousObject, obliviousObject, obliviousObject, obliviousObject, obliviousObject, obliviousObject), 28996elementLocations: ImmutableArray.Create<Location>(null, null, null, null, null, null, null, null, null), 28997elementNames: ImmutableArray.Create("a", "b", "c", "d", "e", "f", "g", "h", "i"), 29001errorPositions: ImmutableArray.Create(true, true, true, true, true, true, true, true, true)); 29013elementTypesWithAnnotations: ImmutableArray.Create(nonNullableObject, nullableObject, nonNullableObject, nullableObject, nonNullableObject, nullableObject, nonNullableObject, nullableObject, nonNullableObject), 29014elementLocations: ImmutableArray.Create<Location>(null, null, null, null, null, null, null, null, null), 29019errorPositions: ImmutableArray.Create(true, true, true, true, true, true, true, true, true));

2665MetadataReaderUtils.AssertNotThrowNull(ImmutableArray.CreateRange(output.GetBuffer())); 2666MetadataReaderUtils.AssertEmptyOrThrowNull(ImmutableArray.CreateRange(metadataOutput.GetBuffer()));

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)));

362Assert.True(i1.Interfaces().SequenceEqual(ImmutableArray.Create<NamedTypeSymbol>(i2, i3, i4, i5, i6, i7))); 363Assert.True(i2.Interfaces().SequenceEqual(ImmutableArray.Create<NamedTypeSymbol>(i3, i4))); 366Assert.True(i5.Interfaces().SequenceEqual(ImmutableArray.Create<NamedTypeSymbol>(i6, i7))); 370Assert.True(c.Interfaces().SequenceEqual(ImmutableArray.Create<NamedTypeSymbol>(i1, i2, i3, i4, i5, i6, i7)));

86var il = ImmutableArray.Create(ilStream.ToArray()); 162var il = ImmutableArray.Create(ilStream.ToArray()); 236ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1))); 242ImmutableArray.Create( 341ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1))); 345ImmutableArray.Create( 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( 2731ImmutableArray.Create( 2742ImmutableArray.Create( 2754ImmutableArray.Create( 2803ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 2875ImmutableArray.Create( 2981ImmutableArray.Create( 3100ImmutableArray.Create( 3195ImmutableArray.Create( 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(

150ImmutableArray.Create( 270ImmutableArray.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)))); 7427ImmutableArray.Create( 7439ImmutableArray.Create( 7450ImmutableArray.Create( 7806ImmutableArray.Create( 7881ImmutableArray.Create( 8176ImmutableArray.Create( 8188ImmutableArray.Create( 8199ImmutableArray.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( 10767ImmutableArray.Create( 10835ImmutableArray.Create( 10888ImmutableArray.Create( 10952ImmutableArray.Create( 11018ImmutableArray.Create( 11069ImmutableArray.Create( 11120ImmutableArray.Create( 11174ImmutableArray.Create( 11235ImmutableArray.Create( 11290ImmutableArray.Create( 11357ImmutableArray.Create(

285ImmutableArray.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))); 3203ImmutableArray.Create( 3252ImmutableArray.Create( 3317ImmutableArray.Create( 3624ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Insert, null, f1))); 3658ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f1, f2))); 3767ImmutableArray.Create( 3857ImmutableArray.Create( 3954ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Insert, null, f3))); 4017ImmutableArray.Create( 4077ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, getP0, getP1))); 4146? ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Insert, null, r1), SemanticEdit.Create(SemanticEditKind.Insert, null, r1.GetMethod)) 4147: ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Insert, null, r1))); 4181? ImmutableArray.Create( 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( 6958ImmutableArray.Create( 7119ImmutableArray.Create( 7197ImmutableArray.Create( 7212ImmutableArray.Create( 7282ImmutableArray.Create( 7297ImmutableArray.Create( 7360ImmutableArray.Create( 7462ImmutableArray.Create( 7523ImmutableArray.Create( 7637ImmutableArray.Create( 7651ImmutableArray.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))); 7950ImmutableArray.Create( 7975ImmutableArray.Create( 8114ImmutableArray.Create( 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))); 10096ImmutableArray.Create( 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))); 13361ImmutableArray.Create( 13370ImmutableArray.Create( 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( 19649ImmutableArray.Create( 19743ImmutableArray.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);

33var options = EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.CreateRange(kinds)); 452edits: ImmutableArray.Create( 453new SemanticEdit(f0, f1, ImmutableArray.Create(InstrumentationKindExtensions.LocalStateTracing))));

26TestOptions.DebugDll.WithSourceReferenceResolver(new SourceFileResolver(ImmutableArray.Create<string>(), baseDirectory)));

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")), 793new CSharpCompilationReference(dummyCompilation, ImmutableArray.Create("A", "A")), 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")); 1030var refA1 = comp.EmitToImageReference(aliases: ImmutableArray.Create("A2", "A3")); 1040var refA4 = comp.EmitToImageReference(aliases: ImmutableArray.Create("A5")); 1123var refA1 = comp.EmitToImageReference(aliases: ImmutableArray.Create("A2", "A3")); 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")); 1415new CSharpCompilationReference(dummyCompilation1, ImmutableArray.Create("global", "A")), 1416new CSharpCompilationReference(dummyCompilation2, ImmutableArray.Create("B", "global")) 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")) 1718new CSharpCompilationReference(compilation1, ImmutableArray.Create("A", "B")) 1786new CSharpCompilationReference(compilation1, ImmutableArray.Create("global", "B", "A", "A", "global")) 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)));

1386AssertEx.Equal(ImmutableArray.Create(true, true, true, false, true, true), reader.ReadBoolArray(customAttribute.Value));

4222underlyingType.ApplyNullableTransforms(0, ImmutableArray.Create(expectedPreviously), ref position, out _); 4758AssertEx.Equal(ImmutableArray.Create<byte>(0, 0, 2, 0, 2, 0, 0, 0, 0, 2, 0, 2), reader.ReadByteArray(customAttribute.Value)); 4767AssertEx.Equal(ImmutableArray.Create<byte>(0, 2, 0, 2, 0, 2, 0, 2, 0, 0, 2), reader.ReadByteArray(customAttribute.Value)); 4902var expectedBits = ImmutableArray.Create<byte>(0, 2, 0, 1, 2, 1, 2, 1, 2, 1, 0, 2); 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\")), 773WithCryptoPublicKey(ImmutableArray.Create<byte>(1, 2, 3)).

45return ImmutableArray.Create(s_CA9999_UseOfVariableThatStartsWithX); 240return ImmutableArray.Create(s_descriptor); 478get { return ImmutableArray.Create(desc1, desc2, desc3); } 493get { return ImmutableArray.Create(desc1, desc2); } 507get { return ImmutableArray.Create(desc1); } 659public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get { return ImmutableArray.Create(Rule); } } 764get { return ImmutableArray.Create(Descriptor1, Descriptor2, Descriptor3, Descriptor4, Descriptor5, Descriptor6); } 801ImmutableArray.Create(SyntaxKind.EqualsValueClause)); 804ImmutableArray.Create(SyntaxKind.BaseConstructorInitializer)); 823}, ImmutableArray.Create(SyntaxKind.ArrowExpressionClause)); 834get { return ImmutableArray.Create(Descriptor1); } 885return ImmutableArray.Create(SupportedDescriptor); 1475var builder = ImmutableArray.CreateBuilder<SyntaxTree>(); 1646get { return ImmutableArray.Create(ExpressionDescriptor); } 2245var syntaxKinds = ImmutableArray.Create(SyntaxKind.VariableDeclaration); 2246var operationKinds = ImmutableArray.Create(OperationKind.VariableDeclarator); 2307public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Warning, Summary); 3266var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(new SymbolStartAnalyzer(topLevelAction: false, SymbolKind.NamedType)); 3312var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(new SymbolStartAnalyzer(topLevelAction: false, SymbolKind.NamedType)); 3350var compilationWithAnalyzers = compilation.WithAnalyzers(ImmutableArray.Create<DiagnosticAnalyzer>(analyzer1, analyzer2)); 3358var tree1SemanticDiagnostics = await compilationWithAnalyzers.GetAnalyzerSemanticDiagnosticsAsync(semanticModel1, filterSpan: null, ImmutableArray.Create<DiagnosticAnalyzer>(analyzer1), CancellationToken.None); 3687var allAnalyzers = ImmutableArray.Create<DiagnosticAnalyzer>(analyzer1, analyzer2); 3695var analyzersToQuery = singleAnalyzer ? ImmutableArray.Create<DiagnosticAnalyzer>(analyzer1) : allAnalyzers; 3754var allAnalyzers = ImmutableArray.Create<DiagnosticAnalyzer>(analyzer1, analyzer2); 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); 3924var additionalFiles = ImmutableArray.Create(additionalFile1, additionalFile2); 3930var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(analyzer1, analyzer2); 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); 1077public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor, DescriptorForBlockEnd); 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()); 1582analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(new CSharpCompilerDiagnosticAnalyzer(), suppressor); 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);