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

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

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

406builder = ImmutableArray.CreateBuilder<ResourceCommandSnapshot>(previousState.Commands.Length); 422builder = ImmutableArray.CreateBuilder<ResourceCommandSnapshot>(previousState.Commands.Length);

654var ports = ImmutableArray.CreateBuilder<int>(); 741var urls = ImmutableArray.CreateBuilder<UrlSnapshot>(); 829var environment = ImmutableArray.CreateBuilder<EnvironmentVariableSnapshot>(effectiveSource.Count);

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

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

139aliases: 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);

110var sourcesBuilder = ImmutableArray.CreateBuilder<(string hintName, SourceText sourceText)>();

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

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

60incrementalAnalyzerNames: ImmutableArray.Create(AnalyzerName));

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

37 var builder = ImmutableArray.CreateBuilder<MultiValue> (); 52 var argumentsBuilder = ImmutableArray.CreateBuilder<MultiValue> ();

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

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

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

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

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

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

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

144 case 1: return ImmutableArray.Create (span[0]); 145 case 2: return ImmutableArray.Create (span[0], span[1]); 146 case 3: return ImmutableArray.Create (span[0], span[1], span[2]); 147 case 4: return ImmutableArray.Create (span[0], span[1], span[2], span[3]); 149 var builder = ImmutableArray.CreateBuilder<T> (span.Length);

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

277 ImmutableArray<TValue>.Builder arguments = ImmutableArray.CreateBuilder<TValue> (); 302 var argumentsBuilder = ImmutableArray.CreateBuilder<TValue> (); 438 HandleMethodCallHelper (addMethod, instanceValue, ImmutableArray.Create (value), operation, state); 444 HandleMethodCallHelper (removeMethod, instanceValue, ImmutableArray.Create (value), operation, state); 614 ImmutableArray<TValue>.Builder arguments = ImmutableArray.CreateBuilder<TValue> (); 652 return HandleMethodCallHelper (getMethod, instanceValue, ImmutableArray.Create (indexArgumentValue), operation, state); 808 var argumentsBuilder = ImmutableArray.CreateBuilder<TValue> ();

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

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

28 ImmutableArray.Create (s_requiresDynamicCodeRule, s_requiresDynamicCodeAttributeMismatch, s_requiresDynamicCodeOnStaticCtor, s_requiresDynamicCodeOnEntryPoint);

49 ImmutableArray.Create (s_makeGenericMethodRule, s_makeGenericTypeRule, s_requiresUnreferencedCodeRule, s_requiresUnreferencedCodeAttributeMismatch, s_typeDerivesFromRucClassRule, s_requiresUnreferencedCodeOnStaticCtor, s_requiresUnreferencedCodeOnEntryPoint); 98 ImmutableArray.Create<(Action<SymbolAnalysisContext> Action, SymbolKind[] SymbolKind)> ((typeDerivesFromRucBase, new SymbolKind[] { SymbolKind.NamedType }));

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

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

37 var builder = ImmutableArray.CreateBuilder<MultiValue> (); 58 var argumentsBuilder = ImmutableArray.CreateBuilder<MultiValue> ();

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

129return ImmutableArray.Create(text.Split(new[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries));

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[]

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

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

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

38var 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(

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

120var imArray = ImmutableArray.CreateBuilder<(int, int)>(numberRangePairs is null ? 0 : numberRangePairs.Count);

484public readonly ImmutableArray<ProjectMetadataElement>.Builder Metadata = ImmutableArray.CreateBuilder<ProjectMetadataElement>();

76itemsToAdd ??= ImmutableArray.CreateBuilder<I>(); 88itemsToAdd ??= ImmutableArray.CreateBuilder<I>(); 131itemsToAdd ??= ImmutableArray.CreateBuilder<I>();

40: this(ImmutableArray.Create(globs)) 49: this(ImmutableArray.Create(glob1, glob2)) 127var builder = ImmutableArray.CreateBuilder<IMSBuildGlob>();

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

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

64_sortedCaseLabels = ImmutableArray.Create(caseLabels);

79return ImmutableArray.Create(map(items[0])); 82return ImmutableArray.Create(map(items[0]), map(items[1])); 85return ImmutableArray.Create(map(items[0]), map(items[1]), map(items[2])); 88return ImmutableArray.Create(map(items[0]), map(items[1]), map(items[2]), map(items[3])); 119return ImmutableArray.Create(map(items[0], arg)); 122return ImmutableArray.Create(map(items[0], arg), map(items[1], arg)); 125return ImmutableArray.Create(map(items[0], arg), map(items[1], arg), map(items[2], arg)); 128return ImmutableArray.Create(map(items[0], arg), map(items[1], arg), map(items[2], arg), map(items[3], arg)); 159return ImmutableArray.Create(map(items[0], 0, arg)); 162return ImmutableArray.Create(map(items[0], 0, arg), map(items[1], 1, arg)); 165return ImmutableArray.Create(map(items[0], 0, arg), map(items[1], 1, arg), map(items[2], 2, arg)); 168return ImmutableArray.Create(map(items[0], 0, arg), map(items[1], 1, arg), map(items[2], 2, arg), map(items[3], 3, arg));

41return ImmutableArray.CreateRange<T>(items); 58return ImmutableArray.CreateRange<T>(items); 75return ImmutableArray.CreateRange<T>(items); 87return ImmutableArray.Create<T>(items); 104return ImmutableArray.Create<T>(items); 120return ImmutableArray.Create<T>(items); 130return ImmutableArray.Create<byte>(stream.ToArray()); 143return ImmutableArray.CreateRange(items, map); 158return ImmutableArray.CreateRange(items, map, arg); 179return ImmutableArray.Create(map(items[0], 0, arg)); 182return ImmutableArray.Create(map(items[0], 0, arg), map(items[1], 1, arg)); 185return ImmutableArray.Create(map(items[0], 0, arg), map(items[1], 1, arg), map(items[2], 2, arg)); 188return ImmutableArray.Create(map(items[0], 0, arg), map(items[1], 1, arg), map(items[2], 2, arg), map(items[3], 3, arg)); 494return ImmutableArray.Create(map(self[0], other[0])); 497return ImmutableArray.Create(map(self[0], other[0]), map(self[1], other[1])); 500return ImmutableArray.Create(map(self[0], other[0]), map(self[1], other[1]), map(self[2], other[2])); 503return ImmutableArray.Create(map(self[0], other[0]), map(self[1], other[1]), map(self[2], other[2]), map(self[3], other[3])); 1202? ImmutableArray.Create(symbol) 1203: ImmutableArray<TNamespaceOrTypeSymbol>.CastUp(ImmutableArray.Create((TNamedTypeSymbol)symbol));

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

3101 => ImmutableArray.Create(_item0), 3112 => ImmutableArray.Create(_item0, _item1), 3123 => ImmutableArray.Create(_item0, _item1, _item2), 3134 => ImmutableArray.Create(_item0, _item1, _item2, _item3),

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

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

480var analyzerBuilder = ImmutableArray.CreateBuilder<DiagnosticAnalyzer>(); 481var 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 });

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

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

359analyzerDiagnostics = ImmutableArray.CreateBuilder<Diagnostic>(); 379currentDiagnostics = ImmutableArray.CreateBuilder<Diagnostic>(); 413var builder = ImmutableArray.CreateBuilder<Diagnostic>();

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

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

300return ImmutableArray.Create(LanguageNames.CSharp); 405var builder = ImmutableArray.CreateBuilder<TExtension>(); 446var builder = ImmutableArray.CreateBuilder<TExtension>();

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

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

553parameters = delegateInvokeMethod?.Parameters ?? ImmutableArray.Create<IParameterSymbol>(); 576ImmutableArray.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);

167return ImmutableArray.Create(sizes); 222tableEntriesAdded: ImmutableArray.Create(tableSizes),

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

70return ImmutableArray.Create<T>(); 78return ImmutableArray.CreateRange<T>(items); 98return ImmutableArray.CreateRange(items);

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

22numerals = 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));

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

187return ImmutableArray.Create(hash); 439var builder = ImmutableArray.CreateBuilder<EmbeddedResource>(); 1088private static readonly ImmutableArray<bool> s_simpleTransformFlags = ImmutableArray.Create(true); 1453return (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,

89ImmutableArray.Create(

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

436return 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;

192var inputs = ImmutableArray.Create((entry.Step!, entry.OutputIndex)); 569private static readonly ImmutableArray<EntryState> s_allAddedEntries = ImmutableArray.Create(EntryState.Added); 570private static readonly ImmutableArray<EntryState> s_allCachedEntries = ImmutableArray.Create(EntryState.Cached); 571private static readonly ImmutableArray<EntryState> s_allModifiedEntries = ImmutableArray.Create(EntryState.Modified); 576private static readonly ImmutableArray<EntryState> s_allRemovedEntries = ImmutableArray.Create(EntryState.Removed); 581private static readonly ImmutableArray<EntryState> s_allRemovedDueToInputRemoval = ImmutableArray.Create(EntryState.Removed);

18public static readonly InputNode<Compilation> Compilation = new InputNode<Compilation>(b => ImmutableArray.Create(b.Compilation)); 20public static readonly InputNode<CompilationOptions> CompilationOptions = new(b => ImmutableArray.Create(b.Compilation.Options), ReferenceEqualityComparer.Instance); 22public static readonly InputNode<ParseOptions> ParseOptions = new InputNode<ParseOptions>(b => ImmutableArray.Create(b.DriverState.ParseOptions)); 28public 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);

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

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

60_builder = ImmutableArray.CreateBuilder<T>(size); 523dictionary1.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));

688return ImmutableArray.Create(algorithm.ComputeHash(buffer, offset, count)); 701return ImmutableArray.Create(algorithm.ComputeHash(stream)); 890return ImmutableArray.Create(new TextChangeRange(new TextSpan(0, oldText.Length), this.Length));

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

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

112additionalLocations: ImmutableArray.Create(nextToken.GetLocation()),

82additionalLocations: ImmutableArray.Create(token.GetLocation()),

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

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

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

