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

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

30ImmutableArray.Create(new HealthReportViewModel("Null", null, "Description1", null))), 72ImmutableArray.Create(new HealthReportViewModel("Healthy", HealthStatus.Healthy, "Description2", null)))) 119ImmutableArray.Create(new HealthReportViewModel("Null", null, "Description1", null))), 124ImmutableArray.Create(new HealthReportViewModel("Healthy", HealthStatus.Healthy, "Description2", null))), 129ImmutableArray.Create(new HealthReportViewModel("Degraded", HealthStatus.Degraded, "Description3", null))),

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

622builder = ImmutableArray.CreateBuilder<ResourceCommandSnapshot>(previousState.Commands.Length); 638builder = ImmutableArray.CreateBuilder<ResourceCommandSnapshot>(previousState.Commands.Length);

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

72var ports = ImmutableArray.CreateBuilder<int>(); 168var launchArgsBuilder = ImmutableArray.CreateBuilder<string>(); 169var argsAreSensitiveBuilder = ImmutableArray.CreateBuilder<int>(); 188var urls = ImmutableArray.CreateBuilder<UrlSnapshot>(); 275var environment = ImmutableArray.CreateBuilder<EnvironmentVariableSnapshot>(effectiveSource.Count);

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

368ImmutableArray.Create(name));

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

38 var builder = ImmutableArray.CreateBuilder<MultiValue> (); 59 var argumentsBuilder = ImmutableArray.CreateBuilder<MultiValue> ();

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

129return ImmutableArray.Create(text.Split(["\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))));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

645var additionalLocations = ImmutableArray.Create(

119var locations = ImmutableArray.Create(

123var locations = ImmutableArray.Create(

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

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

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

190var locations = ImmutableArray.Create(

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

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

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

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

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

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

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

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

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

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

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

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

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

52var formattingRules = ImmutableArray.Create(

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")); 1673symbols: ImmutableArray.Create(symbol), 1674childBoundNodes: ImmutableArray.Create(BindToTypeForErrorRecovery(expression)), 4217ImmutableArray.Create(boundExpression.ExpressionSymbol), 4218ImmutableArray.Create(boundExpression)); 4594typeArguments: ImmutableArray.Create(elementTypeWithAnnotations), 5441return new BoundBadExpression(node, LookupResultKind.NotInvocable, StaticCast<Symbol>.From(type.InstanceConstructors), ImmutableArray.Create(argument), type); 5451argument.Syntax, default, WellKnownMemberNames.DelegateInvokeName, ImmutableArray.Create(sourceDelegate.DelegateInvokeMethod), 5585return new BoundBadExpression(node, LookupResultKind.NotCreatable, ImmutableArray.Create<Symbol?>(type), children.ToImmutableAndFree(), type) { WasCompilerGenerated = wasCompilerGenerated }; 6341ImmutableArray.Create(boundElementInitializer), 6569ImmutableArray.Create((BoundExpression)addElementPlaceholder), 7809return new BoundBadExpression(node, LookupResultKind.Ambiguous, lookupResult.Symbols.AsImmutable(), ImmutableArray.Create(boundLeft), CreateErrorType(rightName), hasErrors: true); 7846return new BoundBadExpression(node, lookupResult.Kind, symbols.AsImmutable(), ImmutableArray.Create(boundLeft), CreateErrorType(rightName), hasErrors: true); 8192(object)symbolOpt == null ? ImmutableArray<Symbol>.Empty : ImmutableArray.Create(symbolOpt), 8193boundLeft == null ? ImmutableArray<BoundExpression>.Empty : ImmutableArray.Create(BindToTypeForErrorRecovery(boundLeft)), 9229Construct(ImmutableArray.Create(elementField.TypeWithAnnotations)); 9405var argumentPlaceholders = ImmutableArray.Create(new BoundImplicitIndexerValuePlaceholder(convertedArguments[0].Syntax, int32) { WasCompilerGenerated = true }); 10072argumentPlaceholders = ImmutableArray.Create(intPlaceholder); 10144argumentPlaceholders = ImmutableArray.Create(startArgumentPlaceholder, lengthArgumentPlaceholder); 10151syntax, typeArgumentsOpt: default, method.Name, ImmutableArray.Create(method), 10431methods = 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); 3550return new BoundBlock(node, locals, ImmutableArray.Create(statement)) { WasCompilerGenerated = node.Kind() != SyntaxKind.ArrowExpressionClause }; 4022arguments: 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); 728ImmutableArray.Create(collectionExpr), 845spanType = spanType.Construct(ImmutableArray.Create(elementField.TypeWithAnnotations));

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

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

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

4527return 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) 635return 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),

1482return new BoundBadStatement(body.Syntax, ImmutableArray.Create<BoundNode>(body), hasErrors: true); 1864body = new BoundBlock(constructor.Syntax, constructor.Locals, ImmutableArray.Create<BoundStatement>(constructor.Initializer)); 1868body = new BoundBlock(constructor.Syntax, constructor.Locals, ImmutableArray.Create<BoundStatement>(constructor.Initializer, body)); 1959statements = ImmutableArray.Create(constructorInitializer); 1963statements = 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()));

275private static readonly ImmutableArray<BoundKind> s_skippedExpressions = ImmutableArray.Create(BoundKind.ArrayInitialization, 4791return namedType.OriginalDefinition.Construct(ImmutableArray.Create(elementType)); 4947type = TypeWithAnnotations.Create(((NamedTypeSymbol)node.Type).OriginalDefinition.Construct(ImmutableArray.Create(type))); 6485var constructedType = wellKnownType.Construct(ImmutableArray.Create(parameterType)); 9669return compilation.GetSpecialType(SpecialType.System_Nullable_T).Construct(ImmutableArray.Create(underlying)); 11140getEnumeratorType = 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);

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

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

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

126return block.Update(block.Locals, block.LocalFunctions, block.HasUnsafeModifier, block.Instrumentation, ImmutableArray.Create(InstrumentFieldOrPropertyInitializer(block.Statements.Single(), syntax))); 299ImmutableArray.Create<BoundStatement>(foreachKeywordSequencePoint,

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

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), 711return _factory.Sequence(ImmutableArray.Create(temp.LocalSymbol), ImmutableArray.Create<BoundExpression>(tempAssignment), result); 859sideEffects: ImmutableArray.Create<BoundExpression>(nonNull), 1104locals: ImmutableArray.Create<LocalSymbol>(boundTempX.LocalSymbol, boundTempY.LocalSymbol), 1105sideEffects: ImmutableArray.Create<BoundExpression>(tempAssignmentX, tempAssignmentY), 1293locals: ImmutableArray.Create<LocalSymbol>(boundTempX.LocalSymbol, boundTempY.LocalSymbol), 1294sideEffects: ImmutableArray.Create<BoundExpression>(tempAssignmentX, tempAssignmentY), 1403sideEffects: ImmutableArray.Create<BoundExpression>(sideEffect), 1740locals: ImmutableArray.Create<LocalSymbol>(boundTemp.LocalSymbol), 1741sideEffects: ImmutableArray.Create<BoundExpression>(tempAssignment), 1801locals: ImmutableArray.Create<LocalSymbol>(boundTempX.LocalSymbol, boundTempY.LocalSymbol), 1802sideEffects: ImmutableArray.Create<BoundExpression>(tempAssignmentX, tempAssignmentY), 1889locals: ImmutableArray.Create<LocalSymbol>(boundTempX.LocalSymbol, boundTempY.LocalSymbol), 1890sideEffects: ImmutableArray.Create<BoundExpression>(tempAssignmentX, tempAssignmentY), 1971sideEffects: 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),

158ImmutableArray.Create<BoundExpression>(_factory.Literal(builder.Count)), 1195locals: ImmutableArray.Create(boundTemp.LocalSymbol), 1196sideEffects: ImmutableArray.Create<BoundExpression>(tempAssignment), 1471locals: ImmutableArray.Create(boundTemp.LocalSymbol), 1472sideEffects: ImmutableArray.Create<BoundExpression>(tempAssignment), 1528rewrittenArguments: ImmutableArray.Create(rewrittenOperand)); 1780var result = UserDefinedConversionResult.Valid(ImmutableArray.Create<UserDefinedConversionAnalysis>(analysis), 0); 1880var 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)));

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

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

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

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

463return Block(ImmutableArray.Create(statements)); 468return Block(locals, ImmutableArray.Create(statements)); 478return Block(locals, localFunctions, ImmutableArray.Create(statements)); 503return new BoundStatementList(Syntax, ImmutableArray.Create(first, second)) { WasCompilerGenerated = true }; 839return Call(receiver, method, ImmutableArray.Create(arg0), useStrictArgumentRefKinds); 844return Call(receiver, method, ImmutableArray.Create(arg0, arg1), useStrictArgumentRefKinds); 849return Call(receiver, method, ImmutableArray.Create<BoundExpression>(args)); 853=> Call(receiver, WellKnownMethod(method), ImmutableArray.Create(arg0)); 995return MakeSequence(ImmutableArray.Create<LocalSymbol>(temp), parts); 1063=> SwitchSection(ImmutableArray.Create(value), statements); 1066=> new(values, ImmutableArray.Create(statements)); 1546arrayEmpty = arrayEmpty.Construct(ImmutableArray.Create(elementType)); 1558ImmutableArray.Create<BoundExpression>(Literal(elements.Length)), 1567ImmutableArray.Create<BoundExpression>(length), 1603return new BoundCatchBlock(Syntax, ImmutableArray.Create(local), source, source.Type, exceptionFilterPrologueOpt: null, exceptionFilterOpt: null, body: block, isSynthesizedAsyncCatchAll: false); 1853sideEffects: 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)

175get { 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));

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

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

1015return ImmutableArray.Create(CSharpCustomModifier.CreateOptional(requiresLocationType)); 1026return 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)));

1272parameterOrdinals = 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);

122return ImmutableArray.Create(_location); 133return 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)); 3084return ImmutableArray.Create(InstanceInitializersForPositionalMembers.ToImmutableAndFree()); 4546ImmutableArray.Create<ParameterSymbol>(new SignatureOnlyParameterSymbol( 4595ImmutableArray.Create<ParameterSymbol>(new SignatureOnlyParameterSymbol( 4922ImmutableArray.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()));

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

789=> ImmutableArray.Create(_location); 1063ImmutableArray.Create(arg))); 1069ImmutableArray.Create(arg))); 1075ImmutableArray.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(

1708ImmutableArray.Create( 1715ImmutableArray.Create(new TypedConstant(compilation.GetSpecialType(SpecialType.System_String), TypedConstantKind.Primitive, nameof(CompilerFeatureRequiredFeatures.RefStructs))), 1732ImmutableArray.Create(defaultMemberNameConstant))); 1764ImmutableArray.Create(new TypedConstant(compilation.GetWellKnownType(WellKnownType.System_Type), TypedConstantKind.Type, originalType)), 1910Conversions.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)); 1157var syntaxRefs = ImmutableArray.Create(parameter.GetReference()); 1158var locations = ImmutableArray.Create(location);

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

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

273_lazyRefCustomModifiers = ImmutableArray.Create(CSharpCustomModifier.CreateRequired(modifierType)); 280ImmutableArray.Create(explicitlyImplementedProperty); 531return ImmutableArray.Create(Location); 539return 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( 885? 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>(

243_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); 202arguments: 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)