649var additionalLocations = ImmutableArray.Create(

119var locations = ImmutableArray.Create(

123var locations = ImmutableArray.Create(

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

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

163additionalLocations: ImmutableArray.Create(assignment.GetLocation()), 183additionalLocations: ImmutableArray.Create(assignment.GetLocation()), 196additionalLocations: ImmutableArray.Create(assignment.GetLocation()),

60additionalLocations: ImmutableArray.Create(ifStatement.GetLocation()),

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

190var locations = ImmutableArray.Create(

99ImmutableArray.Create(

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

129var allLocations = ImmutableArray.Create(

79return ImmutableArray.Create(map(items[0])); 82return ImmutableArray.Create(map(items[0]), map(items[1])); 85return ImmutableArray.Create(map(items[0]), map(items[1]), map(items[2])); 88return ImmutableArray.Create(map(items[0]), map(items[1]), map(items[2]), map(items[3])); 119return ImmutableArray.Create(map(items[0], arg)); 122return ImmutableArray.Create(map(items[0], arg), map(items[1], arg)); 125return ImmutableArray.Create(map(items[0], arg), map(items[1], arg), map(items[2], arg)); 128return ImmutableArray.Create(map(items[0], arg), map(items[1], arg), map(items[2], arg), map(items[3], arg)); 159return ImmutableArray.Create(map(items[0], 0, arg)); 162return ImmutableArray.Create(map(items[0], 0, arg), map(items[1], 1, arg)); 165return ImmutableArray.Create(map(items[0], 0, arg), map(items[1], 1, arg), map(items[2], 2, arg)); 168return ImmutableArray.Create(map(items[0], 0, arg), map(items[1], 1, arg), map(items[2], 2, arg), map(items[3], 3, arg));

41return ImmutableArray.CreateRange<T>(items); 58return ImmutableArray.CreateRange<T>(items); 75return ImmutableArray.CreateRange<T>(items); 87return ImmutableArray.Create<T>(items); 104return ImmutableArray.Create<T>(items); 120return ImmutableArray.Create<T>(items); 130return ImmutableArray.Create<byte>(stream.ToArray()); 143return ImmutableArray.CreateRange(items, map); 158return ImmutableArray.CreateRange(items, map, arg); 179return ImmutableArray.Create(map(items[0], 0, arg)); 182return ImmutableArray.Create(map(items[0], 0, arg), map(items[1], 1, arg)); 185return ImmutableArray.Create(map(items[0], 0, arg), map(items[1], 1, arg), map(items[2], 2, arg)); 188return ImmutableArray.Create(map(items[0], 0, arg), map(items[1], 1, arg), map(items[2], 2, arg), map(items[3], 3, arg)); 494return ImmutableArray.Create(map(self[0], other[0])); 497return ImmutableArray.Create(map(self[0], other[0]), map(self[1], other[1])); 500return ImmutableArray.Create(map(self[0], other[0]), map(self[1], other[1]), map(self[2], other[2])); 503return ImmutableArray.Create(map(self[0], other[0]), map(self[1], other[1]), map(self[2], other[2]), map(self[3], other[3])); 1202? ImmutableArray.Create(symbol) 1203: ImmutableArray<TNamespaceOrTypeSymbol>.CastUp(ImmutableArray.Create((TNamedTypeSymbol)symbol));

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

3101 => ImmutableArray.Create(_item0), 3112 => ImmutableArray.Create(_item0, _item1), 3123 => ImmutableArray.Create(_item0, _item1, _item2), 3134 => ImmutableArray.Create(_item0, _item1, _item2, _item3),

70return ImmutableArray.Create<T>(); 78return ImmutableArray.CreateRange<T>(items); 98return ImmutableArray.CreateRange(items);

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

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

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

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

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

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

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

27return ImmutableArray.Create(info.Symbol);

180return ImmutableArray.CreateRange(leadingTrivia.Take(index));

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

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

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

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

61var kinds = ImmutableArray.Create(new SymbolKindOrTypeKind(MethodKind.Ordinary)); 62var modifiers = ImmutableArray.Create(new ModifierKind(ModifierKindEnum.IsAsync)); 71var kinds = ImmutableArray.Create(new SymbolKindOrTypeKind(SymbolKind.Field), new SymbolKindOrTypeKind(SymbolKind.Parameter), new SymbolKindOrTypeKind(SymbolKind.Local)); 80var kinds = ImmutableArray.Create(new SymbolKindOrTypeKind(MethodKind.Ordinary)); 81var modifiers = ImmutableArray.Create(new ModifierKind(ModifierKindEnum.IsAsync)); 90var kinds = ImmutableArray.Create(new SymbolKindOrTypeKind(MethodKind.Ordinary));

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

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

90return ImmutableArray.CreateRange(_constructedFrom.TypeMembers.Cast<INamedTypeSymbol>());

37parameters: ImmutableArray.Create(fromType),

148return ImmutableArray.CreateRange(_typeParameters); 158return ImmutableArray.CreateRange(_interfaces); 163=> ImmutableArray.CreateRange(_members.Concat(this.TypeMembers)); 166=> ImmutableArray.CreateRange(this.TypeMembers.Cast<INamedTypeSymbol>()); 173return ImmutableArray.CreateRange( 183return ImmutableArray.CreateRange(

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

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

55var formattingRules = ImmutableArray.Create(

105=> SymbolKindsArePascalCase(ImmutableArray.Create(ToSymbolKindOrTypeKind(symbolOrTypeKind))); 133ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(TypeKind.Class)), 151ImmutableArray.Create(symbolSpecification), 152ImmutableArray.Create(namingStyle), 153ImmutableArray.Create(namingRule)); 163ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Field)), 183ImmutableArray.Create(symbolSpecification), 184ImmutableArray.Create(namingStyle), 185ImmutableArray.Create(namingRule)); 195ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Field)), 215ImmutableArray.Create(symbolSpecification), 216ImmutableArray.Create(namingStyle), 217ImmutableArray.Create(namingRule)); 227ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Field)), 247ImmutableArray.Create(symbolSpecification), 248ImmutableArray.Create(namingStyle), 249ImmutableArray.Create(namingRule)); 259ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Field)), 279ImmutableArray.Create(symbolSpecification), 280ImmutableArray.Create(namingStyle), 281ImmutableArray.Create(namingRule)); 297ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(MethodKind.Ordinary)), 316ImmutableArray.Create(symbolSpecification), 317ImmutableArray.Create(namingStyle), 318ImmutableArray.Create(namingRule)); 328ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(MethodKind.Ordinary)), 347ImmutableArray.Create(symbolSpecification), 348ImmutableArray.Create(namingStyle), 349ImmutableArray.Create(namingRule)); 378ImmutableArray.Create(symbolSpecification), 379ImmutableArray.Create(namingStyle), 380ImmutableArray.Create(namingRule)); 409ImmutableArray.Create(symbolSpecification), 410ImmutableArray.Create(namingStyle), 411ImmutableArray.Create(namingRule)); 421ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Parameter)), 441ImmutableArray.Create(symbolSpecification), 442ImmutableArray.Create(namingStyle), 443ImmutableArray.Create(namingRule)); 453ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Parameter)), 473ImmutableArray.Create(symbolSpecification), 474ImmutableArray.Create(namingStyle), 475ImmutableArray.Create(namingRule)); 485ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Parameter)), 505ImmutableArray.Create(symbolSpecification), 506ImmutableArray.Create(namingStyle), 507ImmutableArray.Create(namingRule)); 517ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Local)), 537ImmutableArray.Create(symbolSpecification), 538ImmutableArray.Create(namingStyle), 539ImmutableArray.Create(namingRule)); 549ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(MethodKind.LocalFunction)), 569ImmutableArray.Create(symbolSpecification), 570ImmutableArray.Create(namingStyle), 571ImmutableArray.Create(namingRule)); 581ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Property)), 601ImmutableArray.Create(symbolSpecification), 602ImmutableArray.Create(namingStyle), 603ImmutableArray.Create(namingRule)); 613ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(TypeKind.Interface)), 633ImmutableArray.Create(symbolSpecification), 634ImmutableArray.Create(namingStyle), 635ImmutableArray.Create(namingRule)); 645ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.TypeParameter)), 665ImmutableArray.Create(symbolSpecification), 666ImmutableArray.Create(namingStyle), 667ImmutableArray.Create(namingRule)); 677ImmutableArray.Create( 681ImmutableArray.Create(new SymbolSpecification.ModifierKind(SymbolSpecification.ModifierKindEnum.IsConst))); 699ImmutableArray.Create(symbolSpecification), 700ImmutableArray.Create(namingStyle), 701ImmutableArray.Create(namingRule)); 711ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Local)), 718ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Local)), 720ImmutableArray.Create(new SymbolSpecification.ModifierKind(SymbolSpecification.ModifierKindEnum.IsConst))); 753ImmutableArray.Create(localsSymbolSpecification, constLocalsSymbolSpecification), 754ImmutableArray.Create(camelCaseNamingStyle, allUpperNamingStyle), 755ImmutableArray.Create(constLocalsUpperCaseNamingRule, localsCamelCaseNamingRule)); 765ImmutableArray.Create( 769ImmutableArray.Create(new SymbolSpecification.ModifierKind(SymbolSpecification.ModifierKindEnum.IsAsync))); 787ImmutableArray.Create(symbolSpecification), 788ImmutableArray.Create(namingStyle), 789ImmutableArray.Create(namingRule));

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

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[]

880return new BoundBlock(statement.Syntax, locals, ImmutableArray.Create(statement)) 897ImmutableArray.Create(statement))

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

630(object)otherSymbol == null ? ImmutableArray<Symbol>.Empty : ImmutableArray.Create(otherSymbol), 631receiver == null ? ImmutableArray<BoundExpression>.Empty : ImmutableArray.Create(receiver), 893getItemOrSliceHelper = getItemOrSliceHelper.AsMember(getItemOrSliceHelper.ContainingType.Construct(ImmutableArray.Create(elementAccess.Expression.Type.TryGetInlineArrayElementField().TypeWithAnnotations))); 5481ImmutableArray.Create<ParameterSymbol>(new SignatureOnlyParameterSymbol( 5495arguments = ImmutableArray.Create(elementAccess.Expression); 5496refKinds = ImmutableArray.Create(parameterRefKind); 5521ImmutableArray.Create<ParameterSymbol>(new SignatureOnlyParameterSymbol( 5535arguments = ImmutableArray.Create(inlineArray); 5536refKinds = 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), 1512ImmutableArray.Create<BoundExpression>(methodGroup.ReceiverOpt, new BoundValuePlaceholder(syntax, secondArgumentType) { WasCompilerGenerated = true }), 2471ImmutableArray.Create(tupleSyntax.Location));

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

164ImmutableArray.Create(BindToTypeForErrorRecovery(childNode)), 220ImmutableArray.Create(BindToTypeForErrorRecovery(expr)), 854node, LookupResultKind.Empty, ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundExpression>(BindToTypeForErrorRecovery(BindValue(node.Expression, BindingDiagnosticBag.Discarded, BindValueKind.RefersToLocation))), 1006ImmutableArray.Create(BindValue(arguments[0].Expression, diagnostics, BindValueKind.RValue)) : 1042ImmutableArray.Create<BoundExpression>(boundArgument), CreateErrorType("void")); 1643symbols: ImmutableArray.Create(symbol), 1644childBoundNodes: ImmutableArray.Create(BindToTypeForErrorRecovery(expression)), 4185ImmutableArray.Create(boundExpression.ExpressionSymbol), 4186ImmutableArray.Create(boundExpression)); 4562typeArguments: ImmutableArray.Create(elementTypeWithAnnotations), 5409return new BoundBadExpression(node, LookupResultKind.NotInvocable, StaticCast<Symbol>.From(type.InstanceConstructors), ImmutableArray.Create(argument), type); 5419argument.Syntax, default, WellKnownMemberNames.DelegateInvokeName, ImmutableArray.Create(sourceDelegate.DelegateInvokeMethod), 5553return new BoundBadExpression(node, LookupResultKind.NotCreatable, ImmutableArray.Create<Symbol?>(type), children.ToImmutableAndFree(), type) { WasCompilerGenerated = wasCompilerGenerated }; 6309ImmutableArray.Create(boundElementInitializer), 6537ImmutableArray.Create((BoundExpression)addElementPlaceholder), 7777return new BoundBadExpression(node, LookupResultKind.Ambiguous, lookupResult.Symbols.AsImmutable(), ImmutableArray.Create(boundLeft), CreateErrorType(rightName), hasErrors: true); 7814return new BoundBadExpression(node, lookupResult.Kind, symbols.AsImmutable(), ImmutableArray.Create(boundLeft), CreateErrorType(rightName), hasErrors: true); 8160(object)symbolOpt == null ? ImmutableArray<Symbol>.Empty : ImmutableArray.Create(symbolOpt), 8161boundLeft == null ? ImmutableArray<BoundExpression>.Empty : ImmutableArray.Create(BindToTypeForErrorRecovery(boundLeft)), 9197Construct(ImmutableArray.Create(elementField.TypeWithAnnotations)); 9373var argumentPlaceholders = ImmutableArray.Create(new BoundImplicitIndexerValuePlaceholder(convertedArguments[0].Syntax, int32) { WasCompilerGenerated = true }); 10040argumentPlaceholders = ImmutableArray.Create(intPlaceholder); 10112argumentPlaceholders = ImmutableArray.Create(startArgumentPlaceholder, lengthArgumentPlaceholder); 10119syntax, typeArgumentsOpt: default, method.Name, ImmutableArray.Create(method), 10399methods = ImmutableArray.Create(method);