229var allLocations = ImmutableArray.Create(

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

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

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

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

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

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

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

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

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

12ImmutableArray.Create(

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

314var additionalLocations = ImmutableArray.Create(

133var additionalLocations = ImmutableArray.Create(

253var additionalLocations = ImmutableArray.Create(

147var 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>();

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

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

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

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

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

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

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)); 14898public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(_rule); 15943return ImmutableArray.Create(Hidden01, Hidden02); 15967return ImmutableArray.Create(Info01); 15994return ImmutableArray.Create(Warning01); 16013public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Warning02); 16036return ImmutableArray.Create(Error01, Error02);

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

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

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

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

3010var symbolSpecifications = ImmutableArray.Create( 3023var namingStyles = ImmutableArray.Create(

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

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

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

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

991classificationTypeNames: ImmutableArray.Create(

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

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

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

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

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

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

26305=> ImmutableArray.Create(Descriptor); 26628=> ImmutableArray.Create(Descriptor); 26723=> ImmutableArray.Create(Descriptor); 26888=> ImmutableArray.Create(Descriptor); 27078=> ImmutableArray.Create(Descriptor); 27212=> ImmutableArray.Create(Descriptor); 27392=> ImmutableArray.Create(Descriptor); 27537=> ImmutableArray.Create(Descriptor); 27720=> ImmutableArray.Create(Descriptor);

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

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

525var possibleTypes = ImmutableArray.Create(

200var additionalFilterTexts = ImmutableArray.Create(field.Name); 256var additionalFilterTexts = ImmutableArray.Create(staticSymbol.Name);

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

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

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

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

229var allLocations = ImmutableArray.Create(

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

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

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

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

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

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

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

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

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

12ImmutableArray.Create(

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

314var additionalLocations = ImmutableArray.Create(

133var additionalLocations = ImmutableArray.Create(

253var additionalLocations = ImmutableArray.Create(

147var additionalLocations = ImmutableArray.Create(

113var additionalLocations = ImmutableArray.Create(

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

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

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

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

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

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

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

19var items = ImmutableArray.Create("Action1", "Action2"); 31var items = ImmutableArray.Create("Action1", "Action2"); 43var items = ImmutableArray.Create("Action1", "Action2"); 55var items = ImmutableArray.Create("Action1", "Action2"); 67var items = ImmutableArray.Create("Action1", "Action2");

1774=> ImmutableArray.Create(Descriptor);

15594var funcOfObjectNullable = funcOfT.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(objectType, NullableAnnotation.Annotated))); 15595var funcOfStringNullable = funcOfT.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(stringType, NullableAnnotation.Annotated))); 15596var funcOfStringNotNullable = funcOfT.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(stringType, NullableAnnotation.NotAnnotated)));

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

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

5316var pathMap = ImmutableArray.Create(new KeyValuePair<string, string>(pathPrefix, "/_/")); 5352var pathMap = ImmutableArray.Create(new KeyValuePair<string, string>(pathPrefix, "/_/")); 5386var pathMap = ImmutableArray.Create(new KeyValuePair<string, string>(pathPrefix, "/_/")); 5455var pathMap = ImmutableArray.Create( 5495var pathMap = ImmutableArray.Create(new KeyValuePair<string, string>(pathPrefix, @"\_\")); 5530var pathMap = ImmutableArray.Create(new KeyValuePair<string, string>(pathPrefix, @"\_/")); 5572var pathMap = ImmutableArray.Create(new KeyValuePair<string, string>(pathPrefix, @"\_/")); 6013var pathMap = ImmutableArray.Create(new KeyValuePair<string, string>(pathPrefix, "/_/")); 6054var pathMap = ImmutableArray.Create(new KeyValuePair<string, string>(pathPrefix, "/_/")); 6116var pathMap = ImmutableArray.Create(new KeyValuePair<string, string>(directory2, "./"));

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

113113m1.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(a, NullableAnnotation.Annotated))), 113114m1.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(a, NullableAnnotation.NotAnnotated))), 113115m1.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(a, NullableAnnotation.Oblivious))) 113120m1.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(a, NullableAnnotation.Annotated))), 113121m1.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(a, NullableAnnotation.NotAnnotated))), 113122m1.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(a, NullableAnnotation.Oblivious))) 115795var c2 = cDefinition.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(cDefinition.TypeParameters.Single(), NullableAnnotation.NotAnnotated))); 115807var c3 = cDefinition.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(cDefinition.TypeParameters.Single(), NullableAnnotation.Annotated))); 115837var i1 = iDefinition.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(iDefinition.TypeParameters.Single(), NullableAnnotation.Annotated))); 115846var c2 = cDefinition.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(cDefinition.TypeParameters.Single(), NullableAnnotation.NotAnnotated))); 115858var i2b = i2.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(iDefinition.TypeParameters.Single(), NullableAnnotation.Annotated))); 115863var i2c = i2.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(i2.TypeParameters.Single(), NullableAnnotation.Annotated))); 115867var c3 = cDefinition.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(cDefinition.TypeParameters.Single(), NullableAnnotation.Annotated))); 115872var i3b = i3.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(i3.TypeParameters.Single(), NullableAnnotation.Annotated))); 115877var modifiers = ImmutableArray.Create(CSharpCustomModifier.CreateOptional(comp.GetSpecialType(SpecialType.System_Object))); 115878var c4 = cDefinition.Construct(ImmutableArray.Create(TypeWithAnnotations.Create(cDefinition.TypeParameters.Single(), customModifiers: modifiers)));

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

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

6427=> ImmutableArray.Create(Descriptor); 6526=> ImmutableArray.Create(Descriptor); 6601=> ImmutableArray.Create(Descriptor); 6710=> ImmutableArray.Create(Descriptor); 6791=> ImmutableArray.Create(Descriptor); 6849=> ImmutableArray.Create(Descriptor); 6907=> ImmutableArray.Create(Descriptor); 6975=> ImmutableArray.Create(Descriptor); 7055=> ImmutableArray.Create(Descriptor); 7171=> ImmutableArray.Create(Descriptor); 7265=> ImmutableArray.Create(Descriptor); 7337=> ImmutableArray.Create(Descriptor); 7404=> ImmutableArray.Create(Descriptor);

7876Assert.True(methodGroupSummary.MethodGroup.SetEquals(ImmutableArray.Create<IMethodSymbol>(structMethod1.GetPublicSymbol(), structMethod2.GetPublicSymbol()), EqualityComparer<IMethodSymbol>.Default)); 7922var structMethods = ImmutableArray.Create<MethodSymbol>(structMethod1, structMethod2);

525var editedInputs = ImmutableArray.Create(new AdditionalText[]

181=> ImmutableArray.Create(Descriptor); 827var texts = ImmutableArray.Create<AdditionalText>(new InMemoryAdditionalText("a", "abc"), new InMemoryAdditionalText("b", "def")); 1203GeneratorDriver driver = CSharpGeneratorDriver.Create(ImmutableArray.Create(gen), parseOptions: parseOptions); 1275GeneratorDriver driver = CSharpGeneratorDriver.Create(ImmutableArray.Create(gen), parseOptions: parseOptions); 1826driver = driver.AddAdditionalTexts(ImmutableArray.Create<AdditionalText>(text2)); 4086driver = driver.AddGenerators(ImmutableArray.Create<ISourceGenerator>(generator2)); 4124driver = driver.AddGenerators(ImmutableArray.Create<ISourceGenerator>(generator2)); 4167driver = driver.AddGenerators(ImmutableArray.Create<ISourceGenerator>(generator2));

24builder.AddEntries(ImmutableArray.Create(1), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 25builder.AddEntries(ImmutableArray.Create(2), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 26builder.AddEntries(ImmutableArray.Create(3), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 29var expected = ImmutableArray.Create((1, EntryState.Added, 0), (2, EntryState.Added, 0), (3, EntryState.Added, 0)); 37builder.AddEntries(ImmutableArray.Create(1, 2, 3), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 38builder.AddEntries(ImmutableArray.Create(4, 5, 6), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 39builder.AddEntries(ImmutableArray.Create(7, 8, 9), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 42var expected = ImmutableArray.Create((1, EntryState.Added, 0), (2, EntryState.Added, 1), (3, EntryState.Added, 2), (4, EntryState.Added, 0), (5, EntryState.Added, 1), (6, EntryState.Added, 2), (7, EntryState.Added, 0), (8, EntryState.Added, 1), (9, EntryState.Added, 2)); 52builder.AddEntries(ImmutableArray.Create(o, o, o), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 55var expected = ImmutableArray.Create((o, EntryState.Added, 0), (o, EntryState.Added, 1), (o, EntryState.Added, 2)); 70var expected = ImmutableArray.Create((o, EntryState.Added, 0), (null, EntryState.Added, 0), (o, EntryState.Added, 0)); 78builder.AddEntries(ImmutableArray.Create(1), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 79builder.AddEntries(ImmutableArray.Create(2, 3), EntryState.Cached, TimeSpan.Zero, default, EntryState.Cached); 80builder.AddEntries(ImmutableArray.Create(4, 5), EntryState.Modified, TimeSpan.Zero, default, EntryState.Modified); 81builder.AddEntries(ImmutableArray.Create(6), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 85builder.TryModifyEntries(ImmutableArray.Create(10, 11), TimeSpan.Zero, default, EntryState.Modified); 87builder.TryModifyEntries(ImmutableArray.Create(20, 21, 22), TimeSpan.Zero, default, EntryState.Modified); 91var expected = ImmutableArray.Create((10, EntryState.Modified, 0), (11, EntryState.Added, 1), (2, EntryState.Cached, 0), (3, EntryState.Cached, 1), (20, EntryState.Modified, 0), (21, EntryState.Modified, 1), (22, EntryState.Added, 2), (6, EntryState.Removed, 0)); 109builder.AddEntries(ImmutableArray.Create(1, 2, 3), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 110builder.AddEntries(ImmutableArray.Create(4, 5, 6), EntryState.Removed, TimeSpan.Zero, default, EntryState.Removed); 111builder.AddEntries(ImmutableArray.Create(7, 8, 9), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 114var expected = ImmutableArray.Create((1, EntryState.Added, 0), (2, EntryState.Added, 1), (3, EntryState.Added, 2), (4, EntryState.Removed, 0), (5, EntryState.Removed, 1), (6, EntryState.Removed, 2), (7, EntryState.Added, 0), (8, EntryState.Added, 1), (9, EntryState.Added, 2)); 118expected = ImmutableArray.Create((1, EntryState.Cached, 0), (2, EntryState.Cached, 1), (3, EntryState.Cached, 2), (7, EntryState.Cached, 0), (8, EntryState.Cached, 1), (9, EntryState.Cached, 2)); 126builder.AddEntries(ImmutableArray.Create(1, 2, 3), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 127builder.AddEntries(ImmutableArray.Create(4, 5, 6), EntryState.Removed, TimeSpan.Zero, default, EntryState.Removed); 128builder.AddEntries(ImmutableArray.Create(7, 8, 9), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 131var expected = ImmutableArray.Create((1, EntryState.Added, 0), (2, EntryState.Added, 1), (3, EntryState.Added, 2), (4, EntryState.Removed, 0), (5, EntryState.Removed, 1), (6, EntryState.Removed, 2), (7, EntryState.Added, 0), (8, EntryState.Added, 1), (9, EntryState.Added, 2)); 135expected = ImmutableArray.Create((1, EntryState.Cached, 0), (2, EntryState.Cached, 1), (3, EntryState.Cached, 2), (7, EntryState.Cached, 0), (8, EntryState.Cached, 1), (9, EntryState.Cached, 2)); 147builder.AddEntries(ImmutableArray.Create(1), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 157builder.AddEntries(ImmutableArray.Create(1), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 168builder.AddEntries(ImmutableArray.Create(2), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 179builder.AddEntries(ImmutableArray.Create(1, 2), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 181builder.AddEntries(ImmutableArray.Create(3, 4), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 184var expected = ImmutableArray.Create((1, EntryState.Added, 0), (2, EntryState.Added, 1), (3, EntryState.Added, 0), (4, EntryState.Added, 1)); 188Assert.True(builder.TryModifyEntries(ImmutableArray.Create(3, 2), TimeSpan.Zero, default, EntryState.Modified)); 190Assert.True(builder.TryModifyEntries(ImmutableArray.Create(3, 5), TimeSpan.Zero, default, EntryState.Modified)); 194expected = ImmutableArray.Create((3, EntryState.Modified, 0), (2, EntryState.Cached, 1), (3, EntryState.Cached, 0), (5, EntryState.Modified, 1)); 202builder.AddEntries(ImmutableArray.Create(1), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 203builder.AddEntries(ImmutableArray.Create(2), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 204builder.AddEntries(ImmutableArray.Create(3), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 205builder.AddEntries(ImmutableArray.Create(4), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 208var expected = ImmutableArray.Create((1, EntryState.Added, 0), (2, EntryState.Added, 0), (3, EntryState.Added, 0), (4, EntryState.Added, 0)); 219expected = ImmutableArray.Create((1, EntryState.Cached, 0), (2, EntryState.Cached, 0), (5, EntryState.Modified, 0), (4, EntryState.Cached, 0)); 227builder.AddEntries(ImmutableArray.Create(1), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 228builder.AddEntries(ImmutableArray.Create(2), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 229builder.AddEntries(ImmutableArray.Create(3), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 232var expected = ImmutableArray.Create((1, EntryState.Added, 0), (2, EntryState.Added, 0), (3, EntryState.Added, 0)); 241expected = ImmutableArray.Create((1, EntryState.Cached, 0), (4, EntryState.Modified, 0), (3, EntryState.Cached, 0)); 281nodeBuilder.AddEntries(ImmutableArray.Create(1, 2, 3), EntryState.Cached, TimeSpan.Zero, default, EntryState.Cached); 310nodeBuilder.AddEntries(ImmutableArray.Create(1, 2, 3), EntryState.Added, TimeSpan.Zero, emptyInputSteps, EntryState.Added); 311nodeBuilder.AddEntries(ImmutableArray.Create(4), EntryState.Removed, TimeSpan.Zero, emptyInputSteps, EntryState.Removed); 312nodeBuilder.AddEntries(ImmutableArray.Create(5, 6), EntryState.Modified, TimeSpan.Zero, emptyInputSteps, EntryState.Modified); 372var inputNode = new InputNode<int>((_) => ImmutableArray.Create(1, 2, 3)); 405Assert.Equal(ImmutableArray.Create(1, 2, 3), (IEnumerable<int>)output.Value); 414var inputNode = new InputNode<int>((_) => ImmutableArray.Create(1, 2, 3)); 425AssertTableEntries(table, new[] { (ImmutableArray.Create(1, 2, 3), EntryState.Cached, 0) }); 432var inputNode = new InputNode<int>((_) => ImmutableArray.Create(1, 2, 3)); 468Assert.Equal(ImmutableArray.Create(1, 2, 3), (IEnumerable<int>)output.Value); 477var inputValue = ImmutableArray.Create(1, 2, 3); 486inputValue = ImmutableArray.Create(1, 2); 515Assert.Equal(ImmutableArray.Create(1, 2), (IEnumerable<int>)output.Value); 525var inputNode = new InputNode<int>((_) => ImmutableArray.Create(1, 2, thirdElement++)); 536AssertTableEntries(table, new[] { (ImmutableArray.Create(1, 2, 4), EntryState.Modified, 0) }); 544var inputNode = new InputNode<int>((_) => ImmutableArray.Create(1, 2, thirdElement)); 582Assert.Equal(ImmutableArray.Create(1, 2, 4), (IEnumerable<int>)output.Value); 611AssertTableEntries(table2, new[] { (ImmutableArray.Create("A", "B"), EntryState.Added, 0) }); 612AssertTableEntries(table2.AsCached(), new[] { (ImmutableArray.Create("A", "B"), EntryState.Cached, 0) }); 623AssertTableEntries(table2, new[] { (ImmutableArray.Create("B"), EntryState.Modified, 0) }); 624AssertTableEntries(table2.AsCached(), new[] { (ImmutableArray.Create("B"), EntryState.Cached, 0) }); 631var inputNode = new InputNode<int>((_) => ImmutableArray.Create(1)); 662var inputNode = new InputNode<int>((_) => ImmutableArray.Create(1)); 698var inputNode = new InputNode<int>((_) => ImmutableArray.Create(value)); 737var inputNode = new InputNode<int>((_) => ImmutableArray.Create(value)); 774ImmutableArray<int> inputNodeValue = ImmutableArray.Create(1, 2, 3); 782inputNodeValue = ImmutableArray.Create(1, 4, 5, 6); 827ImmutableArray<int> inputNodeValue = ImmutableArray.Create(1, 2, 3); 829var transformNode = new TransformNode<int, int>(inputNode, (i, ct) => ImmutableArray.Create(i)).WithTrackingName("TestStep"); 836inputNodeValue = ImmutableArray.Create(1, 4, 5, 6); 861ImmutableArray<int> inputNodeValue = ImmutableArray.Create(1, 2, 3); 863var input2Node = new InputNode<int>((_) => ImmutableArray.Create(0)); 871inputNodeValue = ImmutableArray.Create(1, 4, 5, 6); 919var inputNode = new InputNode<int>((_) => ImmutableArray.Create(1, 2, 3)) 937var inputNode = new InputNode<int>((_) => ImmutableArray.Create(1, 2, thirdValue)).WithTrackingName("Input"); 940var filterNode = new TransformNode<int, int>(transformNode, (i, ct) => i <= 2 ? ImmutableArray.Create(i) : ImmutableArray<int>.Empty, name: "Filter"); 970ImmutableArray<int> values = ImmutableArray.Create(1, 2, 3); 971var inputNode = new InputNode<ImmutableArray<int>>(_ => ImmutableArray.Create(values)).WithTrackingName("Input"); 1000var inputNode = new InputNode<ImmutableArray<int>>(_ => ImmutableArray.Create(values)).WithTrackingName("Input"); 1007values = ImmutableArray.Create(1, 2, 3); 1028ImmutableArray<ImmutableArray<string>> values = ImmutableArray.Create(ImmutableArray.Create("class1"), ImmutableArray.Create("class2")); 1035AssertTableEntries(table, ImmutableArray.Create(("class1", EntryState.Added, 0), ("class2", EntryState.Added, 0))); 1037AssertTableEntries(table.AsCached(), ImmutableArray.Create(("class1", EntryState.Cached, 0), ("class2", EntryState.Cached, 0))); 1040values = ImmutableArray.Create(ImmutableArray.Create("class3"), ImmutableArray.Create("class2")); 1044AssertTableEntries(table, ImmutableArray.Create(("class1", EntryState.Removed, 0), ("class2", EntryState.Cached, 0))); 1046AssertTableEntries(table.AsCached(), ImmutableArray.Create(("class2", EntryState.Cached, 0))); 1048values = ImmutableArray.Create(ImmutableArray.Create("class3"), ImmutableArray.Create("class4")); 1052AssertTableEntries(table, ImmutableArray.Create(("class4", EntryState.Modified, 0))); 1054AssertTableEntries(table.AsCached(), ImmutableArray.Create(("class4", EntryState.Cached, 0))); 1057values = ImmutableArray.Create(ImmutableArray.Create("class1")); 1061AssertTableEntries(table, ImmutableArray.Create(("class4", EntryState.Removed, 0), ("class1", EntryState.Added, 0))); 1063AssertTableEntries(table.AsCached(), ImmutableArray.Create(("class1", EntryState.Cached, 0))); 1069ImmutableArray<ImmutableArray<string>> values = ImmutableArray.Create(ImmutableArray.Create("class1", "class1.1"), ImmutableArray.Create("class2", "class2.1")); 1076AssertTableEntries(table, ImmutableArray.Create(("class1", EntryState.Added, 0), ("class1.1", EntryState.Added, 1), ("class2", EntryState.Added, 0), ("class2.1", EntryState.Added, 1))); 1078AssertTableEntries(table.AsCached(), ImmutableArray.Create(("class1", EntryState.Cached, 0), ("class1.1", EntryState.Cached, 1), ("class2", EntryState.Cached, 0), ("class2.1", EntryState.Cached, 1))); 1081values = ImmutableArray.Create(ImmutableArray.Create("class3", "class3.1"), ImmutableArray.Create("class2", "class2.1")); 1085AssertTableEntries(table, ImmutableArray.Create(("class1", EntryState.Removed, 0), ("class1.1", EntryState.Removed, 1), ("class2", EntryState.Cached, 0), ("class2.1", EntryState.Cached, 1))); 1087AssertTableEntries(table.AsCached(), ImmutableArray.Create(("class2", EntryState.Cached, 0), ("class2.1", EntryState.Cached, 1))); 1089values = ImmutableArray.Create(ImmutableArray.Create("class3", "class3.1"), ImmutableArray.Create("class4", "class4.1")); 1093AssertTableEntries(table, ImmutableArray.Create(("class4", EntryState.Modified, 0), ("class4.1", EntryState.Modified, 1))); 1095AssertTableEntries(table.AsCached(), ImmutableArray.Create(("class4", EntryState.Cached, 0), ("class4.1", EntryState.Cached, 1))); 1098values = ImmutableArray.Create(ImmutableArray.Create("class1", "class1.1")); 1102AssertTableEntries(table, ImmutableArray.Create(("class4", EntryState.Removed, 0), ("class4.1", EntryState.Removed, 1), ("class1", EntryState.Added, 0), ("class1.1", EntryState.Added, 1))); 1104AssertTableEntries(table.AsCached(), ImmutableArray.Create(("class1", EntryState.Cached, 0), ("class1.1", EntryState.Cached, 1))); 1110ImmutableArray<string> values = ImmutableArray.Create("1", "2"); 1117"1" => ImmutableArray.Create("1.1", "1.2"), 1118"2" => ImmutableArray.Create("2.1", "2.2"), 1119_ => ImmutableArray.Create("1.1", "inserted", "1.2") 1128AssertTableEntries(table, ImmutableArray.Create(("1.1", EntryState.Added, 0), ("1.2", EntryState.Added, 0), ("2.1", EntryState.Added, 0), ("2.2", EntryState.Added, 0))); 1130AssertTableEntries(table.AsCached(), ImmutableArray.Create(("1.1", EntryState.Cached, 0), ("1.2", EntryState.Cached, 0), ("2.1", EntryState.Cached, 0), ("2.2", EntryState.Cached, 0))); 1133values = ImmutableArray.Create("3", "2"); 1137AssertTableEntries(table, ImmutableArray.Create(("1.1", EntryState.Cached, 0), ("inserted", EntryState.Modified, 0), ("1.2", EntryState.Added, 0), ("2.1", EntryState.Cached, 0), ("2.2", EntryState.Cached, 0))); 1139AssertTableEntries(table.AsCached(), ImmutableArray.Create(("1.1", EntryState.Cached, 0), ("inserted", EntryState.Cached, 0), ("1.2", EntryState.Cached, 0), ("2.1", EntryState.Cached, 0), ("2.2", EntryState.Cached, 0))); 1145ImmutableArray<string> values = ImmutableArray.Create("1", "2"); 1152"1" => ImmutableArray.Create("1.1", "1.2"), 1153"2" => ImmutableArray.Create("2.1", "2.2"), 1154_ => ImmutableArray.Create("inserted", "1.1", "1.2") 1163AssertTableEntries(table, ImmutableArray.Create(("1.1", EntryState.Added, 0), ("1.2", EntryState.Added, 0), ("2.1", EntryState.Added, 0), ("2.2", EntryState.Added, 0))); 1165AssertTableEntries(table.AsCached(), ImmutableArray.Create(("1.1", EntryState.Cached, 0), ("1.2", EntryState.Cached, 0), ("2.1", EntryState.Cached, 0), ("2.2", EntryState.Cached, 0))); 1168values = ImmutableArray.Create("3", "2"); 1172AssertTableEntries(table, ImmutableArray.Create(("inserted", EntryState.Modified, 0), ("1.1", EntryState.Modified, 0), ("1.2", EntryState.Added, 0), ("2.1", EntryState.Cached, 0), ("2.2", EntryState.Cached, 0))); 1174AssertTableEntries(table.AsCached(), ImmutableArray.Create(("inserted", EntryState.Cached, 0), ("1.1", EntryState.Cached, 0), ("1.2", EntryState.Cached, 0), ("2.1", EntryState.Cached, 0), ("2.2", EntryState.Cached, 0))); 1180ImmutableArray<string> values = ImmutableArray.Create("1", "2"); 1187"1" => ImmutableArray.Create("1.1", "1.2"), 1188"2" => ImmutableArray.Create("2.1", "2.2"), 1189_ => ImmutableArray.Create("1.1", "1.2", "inserted") 1198AssertTableEntries(table, ImmutableArray.Create(("1.1", EntryState.Added, 0), ("1.2", EntryState.Added, 0), ("2.1", EntryState.Added, 0), ("2.2", EntryState.Added, 0))); 1200AssertTableEntries(table.AsCached(), ImmutableArray.Create(("1.1", EntryState.Cached, 0), ("1.2", EntryState.Cached, 0), ("2.1", EntryState.Cached, 0), ("2.2", EntryState.Cached, 0))); 1203values = ImmutableArray.Create("3", "2"); 1207AssertTableEntries(table, ImmutableArray.Create(("1.1", EntryState.Cached, 0), ("1.2", EntryState.Cached, 0), ("inserted", EntryState.Added, 0), ("2.1", EntryState.Cached, 0), ("2.2", EntryState.Cached, 0))); 1209AssertTableEntries(table.AsCached(), ImmutableArray.Create(("1.1", EntryState.Cached, 0), ("1.2", EntryState.Cached, 0), ("inserted", EntryState.Cached, 0), ("2.1", EntryState.Cached, 0), ("2.2", EntryState.Cached, 0))); 1215ImmutableArray<string> values = ImmutableArray.Create("1", "2"); 1222"1" => ImmutableArray.Create("1.1", "1.2"), 1223"2" => ImmutableArray.Create("2.1", "2.2"), 1224_ => ImmutableArray.Create("2.1", "inserted", "2.2") 1233AssertTableEntries(table, ImmutableArray.Create(("1.1", EntryState.Added, 0), ("1.2", EntryState.Added, 0), ("2.1", EntryState.Added, 0), ("2.2", EntryState.Added, 0))); 1235AssertTableEntries(table.AsCached(), ImmutableArray.Create(("1.1", EntryState.Cached, 0), ("1.2", EntryState.Cached, 0), ("2.1", EntryState.Cached, 0), ("2.2", EntryState.Cached, 0))); 1238values = ImmutableArray.Create("1", "3"); 1242AssertTableEntries(table, ImmutableArray.Create(("1.1", EntryState.Cached, 0), ("1.2", EntryState.Cached, 0), ("2.1", EntryState.Cached, 0), ("inserted", EntryState.Modified, 0), ("2.2", EntryState.Added, 0))); 1244AssertTableEntries(table.AsCached(), ImmutableArray.Create(("1.1", EntryState.Cached, 0), ("1.2", EntryState.Cached, 0), ("2.1", EntryState.Cached, 0), ("inserted", EntryState.Cached, 0), ("2.2", EntryState.Cached, 0))); 1250ImmutableArray<string> values = ImmutableArray.Create("1", "2", "3"); 1257"1" => ImmutableArray.Create("1.1", "1.2"), 1258"2" => ImmutableArray.Create("2.1", "2.2"), 1259"3" => ImmutableArray.Create("3.1", "3.2"), 1260_ => ImmutableArray.Create("2.1", "inserted", "2.2") 1269AssertTableEntries(table, ImmutableArray.Create(("1.1", EntryState.Added, 0), ("1.2", EntryState.Added, 0), ("2.1", EntryState.Added, 0), ("2.2", EntryState.Added, 0), ("3.1", EntryState.Added, 0), ("3.2", EntryState.Added, 0))); 1271AssertTableEntries(table.AsCached(), ImmutableArray.Create(("1.1", EntryState.Cached, 0), ("1.2", EntryState.Cached, 0), ("2.1", EntryState.Cached, 0), ("2.2", EntryState.Cached, 0), ("3.1", EntryState.Cached, 0), ("3.2", EntryState.Cached, 0))); 1274values = ImmutableArray.Create("1", "4", "3"); 1278AssertTableEntries(table, ImmutableArray.Create(("1.1", EntryState.Cached, 0), ("1.2", EntryState.Cached, 0), ("2.1", EntryState.Cached, 0), ("inserted", EntryState.Modified, 0), ("2.2", EntryState.Added, 0), ("3.1", EntryState.Cached, 0), ("3.2", EntryState.Cached, 0))); 1280AssertTableEntries(table.AsCached(), ImmutableArray.Create(("1.1", EntryState.Cached, 0), ("1.2", EntryState.Cached, 0), ("2.1", EntryState.Cached, 0), ("inserted", EntryState.Cached, 0), ("2.2", EntryState.Cached, 0), ("3.1", EntryState.Cached, 0), ("3.2", EntryState.Cached, 0))); 1286ImmutableArray<string> values = ImmutableArray.Create("1", "2"); 1293"1" => ImmutableArray.Create("1.1", "1.2"), 1294"2" => ImmutableArray.Create("2.1", "2.2"), 1295_ => ImmutableArray.Create("1.1") 1304AssertTableEntries(table, ImmutableArray.Create(("1.1", EntryState.Added, 0), ("1.2", EntryState.Added, 0), ("2.1", EntryState.Added, 0), ("2.2", EntryState.Added, 0))); 1306AssertTableEntries(table.AsCached(), ImmutableArray.Create(("1.1", EntryState.Cached, 0), ("1.2", EntryState.Cached, 0), ("2.1", EntryState.Cached, 0), ("2.2", EntryState.Cached, 0))); 1309values = ImmutableArray.Create("3", "2"); 1313AssertTableEntries(table, ImmutableArray.Create(("1.1", EntryState.Cached, 0), ("1.2", EntryState.Removed, 0), ("2.1", EntryState.Cached, 0), ("2.2", EntryState.Cached, 0))); 1315AssertTableEntries(table.AsCached(), ImmutableArray.Create(("1.1", EntryState.Cached, 0), ("2.1", EntryState.Cached, 0), ("2.2", EntryState.Cached, 0)));

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

617var mtref = refcomp.EmitToImageReference(aliases: ImmutableArray.Create("a", "Alias(*#$@^%*&)")); 685var mtref = refcomp.EmitToImageReference(aliases: ImmutableArray.Create("a", "Alias(*#$@^%*&)")); 2510ImmutableArray.Create((ITypeSymbol)null), 2511ImmutableArray.Create("m1", "m2"))); 2520ImmutableArray.Create((ITypeSymbol)compilation.GetSpecialType(SpecialType.System_Int32), 2522ImmutableArray.Create("m1", "m2"), 2523ImmutableArray.Create(true))); 2532ImmutableArray.Create((ITypeSymbol)compilation.GetSpecialType(SpecialType.System_Int32), 2534ImmutableArray.Create("m1", "m2"), 2535memberLocations: ImmutableArray.Create(Location.None))); 2544ImmutableArray.Create((ITypeSymbol)compilation.GetSpecialType(SpecialType.System_Int32), 2546ImmutableArray.Create("m1", "m2"), 2547ImmutableArray.Create(false, false))); 2556ImmutableArray.Create((ITypeSymbol)compilation.GetSpecialType(SpecialType.System_Int32), 2558ImmutableArray.Create("m1", "m2"), 2559memberLocations: ImmutableArray.Create(Location.None, null))); 2569ImmutableArray.Create("m1"))); 2578ImmutableArray.Create((ITypeSymbol)null), 2588ImmutableArray.Create((ITypeSymbol)null), 2589ImmutableArray.Create("m1"))); 2598ImmutableArray.Create((ITypeSymbol)compilation.GetSpecialType(SpecialType.System_Int32)), 2599ImmutableArray.Create((string)null))); 2607ImmutableArray.Create<ITypeSymbol>(compilation.GetSpecialType(SpecialType.System_Int32)), 2608ImmutableArray.Create("m1")); 2626ImmutableArray.Create<ITypeSymbol>(compilation.GetSpecialType(SpecialType.System_Int32), 2628ImmutableArray.Create("m1", "m2"), 2629memberLocations: ImmutableArray.Create(loc1, loc2)); 2643ImmutableArray.Create<ITypeSymbol>(compilation.GetSpecialType(SpecialType.System_Int32), compilation.GetSpecialType(SpecialType.System_Boolean)), 2644ImmutableArray.Create("m1", "m2")); 2658var memberTypes = ImmutableArray.Create<ITypeSymbol>(comp.GetSpecialType(SpecialType.System_Object), comp.GetSpecialType(SpecialType.System_String)); 2659var memberNames = ImmutableArray.Create("P", "Q"); 2698var memberTypes = ImmutableArray.Create<ITypeSymbol>(comp.GetSpecialType(SpecialType.System_Object), comp.GetSpecialType(SpecialType.System_String)); 2699var memberNames = ImmutableArray.Create("P", "Q"); 2705Assert.Throws<ArgumentException>(() => comp.CreateAnonymousTypeSymbol(memberTypes, memberNames, memberNullableAnnotations: ImmutableArray.Create(CodeAnalysis.NullableAnnotation.NotAnnotated))); 2707type = comp.CreateAnonymousTypeSymbol(memberTypes, memberNames, memberNullableAnnotations: ImmutableArray.Create(CodeAnalysis.NullableAnnotation.NotAnnotated, CodeAnalysis.NullableAnnotation.Annotated)); 3032var typeArguments = ImmutableArray.Create<ITypeSymbol>(comp.GetSpecialType(SpecialType.System_Object), comp.GetSpecialType(SpecialType.System_String)); 3043Assert.Throws<ArgumentException>(() => genericType.Construct(ImmutableArray.Create<ITypeSymbol>(null, null), default)); 3045type = genericType.Construct(typeArguments, ImmutableArray.Create(CodeAnalysis.NullableAnnotation.Annotated, CodeAnalysis.NullableAnnotation.NotAnnotated)); 3052typeArguments = ImmutableArray.Create<ITypeSymbol>(comp.GetSpecialType(SpecialType.System_Object), comp.GetSpecialType(SpecialType.System_String)); 3067var typeArguments = ImmutableArray.Create<ITypeSymbol>(comp.GetSpecialType(SpecialType.System_Object), comp.GetSpecialType(SpecialType.System_String)); 3078Assert.Throws<ArgumentException>(() => genericMethod.Construct(ImmutableArray.Create<ITypeSymbol>(null, null), default)); 3080type = genericMethod.Construct(typeArguments, ImmutableArray.Create(CodeAnalysis.NullableAnnotation.Annotated, CodeAnalysis.NullableAnnotation.NotAnnotated)); 3087typeArguments = ImmutableArray.Create<ITypeSymbol>(comp.GetSpecialType(SpecialType.System_Object), comp.GetSpecialType(SpecialType.System_String)); 3639var corlibReference = corlib.EmitToImageReference(aliases: ImmutableArray.Create("corlib")); 3667var otherReference = other.EmitToImageReference(aliases: ImmutableArray.Create("other"));

81TestHiddenProperty((old, value) => old.WithCryptoPublicKey(value), opt => opt.CryptoPublicKey, ImmutableArray.Create<byte>(0, 1, 2, 3)); 113TestProperty((old, value) => old.WithUsings(value), opt => opt.Usings, ImmutableArray.Create("A", "B")); 119TestProperty((old, value) => old.WithCryptoPublicKey(value), opt => opt.CryptoPublicKey, ImmutableArray.Create<byte>(0, 1, 2, 3));

404return comp.ReplaceReference(reference, reference.WithAliases(ImmutableArray.CreateRange(aliases)));

1457var candidateIndexers = ImmutableArray.Create<ISymbol>(indexerSymbol1, indexerSymbol2);

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

36new SymbolInfo(ImmutableArray.Create<ISymbol>(obj, int32), CandidateReason.Inaccessible), 37new SymbolInfo(ImmutableArray.Create<ISymbol>(obj, int32), CandidateReason.Inaccessible)), 39new SymbolInfo(ImmutableArray.Create<ISymbol>(obj, int32), CandidateReason.Inaccessible), 40new SymbolInfo(ImmutableArray.Create<ISymbol>(obj, int32), CandidateReason.Inaccessible))); 52new SymbolInfo(ImmutableArray.Create<ISymbol>(int32, int32), CandidateReason.Inaccessible), 53new SymbolInfo(ImmutableArray.Create<ISymbol>(int32, int32), CandidateReason.Inaccessible)), 55new SymbolInfo(ImmutableArray.Create<ISymbol>(int32, int32), CandidateReason.Inaccessible), 56new SymbolInfo(ImmutableArray.Create<ISymbol>(obj, int32), CandidateReason.Inaccessible))); 68new SymbolInfo(ImmutableArray.Create<ISymbol>(int32, int32), CandidateReason.Inaccessible), 69new SymbolInfo(ImmutableArray.Create<ISymbol>(int32, int32), CandidateReason.Inaccessible)), 71new SymbolInfo(ImmutableArray.Create<ISymbol>(int32, int32), CandidateReason.Inaccessible), 72new SymbolInfo(ImmutableArray.Create<ISymbol>(int32, int32), CandidateReason.Inaccessible))); 84new SymbolInfo(ImmutableArray.Create<ISymbol>(obj, int32), CandidateReason.Inaccessible), 85new SymbolInfo(ImmutableArray.Create<ISymbol>(int32, int32), CandidateReason.Inaccessible)), 87new SymbolInfo(ImmutableArray.Create<ISymbol>(int32, int32), CandidateReason.Inaccessible), 88new SymbolInfo(ImmutableArray.Create<ISymbol>(int32, int32), CandidateReason.Inaccessible))); 92new SymbolInfo(ImmutableArray.Create<ISymbol>(int32, obj), CandidateReason.Inaccessible), 93new SymbolInfo(ImmutableArray.Create<ISymbol>(int32, int32), CandidateReason.Inaccessible)), 95new SymbolInfo(ImmutableArray.Create<ISymbol>(int32, int32), CandidateReason.Inaccessible), 96new SymbolInfo(ImmutableArray.Create<ISymbol>(int32, int32), CandidateReason.Inaccessible))); 100new SymbolInfo(ImmutableArray.Create<ISymbol>(int32, int32), CandidateReason.Inaccessible), 101new SymbolInfo(ImmutableArray.Create<ISymbol>(obj, int32), CandidateReason.Inaccessible)), 103new SymbolInfo(ImmutableArray.Create<ISymbol>(int32, int32), CandidateReason.Inaccessible), 104new SymbolInfo(ImmutableArray.Create<ISymbol>(int32, int32), CandidateReason.Inaccessible))); 108new SymbolInfo(ImmutableArray.Create<ISymbol>(int32, int32), CandidateReason.Inaccessible), 109new SymbolInfo(ImmutableArray.Create<ISymbol>(int32, obj), CandidateReason.Inaccessible)), 111new SymbolInfo(ImmutableArray.Create<ISymbol>(int32, int32), CandidateReason.Inaccessible), 112new SymbolInfo(ImmutableArray.Create<ISymbol>(int32, int32), CandidateReason.Inaccessible))); 116new SymbolInfo(ImmutableArray.Create<ISymbol>(int32, int32), CandidateReason.Ambiguous), 117new SymbolInfo(ImmutableArray.Create<ISymbol>(int32, int32), CandidateReason.Inaccessible)), 119new SymbolInfo(ImmutableArray.Create<ISymbol>(int32, int32), CandidateReason.Inaccessible), 120new SymbolInfo(ImmutableArray.Create<ISymbol>(int32, int32), CandidateReason.Inaccessible))); 124new SymbolInfo(ImmutableArray.Create<ISymbol>(int32, int32), CandidateReason.Inaccessible), 125new SymbolInfo(ImmutableArray.Create<ISymbol>(int32, int32), CandidateReason.Ambiguous)), 127new SymbolInfo(ImmutableArray.Create<ISymbol>(int32, int32), CandidateReason.Inaccessible), 128new SymbolInfo(ImmutableArray.Create<ISymbol>(int32, int32), CandidateReason.Inaccessible)));