584ImmutableArray.Create(unconvertedInterpolatedString.Parts),

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

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

263result = MakeQueryInvocation(state.selectOrGroup, e, "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); 430ImmutableArray.Create(inExpression, outerKeySelectorLambda, innerKeySelectorLambda, resultSelectorLambda), 452var resultSelectorLambda = MakeQueryUnboundLambda(state.RangeVariableMap(), ImmutableArray.Create(x1, g), select.Expression, diagnostics.AccumulatesDependencies); 458ImmutableArray.Create(inExpression, outerKeySelectorLambda, innerKeySelectorLambda, resultSelectorLambda), 498ImmutableArray.Create(inExpression, outerKeySelectorLambda, innerKeySelectorLambda, resultSelectorLambda), 528ImmutableArray.Create(inExpression, outerKeySelectorLambda, innerKeySelectorLambda, resultSelectorLambda), 609var resultSelectorLambda = MakeQueryUnboundLambda(state.RangeVariableMap(), ImmutableArray.Create(x1, x2), select.Expression, diagnostics.AccumulatesDependencies); 615ImmutableArray.Create(collectionSelectorLambda, resultSelectorLambda), 662ImmutableArray.Create(collectionSelectorLambda, resultSelectorLambda), 699var result = MakeQueryUnboundLambda(state.RangeVariableMap(), ImmutableArray.Create(x1, x2), node, bodyFactory, withDependencies); 736yExpression = new BoundBadExpression(yExpression.Syntax, LookupResultKind.Empty, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create(yExpression), CreateErrorType()); 742yExpression = new BoundBadExpression(yExpression.Syntax, LookupResultKind.Empty, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create(yExpression), yExpression.Type); 752var lambda = MakeQueryUnboundLambda(state.RangeVariableMap(), ImmutableArray.Create(x), let.Expression, bodyFactory, diagnostics.AccumulatesDependencies); 803field2Value = new BoundBadExpression(field2Value.Syntax, LookupResultKind.Empty, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create(field2Value), field2Value.Type, true); 807ImmutableArray.Create( 815return MakeConstruction(node, anonymousType, ImmutableArray.Create(field1Value, field2Value), diagnostics); 828return MakeQueryUnboundLambda(qvm, ImmutableArray.Create(parameter), expression, withDependencies); 844return MakeQueryUnboundLambda(expression, new QueryUnboundLambdaState(this, qvm, ImmutableArray.Create(parameter), (LambdaSymbol lambdaSymbol, Binder lambdaBodyBinder, BindingDiagnosticBag diagnostics) => 880return MakeQueryInvocation(node, receiver, methodName, default(SeparatedSyntaxList<TypeSyntax>), default(ImmutableArray<TypeWithAnnotations>), ImmutableArray.Create(arg), diagnostics 906return MakeQueryInvocation(node, receiver, methodName, new SeparatedSyntaxList<TypeSyntax>(new SyntaxNodeOrTokenList(typeArgSyntax, 0)), ImmutableArray.Create(typeArg), ImmutableArray<BoundExpression>.Empty, diagnostics 975receiver = new BoundBadExpression(receiver.Syntax, LookupResultKind.NotAValue, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create(receiver), CreateErrorType()); 997receiver = 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); 3532return new BoundBlock(node, locals, ImmutableArray.Create(statement)) { WasCompilerGenerated = node.Kind() != SyntaxKind.ArrowExpressionClause }; 4004arguments: ImmutableArray.Create(argument),

1309ImmutableArray.Create<Symbol>(lookupResultSymbol), 1469receiver = 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); 726ImmutableArray.Create(collectionExpr), 843spanType = 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)); 2275return new Conversion(ConversionKind.ImplicitNullable, ImmutableArray.Create(tupleConversion)); 2472return new Conversion(ConversionKind.ExplicitNullable, ImmutableArray.Create(tupleConversion));

4503return 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) 662return 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);

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

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

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

298crefSymbols = ImmutableArray.Create<Symbol>(binder.BindType(expression, BindingDiagnosticBag.Discarded).Type); 5183? ImmutableArray.Create<ISymbol>(namedType) 5184: ImmutableArray.Create<ISymbol>(namedType, primaryConstructor.GetPublicSymbol()); 5189? ImmutableArray.Create(symbol)

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

1478return new BoundBadStatement(body.Syntax, ImmutableArray.Create<BoundNode>(body), hasErrors: true); 1860body = new BoundBlock(constructor.Syntax, constructor.Locals, ImmutableArray.Create<BoundStatement>(constructor.Initializer)); 1864body = new BoundBlock(constructor.Syntax, constructor.Locals, ImmutableArray.Create<BoundStatement>(constructor.Initializer, body)); 1955statements = ImmutableArray.Create(constructorInitializer); 1959statements = ImmutableArray.Create(constructorInitializer, body);

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

354children: ImmutableArray.Create(decl), 518children = ImmutableArray.Create<SingleNamespaceOrTypeDeclaration>(ns);

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

189return ImmutableArray.Create(result);

259return ImmutableArray.CreateRange(PreviousGeneration.SynthesizedTypes.AnonymousTypes.Keys); 264return ImmutableArray.CreateRange(PreviousGeneration.SynthesizedTypes.AnonymousDelegates.Keys);

1583ImmutableArray.Create(new TypedConstant(byteArrayType, value))); 1602ImmutableArray.Create(new TypedConstant(byteType, TypedConstantKind.Primitive, nullableValue))); 1622ImmutableArray.Create(new TypedConstant(Compilation.GetSpecialType(SpecialType.System_Byte), TypedConstantKind.Primitive, value))); 1666var arguments = ImmutableArray.Create(new TypedConstant(boolArray, transformFlags));

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

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

139ImmutableArray.Create<TypedConstant>(constructorArguments[0], constructorArguments[0]), 148ImmutableArray.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()));

269private static readonly ImmutableArray<BoundKind> s_skippedExpressions = ImmutableArray.Create(BoundKind.ArrayInitialization, 4734return namedType.OriginalDefinition.Construct(ImmutableArray.Create(elementType)); 4889type = TypeWithAnnotations.Create(((NamedTypeSymbol)node.Type).OriginalDefinition.Construct(ImmutableArray.Create(type))); 6427var constructedType = wellKnownType.Construct(ImmutableArray.Create(parameterType)); 9605return compilation.GetSpecialType(SpecialType.System_Nullable_T).Construct(ImmutableArray.Create(underlying)); 11062getEnumeratorType = spanType.Construct(ImmutableArray.Create(convertedResult.Type!.TryGetInlineArrayElementField()!.TypeWithAnnotations));

210ImmutableArray.CreateRange(_variableSlot),

199ImmutableArray.Create(catchAll), 414ImmutableArray.Create<LocalSymbol>(obj), 442ImmutableArray.Create(ex), 499ImmutableArray.Create<LocalSymbol>( 582ImmutableArray.Create(catchTemp), 628ImmutableArray.Create(catchTemp),

235ImmutableArray.Create(exceptionLocal), 260? ImmutableArray.Create<BoundExpression>(F.Local(_exprRetValue)) 577ImmutableArray.Create(notifyCompletionTemp), 643ImmutableArray.Create(thisTemp), 644ImmutableArray.Create<BoundExpression>(F.AssignmentExpression(F.Local(thisTemp), F.This())), 653return (secondOpt == null) ? ImmutableArray.Create(first) : ImmutableArray.Create(first, secondOpt);

354ImmutableArray.Create(instSymbol, versionSymbol), 397ImmutableArray.Create<BoundExpression>(instLocal))); 459ImmutableArray.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));

662var frameTypeParameters = ImmutableArray.Create(_currentTypeParameters.SelectAsArray(t => TypeWithAnnotations.Create(t)), 0, frame.Arity); 1025var realTypeArguments = ImmutableArray.Create(_currentTypeParameters.SelectAsArray(t => TypeWithAnnotations.Create(t)), 0, totalTypeArgumentCount - originalMethod.Arity); 1033var containerTypeArguments = ImmutableArray.Create(realTypeArguments, 0, containerAsFrame.Arity); 1034realTypeArguments = ImmutableArray.Create(realTypeArguments, containerAsFrame.Arity, realTypeArguments.Length - containerAsFrame.Arity); 1124sideEffects: ImmutableArray.Create<BoundExpression>(rewritten), 1248ImmutableArray.Create<LocalSymbol>(), 1731return 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);

110typeArguments = 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)),

445return ImmutableArray.Create(_factory.Sequence(new[] { value }, refAssignmentSourceIndex), index); 459return ImmutableArray.Create(addressOf, _factory.Sizeof(targetType), index); 479return ImmutableArray.Create(toString, index); 482return ImmutableArray.Create(_factory.Convert(parameter.Type, value), index); 539ImmutableArray.Create<BoundStatement>(logCallStatement, rewrittenFilterPrologue) : 540ImmutableArray.Create<BoundStatement>(logCallStatement)); 603return _factory.Sequence(ImmutableArray.Create(temp.LocalSymbol), builder.ToImmutableAndFree(), temp);

27_parameters = ImmutableArray.Create<ParameterSymbol>(

113ImmutableArray.Create(cachedState) : 114ImmutableArray.Create(cachedState, cachedThis), 177ImmutableArray.Create<LocalSymbol>(stateLocal), 205ImmutableArray.Create<LocalSymbol>(_methodValue), 411ImmutableArray.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),

345ImmutableArray.Create(setterCall),

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

107locals: ImmutableArray.Create(boundTemp.LocalSymbol), 108sideEffects: ImmutableArray.Create<BoundExpression>(tempAssignment), 705return _factory.Sequence(ImmutableArray.Create(temp.LocalSymbol), ImmutableArray.Create<BoundExpression>(tempAssignment), result); 853sideEffects: ImmutableArray.Create<BoundExpression>(nonNull), 1098locals: ImmutableArray.Create<LocalSymbol>(boundTempX.LocalSymbol, boundTempY.LocalSymbol), 1099sideEffects: ImmutableArray.Create<BoundExpression>(tempAssignmentX, tempAssignmentY), 1287locals: ImmutableArray.Create<LocalSymbol>(boundTempX.LocalSymbol, boundTempY.LocalSymbol), 1288sideEffects: ImmutableArray.Create<BoundExpression>(tempAssignmentX, tempAssignmentY), 1397sideEffects: ImmutableArray.Create<BoundExpression>(sideEffect), 1734locals: ImmutableArray.Create<LocalSymbol>(boundTemp.LocalSymbol), 1735sideEffects: ImmutableArray.Create<BoundExpression>(tempAssignment), 1795locals: ImmutableArray.Create<LocalSymbol>(boundTempX.LocalSymbol, boundTempY.LocalSymbol), 1796sideEffects: ImmutableArray.Create<BoundExpression>(tempAssignmentX, tempAssignmentY), 1883locals: ImmutableArray.Create<LocalSymbol>(boundTempX.LocalSymbol, boundTempY.LocalSymbol), 1884sideEffects: ImmutableArray.Create<BoundExpression>(tempAssignmentX, tempAssignmentY), 1965sideEffects: ImmutableArray.Create<BoundExpression>(nonNullValue),

808extraRefInitialization is object ? ImmutableArray.Create<BoundExpression>(extraRefInitialization, assignmentToTemp) : ImmutableArray.Create<BoundExpression>(assignmentToTemp), 884visitedArgumentsBuilder[argIndex] = _factory.Sequence(ImmutableArray<LocalSymbol>.Empty, ImmutableArray.Create<BoundExpression>(store), local); 1408ImmutableArray.Create<BoundExpression>( 1434arrayEmpty = arrayEmpty.Construct(ImmutableArray.Create(elementType)); 1644sideEffects: ImmutableArray.Create<BoundExpression>(boundAssignmentToTemp),

243return _factory.StaticCall(asImmutableArray.Construct(ImmutableArray.Create(elementType)), ImmutableArray.Create(arrayCreation)); 378ImmutableArray.Create(temp.LocalSymbol), 425var typeArgs = ImmutableArray.Create(elementType); 498arguments: ImmutableArray.Create(span), 571var inlineArrayType = _factory.ModuleBuilderOpt.EnsureInlineArrayTypeExists(syntax, _factory, arrayLength, _diagnostics.DiagnosticBag).Construct(ImmutableArray.Create(elementType)); 576Construct(ImmutableArray.Create(TypeWithAnnotations.Create(inlineArrayType), elementType)); 605inlineArrayAsSpan = inlineArrayAsSpan.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(inlineArrayType), elementType)); 748ImmutableArray.Create<BoundExpression>( 774ImmutableArray.Create(GetKnownLengthExpression(elements, numberIncludingLastSpread, localsBuilder)), 1025var typeArguments = ImmutableArray.Create(elementType); 1071rewrittenReceiver = _factory.New(constructor, ImmutableArray.Create<BoundExpression>(knownLengthTemp)); 1076rewrittenReceiver = _factory.New(constructor, ImmutableArray.Create(knownLengthExpression)); 1348var iterationVariables = ImmutableArray.Create(iterationVariable); 1421ImmutableArray.Create(statement),

160ImmutableArray.Create<BoundExpression>(_factory.Literal(builder.Count)), 1197locals: ImmutableArray.Create(boundTemp.LocalSymbol), 1198sideEffects: ImmutableArray.Create<BoundExpression>(tempAssignment), 1473locals: ImmutableArray.Create(boundTemp.LocalSymbol), 1474sideEffects: ImmutableArray.Create<BoundExpression>(tempAssignment), 1530rewrittenArguments: ImmutableArray.Create(rewrittenOperand)); 1782var result = UserDefinedConversionResult.Valid(ImmutableArray.Create<UserDefinedConversionAnalysis>(analysis), 0); 1882var 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);

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

260tryBlock: new BoundBlock(forEachSyntax, locals: ImmutableArray<LocalSymbol>.Empty, statements: ImmutableArray.Create(whileLoop)), 269locals: ImmutableArray.Create(enumeratorVar), 270statements: ImmutableArray.Create<BoundStatement>(enumeratorVarDecl, tryFinally)); 281locals: ImmutableArray.Create(enumeratorVar), 282statements: ImmutableArray.Create<BoundStatement>(enumeratorVarDecl, whileLoop)); 412statements: ImmutableArray.Create(alwaysOrMaybeDisposeStmt)); 466locals: ImmutableArray.Create(disposableVar), 467statements: ImmutableArray.Create(disposableVarDecl, ifStmt)); 630arrayVarDecl = new BoundStatementList(arrayVarDecl.Syntax, ImmutableArray.Create(collectionVarInitializationPreamble, arrayVarDecl)).MakeCompilerGenerated(); 660statements: ImmutableArray.Create<BoundStatement>(arrayVarDecl, positionVarDecl)); 693outerLocals: preambleLocal is null ? ImmutableArray.Create<LocalSymbol>(collectionTemp, positionVar) : ImmutableArray.Create<LocalSymbol>(preambleLocal, collectionTemp, positionVar), 855statements: ImmutableArray.Create(iteratorVariableInitialization, rewrittenBody)); 944indices: ImmutableArray.Create<BoundExpression>(boundPositionVar), 953statements: ImmutableArray.Create<BoundStatement>(arrayVarDecl, positionVarDecl)); 989outerLocals: ImmutableArray.Create<LocalSymbol>(arrayVar, positionVar), 1096ImmutableArray<BoundExpression> dimensionArgument = ImmutableArray.Create( 1123indices: ImmutableArray.Create((BoundExpression[])boundPositionVar), 1150ImmutableArray<BoundExpression> dimensionArgument = ImmutableArray.Create( 1197outerLocals: ImmutableArray.Create(positionVar[dimension]), 1211ImmutableArray.Create(arrayVar).Concat(upperVar.AsImmutableOrNull()), 1212ImmutableArray.Create(arrayVarDecl).Concat(upperVarDecl.AsImmutableOrNull()).Add(forLoop));

297result = _factory.Sequence(ImmutableArray.Create(((BoundLocal)rewrittenReceiver).LocalSymbol), 298ImmutableArray.Create((BoundExpression)receiverStore), 512!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(

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

428rewrittenAccess = 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)));

211arguments = ImmutableArray.Create(boundCoalesce.LeftOperand); 389return BoundCall.Synthesized(syntax, receiverOpt: null, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, method, ImmutableArray.Create(loweredFirst, loweredSecond, loweredThird)); 402return BoundCall.Synthesized(syntax, receiverOpt: null, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, method, ImmutableArray.Create(loweredFirst, loweredSecond, loweredThird, loweredFourth)); 729ImmutableArray.Create(temp.LocalSymbol), 730ImmutableArray.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,

236locals: ImmutableArray.Create<LocalSymbol>(boundTemp.LocalSymbol), 237sideEffects: ImmutableArray.Create<BoundExpression>(tempAssignment), 516ImmutableArray<BoundExpression> assignments = ImmutableArray.Create<BoundExpression>( 550ImmutableArray.Create<BoundExpression>(tempAssignment), 712locals: ImmutableArray.Create<LocalSymbol>(boundTemp.LocalSymbol), 713sideEffects: 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 };

97var loweredArguments = ImmutableArray.Create(loweredOperand); 129var loweredArguments = ImmutableArray.Create(loweredOperand); 172var loweredArguments = ImmutableArray.Create<BoundExpression>(loweredLeft, loweredRight);

536ImmutableArray.Create<LocalSymbol>(tempLocal.LocalSymbol), 537ImmutableArray.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]),

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

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

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

455return Block(ImmutableArray.Create(statements)); 460return Block(locals, ImmutableArray.Create(statements)); 470return Block(locals, localFunctions, ImmutableArray.Create(statements)); 495return new BoundStatementList(Syntax, ImmutableArray.Create(first, second)) { WasCompilerGenerated = true }; 831return Call(receiver, method, ImmutableArray.Create(arg0), useStrictArgumentRefKinds); 836return Call(receiver, method, ImmutableArray.Create(arg0, arg1), useStrictArgumentRefKinds); 841return Call(receiver, method, ImmutableArray.Create<BoundExpression>(args)); 845=> Call(receiver, WellKnownMethod(method), ImmutableArray.Create(arg0)); 987return MakeSequence(ImmutableArray.Create<LocalSymbol>(temp), parts); 1055=> SwitchSection(ImmutableArray.Create(value), statements); 1058=> new(values, ImmutableArray.Create(statements)); 1538arrayEmpty = arrayEmpty.Construct(ImmutableArray.Create(elementType)); 1550ImmutableArray.Create<BoundExpression>(Literal(elements.Length)), 1559ImmutableArray.Create<BoundExpression>(length), 1595return new BoundCatchBlock(Syntax, ImmutableArray.Create(local), source, source.Type, exceptionFilterPrologueOpt: null, exceptionFilterOpt: null, body: block, isSynthesizedAsyncCatchAll: false); 1845sideEffects: 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);

370executableCodeBlocks: 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)

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

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

216=> 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>(

115constructedInterfaces.Add(new ConstructedNamedTypeSymbol(iListOfT, ImmutableArray.Create(elementTypeWithAnnotations))); 122constructedInterfaces.Add(new ConstructedNamedTypeSymbol(iReadOnlyListOfT, ImmutableArray.Create(elementTypeWithAnnotations)));

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

470ImmutableArray.Create( 485ImmutableArray.Create(ticks)); 496ImmutableArray.Create(new TypedConstant( 767ImmutableArray.Create(typedConstantDebugMode)); 790var arguments = ImmutableArray.Create(new TypedConstant(boolArray, transformFlags)); 807var args = ImmutableArray.Create(new TypedConstant(stringArray, names)); 815var arguments = ImmutableArray.Create( 817var 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;

236return ImmutableArray.CreateRange<NamedTypeSymbol>(GetMembersUnordered().OfType<NamedTypeSymbol>()); 241return ImmutableArray.CreateRange<NamedTypeSymbol>(GetMembers().OfType<NamedTypeSymbol>()); 247return 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));

595return ImmutableArray.Create<NamedTypeSymbol>(new UnsupportedMetadataTypeSymbol(mrEx)); 871return 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);

843return this.Construct(ImmutableArray.Create(typeArguments)); 1280ImmutableArray.Create( 1287ImmutableArray.Create(new TypedConstant(declaringCompilation.GetSpecialType(SpecialType.System_String), TypedConstantKind.Primitive, nameof(CompilerFeatureRequiredFeatures.RequiredMembers)))

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

223return ImmutableArray.Create<Location>(_syntax.Location); 250return ImmutableArray.Create<SyntaxReference>(syntaxReferenceOpt);

337public override ImmutableArray<Location> Locations => ImmutableArray.Create(Syntax.Identifier.GetLocation()); 459ImmutableArray.Create(location), 460ImmutableArray.Create(parameter.GetReference()));

1007return ImmutableArray.Create(CSharpCustomModifier.CreateOptional(requiresLocationType)); 1018return ImmutableArray.Create(CSharpCustomModifier.CreateRequired(modifierType));

1838ImmutableArray.Create(typedConstantRequestMinimum), 1839ImmutableArray.Create(new KeyValuePair<WellKnownMember, TypedConstant>( 1976ImmutableArray.Create(typedConstantNoStringInterning))); 1996ImmutableArray.Create(new KeyValuePair<WellKnownMember, TypedConstant>( 2026AddSynthesizedAttribute(ref attributes, _compilation.TrySynthesizeAttribute(WellKnownMember.System_Reflection_AssemblyKeyNameAttribute__ctor, ImmutableArray.Create(typedConstant))); 2036AddSynthesizedAttribute(ref attributes, _compilation.TrySynthesizeAttribute(WellKnownMember.System_Reflection_AssemblyKeyFileAttribute__ctor, ImmutableArray.Create(typedConstant)));

1282parameterOrdinals = ImmutableArray.Create(ordinal);

170ImmutableArray.Create<EventSymbol>(explicitlyImplementedEvent);

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

118return ImmutableArray.Create(_location); 129return ImmutableArray.Create<SyntaxReference>(_syntaxRef);

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

51ImmutableArray.Create<TypedConstant>(item1, item2))); 220return ImmutableArray.Create<Symbol>(_constructor, _internalField); 226(name == _constructor.Name) ? ImmutableArray.Create<Symbol>(_constructor) : 227(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());

1609{ symbol.Name.AsMemory(), ImmutableArray.Create(symbol) }, 1635: ImmutableArray.Create((Symbol)pair.Value)); 3072return ImmutableArray.Create(InstanceInitializersForPositionalMembers.ToImmutableAndFree()); 4351ImmutableArray.Create<ParameterSymbol>(new SignatureOnlyParameterSymbol( 4400ImmutableArray.Create<ParameterSymbol>(new SignatureOnlyParameterSymbol( 4727ImmutableArray.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()));

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

777=> ImmutableArray.Create(_location); 1051ImmutableArray.Create(arg))); 1057ImmutableArray.Create(arg))); 1063ImmutableArray.Create(arg)));

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

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

1692ImmutableArray.Create( 1699ImmutableArray.Create(new TypedConstant(compilation.GetSpecialType(SpecialType.System_String), TypedConstantKind.Primitive, nameof(CompilerFeatureRequiredFeatures.RefStructs))), 1716ImmutableArray.Create(defaultMemberNameConstant))); 1748ImmutableArray.Create(new TypedConstant(compilation.GetWellKnownType(WellKnownType.System_Type), TypedConstantKind.Type, originalType)), 1879Conversions.HasIdentityConversion(((NamedTypeSymbol)returnTypeOriginalDefinition).Construct(ImmutableArray.Create(elementType)), returnType))

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

402return OneOrMany.Create(ImmutableArray.Create(AttributeDeclarationSyntaxList, this.SourcePartialImplementation.AttributeDeclarationSyntaxList)); 1147var syntaxRefs = ImmutableArray.Create(parameter.GetReference()); 1148var locations = ImmutableArray.Create(location);

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

394var modifiers = ImmutableArray.Create<CustomModifier>( 623: ImmutableArray.Create<MethodSymbol>(implementedAccessor);

272_lazyRefCustomModifiers = ImmutableArray.Create(CSharpCustomModifier.CreateRequired(modifierType)); 279ImmutableArray.Create(explicitlyImplementedProperty); 530return ImmutableArray.Create(Location); 538return ImmutableArray.Create(_syntaxRef);

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

14Parameters = ImmutableArray.Create(

14Parameters = ImmutableArray.Create(

38_interfaces = ImmutableArray.Create(

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

272TypeParameters = ImmutableArray.Create<TypeParameterSymbol>(typeParameter); 296? ImmutableArray.Create( 305: ImmutableArray.Create( 883? ImmutableArray.Create(_enumeratorType)

30Parameters: ImmutableArray.Create<ParameterSymbol>(

24Parameters = ImmutableArray.Create(SynthesizedParameterSymbol.Create(

70Parameters: 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()));

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

20_parameters = ImmutableArray.Create<ParameterSymbol>(

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

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

403statements: ImmutableArray.Create<BoundStatement>( 426statements: ImmutableArray.Create<BoundStatement>( 502ImmutableArray.Create<LocalSymbol>(scriptLocal.LocalSymbol), 503ImmutableArray.Create<BoundStatement>( 540_parameters = ImmutableArray.Create(SynthesizedParameterSymbol.Create(this, 590ImmutableArray.Create<BoundExpression>(submissionArrayParameter), 619ImmutableArray.Create<LocalSymbol>(submissionLocal.LocalSymbol), 620ImmutableArray.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")));

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

44_parameters = ImmutableArray.Create<ParameterSymbol>(new SynthesizedOperatorParameterSymbol(this, leftType, 0, "left"), 53_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);

61var locations = locationOpt is null ? ImmutableArray<Location>.Empty : ImmutableArray.Create(locationOpt); 240NamedTypeSymbol currentSymbol = firstTupleType.Construct(ImmutableArray.Create(elementTypes, (chainLength - 1) * (ValueTupleRestPosition - 1), remainder)); 244var chainedTypes = ImmutableArray.Create(elementTypes, (loop - 1) * (ValueTupleRestPosition - 1), ValueTupleRestPosition - 1).Add(TypeWithAnnotations.Create(currentSymbol)); 850return elementLocation == null ? ImmutableArray<Location>.Empty : ImmutableArray.Create(elementLocation);

2011ImmutableArray.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)

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

62ImmutableArray.Create(declaration.GetLocation()),

65ImmutableArray.Create(declaration.GetLocation()),

81ImmutableArray.Create(methodDeclaration.GetLocation()),

230var allLocations = ImmutableArray.Create(

58additionalLocations: ImmutableArray.Create(localFunction.GetLocation()),

166additionalLocations: ImmutableArray.Create(additionalLocation),

65additionalLocations: ImmutableArray.Create(additionalLocation),

96additionalLocations: ImmutableArray.Create(initializer.GetLocation()),

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

48ImmutableArray.Create(node.GetLocation()),

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

121var additionalLocations = ImmutableArray.Create(firstStatementLocation); 140var additionalUnnecessaryLocations = ImmutableArray.Create(location);

21siblingStatements = ImmutableArray.CreateRange(block.Statements); 25siblingStatements = ImmutableArray.CreateRange(switchSection.Statements);

70ImmutableArray.Create(subpattern.GetLocation()),

199additionalLocations: ImmutableArray.Create(initializer.GetLocation()), 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(

49var locations = ImmutableArray.Create(invocationExpression.GetLocation()); 60var additionalUnnecessaryLocations = ImmutableArray.Create(

60additionalLocations: ImmutableArray.Create(nodeToReplace.GetLocation()),

105additionalLocations: ImmutableArray.Create(invocation.GetLocation()),

74var locations = ImmutableArray.Create(objectCreationExpression.GetLocation()); 85var 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);

100additionalLocations: ImmutableArray.Create(coalesceExpression.GetLocation()), 173additionalLocations: ImmutableArray.Create(ifStatement.GetLocation()),

13ImmutableArray.Create(

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

78var additionalLocations = ImmutableArray.Create(declaration.GetLocation()); 93var additionalLocations = ImmutableArray.Create(declaration.GetLocation());

63ImmutableArray.Create(objectCreation.GetLocation()),

315var additionalLocations = ImmutableArray.Create(

133var additionalLocations = ImmutableArray.Create(

253var additionalLocations = ImmutableArray.Create(

148var additionalLocations = ImmutableArray.Create(

113var additionalLocations = ImmutableArray.Create(

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

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

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

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

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

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

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

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

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

164=> ImmutableArray.Create(new DiagnosticDescriptor(

275""", new TestParameters(options: s_options.AccessibilitiesArePascalCase(ImmutableArray.Create(alternateAccessibility)))); 289""", options: s_options.AccessibilitiesArePascalCase(ImmutableArray.Create(accessibility)));

524AssertEx.Equal(ImmutableArray.Create<string>(), parser.KeyFileSearchPaths); 536AssertEx.Equal(ImmutableArray.Create<string>(), parser.KeyFileSearchPaths); 550AssertEx.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.", 14219var virtualSnProvider = new DesktopStrongNameProvider(ImmutableArray.Create(dir.Path)); 14895public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(_rule); 15940return ImmutableArray.Create(Hidden01, Hidden02); 15964return ImmutableArray.Create(Info01); 15991return ImmutableArray.Create(Warning01); 16010public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Warning02); 16033return ImmutableArray.Create(Error01, Error02);

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

52var spans = ImmutableArray.Create(new TextSpan(start, length)); 119var spans = ImmutableArray.Create( 123var 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/")); 229.Returns(ImmutableArray.Create("1.0", "2.0")); 315.Returns(ImmutableArray.Create("1.0")); 352.Returns(ImmutableArray.Create("1.0")); 387=> new(ImmutableArray.Create(results));

2042MemberNames = ImmutableArray.Create("a", "b"), 2087MemberNames = ImmutableArray.Create("c", "b"), 4155MemberNames = ImmutableArray.Create("bar"), 4213MemberNames = ImmutableArray.Create("bar"), 4271MemberNames = ImmutableArray.Create("bar"), 4331MemberNames = ImmutableArray.Create("bar"),

578expectedContainers: ImmutableArray.Create("TestNamespace"), 1415expectedContainers: ImmutableArray.Create("N"), 3857expectedContainers: ImmutableArray.Create("Goo"), 3882expectedContainers: ImmutableArray.Create("Goo"), 3907expectedContainers: ImmutableArray.Create("Goo"), 5625expectedContainers: ImmutableArray.Create("Namespace1", "Namespace2"),

800newFileFolderContainers: ImmutableArray.Create("outer", "inner"), 842newFileFolderContainers: ImmutableArray.Create("outer", "inner"), 878newFileFolderContainers: ImmutableArray.Create("outer", "inner"), 921newFileFolderContainers: ImmutableArray.Create("outer", "inner"), 968newFileFolderContainers: ImmutableArray.Create("outer"), 1017newFileFolderContainers: ImmutableArray.Create("outer"), 1073newFileFolderContainers: ImmutableArray.Create("123", "456"), 1310newFileFolderContainers: ImmutableArray.Create("outer", "inner"), 1349newFileFolderContainers: ImmutableArray.Create("outer", "inner"), 1395newFileFolderContainers: ImmutableArray.Create("outer", "inner"), 1435newFileFolderContainers: ImmutableArray.Create("outer", "inner"), 1518newFileFolderContainers: ImmutableArray.Create("outer", "inner"), 1556newFileFolderContainers: ImmutableArray.Create("outer", "inner"), 1601newFileFolderContainers: ImmutableArray.Create("outer", "inner"), 1640newFileFolderContainers: ImmutableArray.Create("outer", "inner"), 1685newFileFolderContainers: ImmutableArray.Create("outer", "inner"),

37var selectedMembers = ImmutableArray.Create("TestField"); 69var selectedMembers = ImmutableArray.Create("TestProperty"); 102var selectedMembers = ImmutableArray.Create("TestEvent"); 140var selectedMembers = ImmutableArray.Create("TestMethod"); 186var selectedMembers = ImmutableArray.Create("TestMethod"); 230var selectedMembers = ImmutableArray.Create("TestField"); 303var selectedMembers = ImmutableArray.Create("TestMethod"); 347var selectedMembers = ImmutableArray.Create("TestMethodInt", "TestMethodBool"); 395var selectedMembers = ImmutableArray.Create("TestMethodBool"); 445var selectedMembers = ImmutableArray.Create( 496var selectedMembers = ImmutableArray.Create("TestField"); 534var selectedMembers = ImmutableArray.Create("TestField"); 565var selectedMembers = ImmutableArray.Create("TestField"); 587var selectedMembers = ImmutableArray.Create("TestField"); 620var selectedMembers = ImmutableArray.Create("TestMethod"); 657var selectedMembers = ImmutableArray.Create("TestMethod"); 705var selectedMembers = ImmutableArray.Create("TestMethod"); 742var selectedMembers = ImmutableArray.Create("TestMethod"); 787var selectedMembers = ImmutableArray.Create("TestMethod"); 841var selectedMembers = ImmutableArray.Create("TestMethod"); 892var selectedMembers = ImmutableArray.Create("TestMethod"); 935var selectedMembers = ImmutableArray.Create("TestField"); 984var selectedMembers = ImmutableArray.Create("TestProperty", "_testProperty"); 1039var selectedMembers = ImmutableArray.Create("TestMethod"); 1094var selectedMembers = ImmutableArray.Create("TestMethod"); 1153var selectedMembers = ImmutableArray.Create("TestMethod", "TestGeneric"); 1213var selectedMembers = ImmutableArray.Create("TestMethod"); 1275var selectedMembers = ImmutableArray.Create("TestMethod"); 1333var selectedMembers = ImmutableArray.Create("TestMethod"); 1390var selectedMembers = ImmutableArray.Create("TestMethod"); 1469var selectedMembers = ImmutableArray.Create("TestMethod"); 1533var selectedMembers = ImmutableArray.Create("TestMethod"); 1605var selectedMembers = ImmutableArray.Create("Foo"); 1688var selectedMembers = ImmutableArray.Create("TestMethod"); 1751var selectedMembers = ImmutableArray.Create("TestMethod"); 1815var selectedMembers = ImmutableArray.Create("TestMethod"); 1884var selectedMembers = ImmutableArray.Create("TestMethod"); 1964var selectedMembers = ImmutableArray.Create("TestMethod"); 2060var selectedMembers = ImmutableArray.Create("TestMethod"); 2131var selectedMembers = ImmutableArray.Create("TestMethod"); 2170var selectedMembers = ImmutableArray.Create("TestMethod"); 2211var selectedMembers = ImmutableArray.Create("TestField"); 2244var selectedMembers = ImmutableArray.Create("TestProperty"); 2279var selectedMembers = ImmutableArray.Create("TestEvent"); 2319var selectedMembers = ImmutableArray.Create("TestMethod"); 2367var selectedMembers = ImmutableArray.Create("TestMethod"); 2412var selectedMembers = ImmutableArray.Create("TestField"); 2454var selectedMembers = ImmutableArray.Create("TestMethod"); 2502var selectedMembers = ImmutableArray.Create("TestMethod"); 2549var selectedMembers = ImmutableArray.Create("TestMethod"); 2596var selectedMembers = ImmutableArray.Create("TestMethod"); 2644var selectedMembers = ImmutableArray.Create("IsValidWorkflowType", "validWorkflowTypes"); 2693var selectedMembers = ImmutableArray.Create("TestMethod"); 2727var selectedMembers = ImmutableArray.Create("TestField"); 2758var selectedMembers = ImmutableArray.Create("TestField"); 2789var selectedMembers = ImmutableArray.Create("TestField"); 2820var selectedMembers = ImmutableArray.Create("TestField"); 2854var selectedMembers = ImmutableArray.Create("TestMethod"); 2889var selectedMembers = ImmutableArray.Create("TestField"); 2921var selectedMembers = ImmutableArray.Create("Goo", "Foo"); 2959var selectedMembers = ImmutableArray.Create("Goo", "Foo", "DoSomething"); 3002var selectedMembers = ImmutableArray.Create("Goo", "Foo"); 3045var selectedMembers = ImmutableArray.Create("Goo", "Foo", "DoSomething"); 3088var selectedMembers = ImmutableArray.Create("Foo"); 3127var selectedMembers = ImmutableArray.Create("Goo");

2958ImmutableArray.Create(kind)); 2992ImmutableArray.Create(kind), 3010var symbolSpecifications = ImmutableArray.Create( 3014ImmutableArray.Create(new SymbolKindOrTypeKind(SymbolKind.Parameter)), 3020ImmutableArray.Create(new SymbolKindOrTypeKind(SymbolKind.Parameter), new SymbolKindOrTypeKind(SymbolKind.Local)), 3023var namingStyles = ImmutableArray.Create( 3041namingRules: ImmutableArray.Create(

58var analyzerReference = new AnalyzerImageReference(ImmutableArray.Create<DiagnosticAnalyzer>(analyzer)); 89var analyzerReference = new AnalyzerImageReference(ImmutableArray.Create<DiagnosticAnalyzer>(ideEngineAnalyzer)); 125var analyzerReference = new AnalyzerImageReference(ImmutableArray.Create(analyzer)); 166var options = new AnalyzerOptions(ImmutableArray.Create<AdditionalText>(additionalText)); 168var analyzerReference = new AnalyzerImageReference(ImmutableArray.Create<DiagnosticAnalyzer>(analyzer)); 181var diagnosticService = new HostDiagnosticAnalyzers([new AnalyzerImageReference(ImmutableArray.Create(analyzer))]); 201var analyzerReference = new AnalyzerImageReference(ImmutableArray.Create<DiagnosticAnalyzer>(analyzer)); 223return ImmutableArray.Create(s_syntaxDiagnosticDescriptor); 257var analyzerReference = new AnalyzerImageReference(ImmutableArray.Create<DiagnosticAnalyzer>(analyzer)); 294return ImmutableArray.Create(Descriptor); 314return ImmutableArray.Create(SyntaxKind.MethodDeclaration, SyntaxKind.ExpressionStatement, SyntaxKind.EqualsValueClause); 349=> ImmutableArray.Create(Descriptor); 538nugetAnalyzers: ImmutableArray.Create(firstNugetAnalyzer, secondNugetAnalyzer), 557nugetAnalyzers: ImmutableArray.Create(firstNugetAnalyzer, secondNugetAnalyzer), 559vsixAnalyzers: ImmutableArray.Create(vsixAnalyzer), 577nugetAnalyzers: ImmutableArray.Create(firstNugetAnalyzer), 579vsixAnalyzers: ImmutableArray.Create(vsixAnalyzer), 619vsixAnalyzers: ImmutableArray.Create(vsixAnalyzer), 623vsixSuppressors: ImmutableArray.Create(vsixSuppressor), 637nugetAnalyzers: ImmutableArray.Create(firstNugetAnalyzer, secondNugetAnalyzer), 639vsixAnalyzers: ImmutableArray.Create(vsixAnalyzer), 643vsixSuppressors: ImmutableArray.Create(vsixSuppressor), 660nugetAnalyzers: ImmutableArray.Create(firstNugetAnalyzer), 662vsixAnalyzers: ImmutableArray.Create(vsixAnalyzer), 664nugetSuppressors: ImmutableArray.Create(nugetSuppressor), 682nugetAnalyzers: ImmutableArray.Create(firstNugetAnalyzer), 684vsixAnalyzers: ImmutableArray.Create(vsixAnalyzer), 686nugetSuppressors: ImmutableArray.Create(partialNugetSuppressor), 688vsixSuppressors: ImmutableArray.Create(vsixSuppressor), 704nugetAnalyzers: ImmutableArray.Create(firstNugetAnalyzer), 706vsixAnalyzers: ImmutableArray.Create(vsixAnalyzer), 708nugetSuppressors: ImmutableArray.Create(nugetSuppressor), 710vsixSuppressors: ImmutableArray.Create(vsixSuppressor), 728nugetAnalyzer != null ? ImmutableArray.Create(nugetAnalyzer) : ImmutableArray<NuGetAnalyzer>.Empty, 730vsixAnalyzer != null ? ImmutableArray.Create(vsixAnalyzer) : ImmutableArray<VsixAnalyzer>.Empty,

40return ImmutableArray.Create(Descriptor); 67return ImmutableArray.Create(QualifyWithThisAnalyzer.Descriptor.Id);

29return ImmutableArray.Create(_descriptor);

466var editorConfigString = EditorConfigNamingStyleParser.ToEditorConfigString(ImmutableArray.Create(applicableSymbolKind));

40spanProvider.GetBaseActiveStatementSpansImpl = (_, documentIds) => ImmutableArray.Create( 41ImmutableArray.Create( 48"1.cs" => ImmutableArray.Create(

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

21public override ImmutableArray<string> FixableDiagnosticIds { get; } = ImmutableArray.Create("HasDefaultCase");

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

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

124var results = ImmutableArray.Create<INavigateToSearchResult>(new TestNavigateToSearchResult(workspace, new TextSpan(0, 0))); 159var results = ImmutableArray.Create<INavigateToSearchResult>(new TestNavigateToSearchResult(workspace, new TextSpan(0, 0))); 236var results = ImmutableArray.Create<INavigateToSearchResult>(new TestNavigateToSearchResult(workspace, new TextSpan(0, 0))); 272var results = ImmutableArray.Create<INavigateToSearchResult>(new TestNavigateToSearchResult(workspace, new TextSpan(0, 0))); 320var results = ImmutableArray.Create<INavigateToSearchResult>(new TestNavigateToSearchResult(workspace, new TextSpan(0, 0)));

210var analyzerReference = new AnalyzerImageReference(ImmutableArray.Create<DiagnosticAnalyzer>(

991classificationTypeNames: ImmutableArray.Create(

126var json = new StringCopyPasteData(ImmutableArray.Create(StringCopyPasteContent.ForText(pasteText))).ToJson();

63=> 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), 12623publicKeyOrToken: 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));

2664MetadataReaderUtils.AssertNotThrowNull(ImmutableArray.CreateRange(output.GetBuffer())); 2665MetadataReaderUtils.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))); 3648emitOptions: EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage)), 3663return base.CompileAndVerify(compilation, expectedOutput: expectedOutput, emitOptions: EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage)));

361Assert.True(i1.Interfaces().SequenceEqual(ImmutableArray.Create<NamedTypeSymbol>(i2, i3, i4, i5, i6, i7))); 362Assert.True(i2.Interfaces().SequenceEqual(ImmutableArray.Create<NamedTypeSymbol>(i3, i4))); 365Assert.True(i5.Interfaces().SequenceEqual(ImmutableArray.Create<NamedTypeSymbol>(i6, i7))); 369Assert.True(c.Interfaces().SequenceEqual(ImmutableArray.Create<NamedTypeSymbol>(i1, i2, i3, i4, i5, i6, i7)));

86var actualIL = ImmutableArray.Create(ilStream.ToArray()).GetMethodIL(); 158var actualIL = ImmutableArray.Create(ilStream.ToArray()).GetMethodIL(); 228ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1))); 234ImmutableArray.Create( 333ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1))); 337ImmutableArray.Create( 416ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1))); 471var ref01 = lib01.ToMetadataReference(ImmutableArray.Create("L0")); 474var ref02 = lib02.ToMetadataReference(ImmutableArray.Create("L0")); 477var ref11 = lib11.ToMetadataReference(ImmutableArray.Create("L1")); 480var ref12 = lib12.ToMetadataReference(ImmutableArray.Create("L1")); 496ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1))); 607ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, m0, m1, GetSyntaxMapFromMarkers(source0, source1)))); 616ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f1, f2, GetSyntaxMapFromMarkers(source1, source2)))); 628ImmutableArray.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( 3681ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1)))); 3785ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1)))); 3894ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1)))); 4000ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1)))); 4114ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1)))); 4266ImmutableArray.Create( 4500ImmutableArray.Create( 4660ImmutableArray.Create( 5123ImmutableArray.Create( 5471ImmutableArray.Create( 5810ImmutableArray.Create( 5815ImmutableArray.Create( 5820ImmutableArray.Create( 6715ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 7154ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 7438ImmutableArray.Create( 7450ImmutableArray.Create( 7461ImmutableArray.Create( 7817ImmutableArray.Create( 7892ImmutableArray.Create( 8187ImmutableArray.Create( 8199ImmutableArray.Create( 8210ImmutableArray.Create( 8720ImmutableArray.Create( 8729ImmutableArray.Create( 8738ImmutableArray.Create( 8747ImmutableArray.Create( 8797ImmutableArray.Create( 8802ImmutableArray.Create( 8902ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 8914ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f1, f2, GetSyntaxMapFromMarkers(source1, source2)))); 9097ImmutableArray.Create( 9219ImmutableArray.Create( 9238ImmutableArray.Create( 9376ImmutableArray.Create( 9389ImmutableArray.Create( 9531ImmutableArray.Create( 9542ImmutableArray.Create( 9638ImmutableArray.Create( 9700ImmutableArray.Create( 9768ImmutableArray.Create( 9780ImmutableArray.Create( 9794ImmutableArray.Create( 9806ImmutableArray.Create( 9818ImmutableArray.Create( 10270ImmutableArray.Create( 10580ImmutableArray.Create( 10646ImmutableArray.Create( 10713ImmutableArray.Create( 10778ImmutableArray.Create( 10846ImmutableArray.Create( 10899ImmutableArray.Create( 10963ImmutableArray.Create( 11029ImmutableArray.Create( 11080ImmutableArray.Create( 11131ImmutableArray.Create( 11185ImmutableArray.Create( 11246ImmutableArray.Create( 11301ImmutableArray.Create( 11368ImmutableArray.Create(

277ImmutableArray.Create( 320ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1))); 353ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1))); 408ImmutableArray.Create( 418ImmutableArray.Create( 474ImmutableArray.Create( 521ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1))); 583ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1))); 610ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method1, method2))); 810ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1))); 1165ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1))); 1202ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method1, method2))); 1288ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1))); 1329ImmutableArray.Create( 1361ImmutableArray.Create( 1909ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1)))); 1998ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1)))); 2016ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method1, method2, GetSyntaxMapFromMarkers(source1, source2)))); 2083ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1)))); 2101ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method1, method2, GetSyntaxMapFromMarkers(source1, source2)))); 2157ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1)))); 2223ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1)))); 2243ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method1, method2, GetSyntaxMapFromMarkers(source1, source2)))); 2299ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1)))); 2916ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Insert, null, method1))); 3009ImmutableArray.Create( 3058ImmutableArray.Create( 3123ImmutableArray.Create( 3454ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Insert, null, f1))); 3488ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f1, f2))); 3597ImmutableArray.Create( 3687ImmutableArray.Create( 3784ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Insert, null, f3))); 3847ImmutableArray.Create( 3907ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, getP0, getP1))); 3976? ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Insert, null, r1), SemanticEdit.Create(SemanticEditKind.Insert, null, r1.GetMethod)) 3977: ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Insert, null, r1))); 4011? ImmutableArray.Create( 4015: ImmutableArray.Create( 5437ImmutableArray.Create( 5492ImmutableArray.Create( 5944ImmutableArray.Create( 6009ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, c0, c1))); 6030ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, c1, c2))); 6209ImmutableArray.Create( 6217ImmutableArray.Create( 6226ImmutableArray.Create( 6387ImmutableArray.Create( 6465ImmutableArray.Create( 6480ImmutableArray.Create( 6550ImmutableArray.Create( 6565ImmutableArray.Create( 6628ImmutableArray.Create( 6730ImmutableArray.Create( 6791ImmutableArray.Create( 6905ImmutableArray.Create( 6919ImmutableArray.Create( 6962ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1))); 7029ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Insert, null, method1))); 7055ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method1, method2))); 7105ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1))); 7218ImmutableArray.Create( 7243ImmutableArray.Create( 7382ImmutableArray.Create( 7526ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Insert, null, compilation1.GetMember<MethodSymbol>("C.M")))); 7598ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 7648ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, compilation0.GetMember("C.M"), compilation1.GetMember("C.M")))); 7750ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Insert, null, compilation1.GetMember<MethodSymbol>("C.puts")))); 7806ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Insert, null, compilation1.GetMember<NamedTypeSymbol>("B")))); 7886ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Insert, null, compilation1.GetMembers("M.C.M1")[2]))); 7919ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, compilation1.GetMember<MethodSymbol>("M.C.M2"), 8042ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, compilation0.GetMembers("C.M")[0], compilation1.GetMembers("C.M")[0]))); 8066ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, compilation1.GetMembers("C.M")[1], compilation2.GetMembers("C.M")[1]))); 8090ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, compilation2.GetMembers("C.M")[2], compilation3.GetMembers("C.M")[2]))); 8115ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, compilation3.GetMembers("C.M")[3], compilation4.GetMembers("C.M")[3]))); 8140ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, compilation4.GetMembers("C.M")[4], compilation5.GetMembers("C.M")[4]))); 8164ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, compilation5.GetMembers("C.M")[5], compilation6.GetMembers("C.M")[5]))); 8188ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, compilation6.GetMembers("C.M")[6], compilation7.GetMembers("C.M")[6]))); 8214ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, compilation7.GetMembers("C.M")[7], compilation8.GetMembers("C.M")[7]))); 8239ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, compilation8.GetMembers("C.M")[8], compilation9.GetMembers("C.M")[8]))); 8263ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, compilation9.GetMembers("C.M")[9], compilation10.GetMembers("C.M")[9]))); 8336ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, compilation10.GetMembers("C.M")[12], compilation11.GetMembers("C.M")[12]))); 8360ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, compilation11.GetMembers("C.M")[13], compilation12.GetMembers("C.M")[13]))); 8429ImmutableArray.Create( 8535ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 8615ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, compilation0.GetMembers("C.F")[1], compilation1.GetMembers("C.F")[1]))); 8644ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, compilation1.GetMembers("C.F")[1], compilation2.GetMembers("C.F")[1]))); 8708ImmutableArray.Create(SemanticEdit.Create( 8841ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 8899ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method1, method2, GetEquivalentNodesMap(method2, method1)))); 8957ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method2, method3, GetEquivalentNodesMap(method3, method2)))); 9047ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Insert, null, m1, null))); 9051ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, m1, m2, GetEquivalentNodesMap(m2, m1)))); 9135ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 9185ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1))); 9234ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1))); 9381ImmutableArray.Create( 9410ImmutableArray.Create( 9438ImmutableArray.Create( 9523ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 9546ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f1, f2, GetSyntaxMapFromMarkers(source1, source2)))); 9612ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 9633ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f1, f2, GetSyntaxMapFromMarkers(source1, source2)))); 9719ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, m0, m1, GetEquivalentNodesMap(m1, m0)))); 9823ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetEquivalentNodesMap(f1, f0)))); 9939ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1)))); 9967ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method1, method2, GetSyntaxMapFromMarkers(source1, source2)))); 9999ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method2, method3, GetSyntaxMapFromMarkers(source2, source3)))); 10126ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetEquivalentNodesMap(f1, f0)))); 10136ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, g1, g2, GetEquivalentNodesMap(g2, g1)))); 10146ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, g2, g3, GetEquivalentNodesMap(g3, g2)))); 10232ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 10311ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, m0, m1, GetSyntaxMapFromMarkers(source0, source1)))); 10338ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, m1, m2, GetSyntaxMapFromMarkers(source1, source2)))); 10461ImmutableArray.Create( 10475ImmutableArray.Create( 10584ImmutableArray.Create( 10598ImmutableArray.Create( 10780ImmutableArray.Create( 10810ImmutableArray.Create( 10888ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 10961ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 11036ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 11129ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 11222ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 11286ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 11349ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 11359ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 11369ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 11379ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 11389ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 11399ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 11469ImmutableArray.Create( 11510ImmutableArray.Create( 11618ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 11736ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1)))); 11789ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetSyntaxMapFromMarkers(source0, source1)))); 11884ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1A, GetEquivalentNodesMap(method1A, method0)))); 11896ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1B, GetEquivalentNodesMap(method1B, method0)))); 11962ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1))); 12109ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1, GetEquivalentNodesMap(method1, method0)))); 12224ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0F, method1F, syntaxMap: s => null))); 12237ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method1F, method2F, syntaxMap: s => null))); 12249ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method1G, method2G, syntaxMap: s => null))); 12292ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0F, method1F, syntaxMap: s => null)), 12307ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0F, method1F, syntaxMap: s => null)), 12322ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0F, method1F, syntaxMap: s => null)), 12377ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0F, method1F, syntaxMap: s => null)), 12413ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Insert, null, compilation1.GetMember<MethodSymbol>("C.Main"))), 12453ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, compilation0.GetMember("C.Main"), compilation1.GetMember("C.Main")))); 12505ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0F, method1F, syntaxMap: s => null))); 12516ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method1F, method2F, syntaxMap: s => null))); 12575ImmutableArray.Create( 12584ImmutableArray.Create( 12640ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetEquivalentNodesMap(f1, f0)))); 12659ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f1, f2, GetEquivalentNodesMap(f2, f1)))); 12711ImmutableArray.Create( 12718ImmutableArray.Create( 12755ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1))); 12836ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1))))); 12904ImmutableArray.Create( 12947ImmutableArray.Create( 13053ImmutableArray.Create( 13086ImmutableArray.Create( 13181ImmutableArray.Create( 13205ImmutableArray.Create( 13289ImmutableArray.Create( 13314ImmutableArray.Create( 13432ImmutableArray.Create( 13484ImmutableArray.Create( 13604ImmutableArray.Create( 13638ImmutableArray.Create( 13730ImmutableArray.Create( 13759ImmutableArray.Create( 13900ImmutableArray.Create( 13957ImmutableArray.Create( 14068ImmutableArray.Create( 14096ImmutableArray.Create( 14180ImmutableArray.Create( 14203ImmutableArray.Create( 14301ImmutableArray.Create( 14350ImmutableArray.Create( 14463ImmutableArray.Create( 14504ImmutableArray.Create( 14597ImmutableArray.Create( 14621ImmutableArray.Create( 14715ImmutableArray.Create( 14759ImmutableArray.Create( 14892ImmutableArray.Create( 14946ImmutableArray.Create( 15108ImmutableArray.Create( 15179ImmutableArray.Create( 15342ImmutableArray.Create( 15392ImmutableArray.Create( 15481ImmutableArray.Create( 15493ImmutableArray.Create( 15579ImmutableArray.Create( 15660ImmutableArray.Create( 16012ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1))); 16084ImmutableArray.Create( 18620ImmutableArray.Create( 18696ImmutableArray.Create( 18790ImmutableArray.Create( 18879ImmutableArray.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(

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

34var options = EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.CreateRange(kinds)); 442edits: ImmutableArray.Create( 443new 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")) });

5508NamedTypeSymbol classYOfW = classY.ConstructIfGeneric(ImmutableArray.Create(TypeWithAnnotations.Create(classW))); 5515NamedTypeSymbol classYOfInt = classY.ConstructIfGeneric(ImmutableArray.Create(TypeWithAnnotations.Create(m.ContainingAssembly.GetSpecialType(SpecialType.System_Int32)))); 5524NamedTypeSymbol substNestedZ = classYOfInt.GetTypeMember("Z").ConstructIfGeneric(ImmutableArray.Create(TypeWithAnnotations.Create(classW)));

1384AssertEx.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)).

44return ImmutableArray.Create(s_CA9999_UseOfVariableThatStartsWithX); 239return ImmutableArray.Create(s_descriptor); 477get { return ImmutableArray.Create(desc1, desc2, desc3); } 492get { return ImmutableArray.Create(desc1, desc2); } 506get { return ImmutableArray.Create(desc1); } 658public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get { return ImmutableArray.Create(Rule); } } 763get { return ImmutableArray.Create(Descriptor1, Descriptor2, Descriptor3, Descriptor4, Descriptor5, Descriptor6); } 800ImmutableArray.Create(SyntaxKind.EqualsValueClause)); 803ImmutableArray.Create(SyntaxKind.BaseConstructorInitializer)); 822}, ImmutableArray.Create(SyntaxKind.ArrowExpressionClause)); 833get { return ImmutableArray.Create(Descriptor1); } 884return ImmutableArray.Create(SupportedDescriptor); 1474var builder = ImmutableArray.CreateBuilder<SyntaxTree>(); 1645get { return ImmutableArray.Create(ExpressionDescriptor); } 2244var syntaxKinds = ImmutableArray.Create(SyntaxKind.VariableDeclaration); 2245var operationKinds = ImmutableArray.Create(OperationKind.VariableDeclarator); 2306public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Warning, Summary); 3265var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(new SymbolStartAnalyzer(topLevelAction: false, SymbolKind.NamedType)); 3311var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(new SymbolStartAnalyzer(topLevelAction: false, SymbolKind.NamedType)); 3349var compilationWithAnalyzers = compilation.WithAnalyzers(ImmutableArray.Create<DiagnosticAnalyzer>(analyzer1, analyzer2)); 3357var tree1SemanticDiagnostics = await compilationWithAnalyzers.GetAnalyzerSemanticDiagnosticsAsync(semanticModel1, filterSpan: null, ImmutableArray.Create<DiagnosticAnalyzer>(analyzer1), CancellationToken.None); 3686var allAnalyzers = ImmutableArray.Create<DiagnosticAnalyzer>(analyzer1, analyzer2); 3694var analyzersToQuery = singleAnalyzer ? ImmutableArray.Create<DiagnosticAnalyzer>(analyzer1) : allAnalyzers; 3753var allAnalyzers = ImmutableArray.Create<DiagnosticAnalyzer>(analyzer1, analyzer2); 3813var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(analyzer); 3843public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get { return ImmutableArray.Create(Rule); } } 3884var options = new AnalyzerOptions(ImmutableArray.Create(additionalFile)); 3887var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(analyzer); 3923var additionalFiles = ImmutableArray.Create(additionalFile1, additionalFile2); 3929var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(analyzer1, analyzer2); 3935verifyAnalysisResult(analysisResult, analyzers, ImmutableArray.Create(additionalFile1), diagnosticSpan, additionalFilesHaveSamePaths); 3937verifyAnalysisResult(analysisResult, analyzers, ImmutableArray.Create(additionalFile2), diagnosticSpan, additionalFilesHaveSamePaths); 3939var singleAnalyzerArray = ImmutableArray.Create<DiagnosticAnalyzer>(analyzer1); 3941verifyAnalysisResult(analysisResult, singleAnalyzerArray, ImmutableArray.Create(additionalFile1), diagnosticSpan, additionalFilesHaveSamePaths); 3943verifyAnalysisResult(analysisResult, singleAnalyzerArray, ImmutableArray.Create(additionalFile2), diagnosticSpan, additionalFilesHaveSamePaths); 4011var singleAnalyzerArray = ImmutableArray.Create(analyzer); 4015verifyDiagnostics(reportedDiagnostics, singleAnalyzerArray, ImmutableArray.Create(additionalFile), diagnosticSpan, additionalFilesHaveSamePaths); 4077public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get { return ImmutableArray.Create(Rule); } } 4122public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get { return ImmutableArray.Create(Rule); } } 4229var compilationWithAnalyzers = compilation.WithAnalyzers(ImmutableArray.Create<DiagnosticAnalyzer>(analyzer)); 4314var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(analyzer); 4316var analyzerOptions = new AnalyzerOptions(ImmutableArray.Create<AdditionalText>(additionalTextFile)); 4397var 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);

552var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(new CSharpCompilerDiagnosticAnalyzer()); 615var compilationWithAnalyzers = compilation.WithAnalyzers(ImmutableArray.Create(analyzer), analyzerOptions); 662var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(new CSharpCompilerDiagnosticAnalyzer()); 715var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(new SymbolStartAnalyzer(topLevelAction: false, SymbolKind.NamedType, OperationKind.VariableDeclaration)); 744var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(analyzer); 784var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(new CSharpCompilerDiagnosticAnalyzer()); 838var compilationWithAnalyzers = compilation.WithAnalyzers(ImmutableArray.Create<DiagnosticAnalyzer>(analyzer), AnalyzerOptions.Empty); 952public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor, DescriptorForBlockEnd); 1064var compilationWithAnalyzers = compilation.WithAnalyzers(ImmutableArray.Create<DiagnosticAnalyzer>(compilerAnalyzer), AnalyzerOptions.Empty); 1124var compilationWithAnalyzers = compilation.WithAnalyzers(ImmutableArray.Create<DiagnosticAnalyzer>(analyzer), AnalyzerOptions.Empty); 1438var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(new CSharpCompilerDiagnosticAnalyzer()); 1457analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(new CSharpCompilerDiagnosticAnalyzer(), suppressor); 1473public override ImmutableArray<SuppressionDescriptor> SupportedSuppressions => ImmutableArray.Create(_descriptor); 1519var compilationWithAnalyzers = compilation.WithAnalyzers(ImmutableArray.Create<DiagnosticAnalyzer>(analyzer), AnalyzerOptions.Empty); 1698var compilationWithAnalyzers = compilation.WithAnalyzers(ImmutableArray.Create<DiagnosticAnalyzer>(analyzer), AnalyzerOptions.Empty); 1714public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor);

26744var expectedConversion = new Conversion(ConversionKind.CollectionExpression, nestedConversions: ImmutableArray.Create(Conversion.Identity, Conversion.Identity)); 26799var expectedConversion = new Conversion(ConversionKind.CollectionExpression, nestedConversions: ImmutableArray.Create(Conversion.Identity, Conversion.Identity));

18802=> ImmutableArray.Create(Descriptor);

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

3750=> ImmutableArray.Create(Descriptor); 4075=> ImmutableArray.Create(Descriptor); 4161=> ImmutableArray.Create(Descriptor); 4310=> ImmutableArray.Create(Descriptor); 4500=> ImmutableArray.Create(Descriptor); 4634=> ImmutableArray.Create(Descriptor); 4814=> ImmutableArray.Create(Descriptor); 4959=> ImmutableArray.Create(Descriptor); 5138=> ImmutableArray.Create(Descriptor); 5251=> ImmutableArray.Create(Descriptor); 5478=> ImmutableArray.Create(Descriptor); 5565=> ImmutableArray.Create(Descriptor); 5678=> ImmutableArray.Create(Descriptor); 5775=> ImmutableArray.Create(Descriptor); 5833=> ImmutableArray.Create(Descriptor); 5926=> ImmutableArray.Create(Descriptor);

26235=> ImmutableArray.Create(Descriptor); 26558=> ImmutableArray.Create(Descriptor); 26653=> ImmutableArray.Create(Descriptor); 26818=> ImmutableArray.Create(Descriptor); 27008=> ImmutableArray.Create(Descriptor); 27142=> ImmutableArray.Create(Descriptor); 27322=> ImmutableArray.Create(Descriptor); 27467=> ImmutableArray.Create(Descriptor); 27650=> ImmutableArray.Create(Descriptor);

754var result = ImmutableArray.CreateBuilder<T>();

32=> ImmutableArray.Create(FixAllScope.Solution);

169symbols: ImmutableArray.Create(p),

78var serializedOptions = ImmutableArray.Create(KeyValuePairUtil.Create(HideAdvancedMembers, options.MemberDisplayOptions.HideAdvancedMembers.ToString())); 340symbols: ImmutableArray.Create(symbol),

525var possibleTypes = ImmutableArray.Create(

177symbols: ImmutableArray.Create(symbol), 200var additionalFilterTexts = ImmutableArray.Create(field.Name); 205symbols: ImmutableArray.Create<ISymbol>(field), 256var additionalFilterTexts = ImmutableArray.Create(staticSymbol.Name); 261symbols: ImmutableArray.Create(staticSymbol),

64return (ImmutableArray.Create<ISymbol>(conversion), s_conversionProperties); 72var symbols = ImmutableArray.Create<ISymbol>(conversion.ContainingType, conversion.Parameters.First().Type, conversion.ReturnType);

95var opCharacters = ImmutableArray.CreateRange(filterCharacters);

89symbols: ImmutableArray.Create(member),

67Interlocked.CompareExchange(ref _diagnostics, ImmutableArray.CreateBuilder<Diagnostic>(), null);

77return ImmutableArray.CreateRange(block.Statements);

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

90var builder = ImmutableArray.CreateBuilder<SyntaxNode>();

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

62ImmutableArray.Create(declaration.GetLocation()),

65ImmutableArray.Create(declaration.GetLocation()),

81ImmutableArray.Create(methodDeclaration.GetLocation()),

230var allLocations = ImmutableArray.Create(

58additionalLocations: ImmutableArray.Create(localFunction.GetLocation()),

166additionalLocations: ImmutableArray.Create(additionalLocation),

65additionalLocations: ImmutableArray.Create(additionalLocation),

96additionalLocations: ImmutableArray.Create(initializer.GetLocation()),

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

48ImmutableArray.Create(node.GetLocation()),

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

121var additionalLocations = ImmutableArray.Create(firstStatementLocation); 140var additionalUnnecessaryLocations = ImmutableArray.Create(location);

21siblingStatements = ImmutableArray.CreateRange(block.Statements); 25siblingStatements = ImmutableArray.CreateRange(switchSection.Statements);

70ImmutableArray.Create(subpattern.GetLocation()),

199additionalLocations: ImmutableArray.Create(initializer.GetLocation()), 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(

49var locations = ImmutableArray.Create(invocationExpression.GetLocation()); 60var additionalUnnecessaryLocations = ImmutableArray.Create(

60additionalLocations: ImmutableArray.Create(nodeToReplace.GetLocation()),

105additionalLocations: ImmutableArray.Create(invocation.GetLocation()),

74var locations = ImmutableArray.Create(objectCreationExpression.GetLocation()); 85var 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);

100additionalLocations: ImmutableArray.Create(coalesceExpression.GetLocation()), 173additionalLocations: ImmutableArray.Create(ifStatement.GetLocation()),

13ImmutableArray.Create(

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

78var additionalLocations = ImmutableArray.Create(declaration.GetLocation()); 93var additionalLocations = ImmutableArray.Create(declaration.GetLocation());

63ImmutableArray.Create(objectCreation.GetLocation()),

315var additionalLocations = ImmutableArray.Create(

133var additionalLocations = ImmutableArray.Create(

253var additionalLocations = ImmutableArray.Create(

148var additionalLocations = ImmutableArray.Create(

113var additionalLocations = ImmutableArray.Create(

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

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

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

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

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

78ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Field)), 98ImmutableArray.Create(symbolSpecification), 99ImmutableArray.Create(namingStyle), 100ImmutableArray.Create(namingRule)); 110ImmutableArray.Create(new SymbolKindOrTypeKind(SymbolKind.Field)), 130ImmutableArray.Create(symbolSpecification), 131ImmutableArray.Create(namingStyle), 132ImmutableArray.Create(namingRule)); 142ImmutableArray.Create(new SymbolKindOrTypeKind(SymbolKind.Field)), 144ImmutableArray.Create(new ModifierKind(DeclarationModifiers.Static))); 162ImmutableArray.Create(symbolSpecification), 163ImmutableArray.Create(namingStyle), 164ImmutableArray.Create(namingRule));

4753=> ImmutableArray.Create(new DiagnosticDescriptor(

387ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Parameter)), 407ImmutableArray.Create(symbolSpecification), 408ImmutableArray.Create(namingStyle), 409ImmutableArray.Create(namingRule));

30return base.MassageActions(ImmutableArray.Create(nestedActionForOptionIndex));

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

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

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

36return ImmutableArray.Create(Decsciptor);

61public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor0168, Descriptor0219); 116public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 145=> ImmutableArray.Create<DiagnosticAnalyzer>(new CSharpCompilerDiagnosticAnalyzer()); 184=> ImmutableArray.Create<DiagnosticAnalyzer>(new UserDiagnosticAnalyzer(), new CompilationEndDiagnosticAnalyzer()); 189=> ImmutableArray.Create( 1019=> ImmutableArray.Create<DiagnosticAnalyzer>(new CSharpCompilerDiagnosticAnalyzer(), new UserDiagnosticAnalyzer()); 1300public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 1316=> ImmutableArray.Create<DiagnosticAnalyzer>(new NonLocalDiagnosticsAnalyzer()); 1342=> ImmutableArray.Create<DiagnosticAnalyzer>(new CSharpUseAutoPropertyAnalyzer());

43public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Decsciptor1, Decsciptor2);

699return ImmutableArray.Create(Decsciptor); 809return ImmutableArray.Create(_descriptor); 872return ImmutableArray.Create(_descriptor); 922return ImmutableArray.Create(Decsciptor); 1063return ImmutableArray.Create(Descriptor); 2059public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(_descriptor); 2455=> ImmutableArray.Create(Descriptor);

321KeyValuePairUtil.Create(newDocument.FilePath, ImmutableArray.Create(

2307new("a", ImmutableArray.Create( 2375new("a", ImmutableArray.Create(new SourceLineUpdate(0, 1))), 2376new("b", ImmutableArray.Create(new SourceLineUpdate(0, 1))), 2417new("a", ImmutableArray.Create(new SourceLineUpdate(6, 4))),

45ImmutableArray.Create(MakeLiteral(0), MakeLiteral(1), MakeLiteral(2)), 46ImmutableArray.Create(MakeLiteral(1), MakeLiteral(3))); 77ImmutableArray.Create(PublicKeyword, StaticKeyword, AsyncKeyword), 78ImmutableArray.Create(StaticKeyword, PublicKeyword, AsyncKeyword));

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

164=> ImmutableArray.Create(new DiagnosticDescriptor(

275""", new TestParameters(options: s_options.AccessibilitiesArePascalCase(ImmutableArray.Create(alternateAccessibility)))); 289""", options: s_options.AccessibilitiesArePascalCase(ImmutableArray.Create(accessibility)));

19var items = ImmutableArray.Create("Action1", "Action2"); 31var items = ImmutableArray.Create("Action1", "Action2"); 34items, ImmutableArray.Create("Action1"), a => a); 43var items = ImmutableArray.Create("Action1", "Action2"); 46items, ImmutableArray.Create("Action2"), a => a); 49Assert.Equal((IEnumerable<string>)ImmutableArray.Create("Action2", "Action1"), sorted); 55var items = ImmutableArray.Create("Action1", "Action2"); 58items, ImmutableArray.Create("Action1", "Action2"), a => a); 67var items = ImmutableArray.Create("Action1", "Action2"); 70items, ImmutableArray.Create("Action2", "Action1"), a => a); 73Assert.Equal((IEnumerable<string>)ImmutableArray.Create("Action2", "Action1"), sorted);