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

60incrementalAnalyzerNames: ImmutableArray.Create(AnalyzerName));

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

438 HandleMethodCallHelper (addMethod, instanceValue, ImmutableArray.Create (value), operation, state); 444 HandleMethodCallHelper (removeMethod, instanceValue, ImmutableArray.Create (value), operation, state); 652 return HandleMethodCallHelper (getMethod, instanceValue, ImmutableArray.Create (indexArgumentValue), operation, state);

98 ImmutableArray.Create<(Action<SymbolAnalysisContext> Action, SymbolKind[] SymbolKind)> ((typeDerivesFromRucBase, new SymbolKind[] { SymbolKind.NamedType }));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

349return ImmutableArray.Create(info.Symbol);

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

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

75var trees = ImmutableArray.Create(tree);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

79return ImmutableArray.Create(map(items[0])); 119return ImmutableArray.Create(map(items[0], arg)); 159return ImmutableArray.Create(map(items[0], 0, arg));

179return ImmutableArray.Create(map(items[0], 0, arg)); 494return ImmutableArray.Create(map(self[0], other[0])); 1202? ImmutableArray.Create(symbol) 1203: ImmutableArray<TNamespaceOrTypeSymbol>.CastUp(ImmutableArray.Create((TNamedTypeSymbol)symbol));

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

3101 => ImmutableArray.Create(_item0),

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

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

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

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

300return ImmutableArray.Create(LanguageNames.CSharp);

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

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

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

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

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

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

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

99ImmutableArray.Create(error),

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

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;

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

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

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

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

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

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

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

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

107var additionalLocations = ImmutableArray.Create(

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

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

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

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

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

79return ImmutableArray.Create(map(items[0])); 119return ImmutableArray.Create(map(items[0], arg)); 159return ImmutableArray.Create(map(items[0], 0, arg));

179return ImmutableArray.Create(map(items[0], 0, arg)); 494return ImmutableArray.Create(map(self[0], other[0])); 1202? ImmutableArray.Create(symbol) 1203: ImmutableArray<TNamespaceOrTypeSymbol>.CastUp(ImmutableArray.Create((TNamedTypeSymbol)symbol));

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

3101 => ImmutableArray.Create(_item0),

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

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

27return ImmutableArray.Create(info.Symbol);

221? ImmutableArray.Create(disposeMethod) : default;

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

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

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

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

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

584ImmutableArray.Create(unconvertedInterpolatedString.Parts),

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

303ImmutableArray.Create(state.fromExpression), state.fromExpression.Type); 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); 828return MakeQueryUnboundLambda(qvm, ImmutableArray.Create(parameter), expression, withDependencies); 844return MakeQueryUnboundLambda(expression, new QueryUnboundLambdaState(this, qvm, ImmutableArray.Create(parameter), (LambdaSymbol lambdaSymbol, Binder lambdaBodyBinder, BindingDiagnosticBag diagnostics) => 880return MakeQueryInvocation(node, receiver, methodName, default(SeparatedSyntaxList<TypeSyntax>), default(ImmutableArray<TypeWithAnnotations>), ImmutableArray.Create(arg), diagnostics 906return MakeQueryInvocation(node, receiver, methodName, new SeparatedSyntaxList<TypeSyntax>(new SyntaxNodeOrTokenList(typeArgSyntax, 0)), ImmutableArray.Create(typeArg), ImmutableArray<BoundExpression>.Empty, diagnostics 975receiver = new BoundBadExpression(receiver.Syntax, LookupResultKind.NotAValue, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create(receiver), CreateErrorType()); 997receiver = new BoundBadExpression(receiver.Syntax, LookupResultKind.NotAValue, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create(receiver), CreateErrorType());

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

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

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

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

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

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

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

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

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

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

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

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); 5189? ImmutableArray.Create(symbol)

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

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

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

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

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

35return new MergedNamespaceDeclaration(ImmutableArray.Create(declaration));

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

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

4734return namedType.OriginalDefinition.Construct(ImmutableArray.Create(elementType)); 4889type = TypeWithAnnotations.Create(((NamedTypeSymbol)node.Type).OriginalDefinition.Construct(ImmutableArray.Create(type))); 6427var constructedType = wellKnownType.Construct(ImmutableArray.Create(parameterType)); 9605return compilation.GetSpecialType(SpecialType.System_Nullable_T).Construct(ImmutableArray.Create(underlying)); 11062getEnumeratorType = spanType.Construct(ImmutableArray.Create(convertedResult.Type!.TryGetInlineArrayElementField()!.TypeWithAnnotations));

199ImmutableArray.Create(catchAll), 414ImmutableArray.Create<LocalSymbol>(obj), 442ImmutableArray.Create(ex), 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);

397ImmutableArray.Create<BoundExpression>(instLocal))); 459ImmutableArray.Create(instSymbol),

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

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

1124sideEffects: ImmutableArray.Create<BoundExpression>(rewritten), 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);

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

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

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

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

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

27_parameters = ImmutableArray.Create<ParameterSymbol>(

113ImmutableArray.Create(cachedState) : 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)); 720return block.Update(locals, block.LocalFunctions, block.HasUnsafeModifier, block.Instrumentation, ImmutableArray.Create(statement)); 732ImmutableArray.Create(statement)); 849.Construct(ImmutableArray.Create(elementType)),

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

345ImmutableArray.Create(setterCall),

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

107locals: ImmutableArray.Create(boundTemp.LocalSymbol), 108sideEffects: ImmutableArray.Create<BoundExpression>(tempAssignment), 705return _factory.Sequence(ImmutableArray.Create(temp.LocalSymbol), ImmutableArray.Create<BoundExpression>(tempAssignment), result); 853sideEffects: ImmutableArray.Create<BoundExpression>(nonNull), 1397sideEffects: ImmutableArray.Create<BoundExpression>(sideEffect), 1734locals: ImmutableArray.Create<LocalSymbol>(boundTemp.LocalSymbol), 1735sideEffects: ImmutableArray.Create<BoundExpression>(tempAssignment), 1965sideEffects: ImmutableArray.Create<BoundExpression>(nonNullValue),

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

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

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

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

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), 281locals: ImmutableArray.Create(enumeratorVar), 412statements: ImmutableArray.Create(alwaysOrMaybeDisposeStmt)); 466locals: ImmutableArray.Create(disposableVar), 944indices: ImmutableArray.Create<BoundExpression>(boundPositionVar), 1096ImmutableArray<BoundExpression> dimensionArgument = ImmutableArray.Create( 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), 117exitCallExpr = new BoundBadExpression(lockSyntax, LookupResultKind.NotInvocable, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create<BoundExpression>(boundLockTemp), ErrorTypeSymbol.UnknownResultType); 212enterCallExpr = new BoundBadExpression(lockSyntax, LookupResultKind.NotInvocable, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create<BoundExpression>(boundLockTemp), ErrorTypeSymbol.UnknownResultType); 221ImmutableArray.Create(boundLockTemp.LocalSymbol),

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

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

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

211arguments = ImmutableArray.Create(boundCoalesce.LeftOperand); 729ImmutableArray.Create(temp.LocalSymbol), 730ImmutableArray.Create<BoundExpression>(store),

287: ImmutableArray.Create(HandlerTemp.LocalSymbol);

236locals: ImmutableArray.Create<LocalSymbol>(boundTemp.LocalSymbol), 237sideEffects: ImmutableArray.Create<BoundExpression>(tempAssignment), 550ImmutableArray.Create<BoundExpression>(tempAssignment), 712locals: ImmutableArray.Create<LocalSymbol>(boundTemp.LocalSymbol), 713sideEffects: ImmutableArray.Create<BoundExpression>(tempAssignment),

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

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

97var loweredArguments = ImmutableArray.Create(loweredOperand); 129var loweredArguments = ImmutableArray.Create(loweredOperand);

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

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

831return Call(receiver, method, ImmutableArray.Create(arg0), useStrictArgumentRefKinds); 845=> Call(receiver, WellKnownMethod(method), ImmutableArray.Create(arg0)); 987return MakeSequence(ImmutableArray.Create<LocalSymbol>(temp), parts); 1055=> SwitchSection(ImmutableArray.Create(value), statements); 1538arrayEmpty = arrayEmpty.Construct(ImmutableArray.Create(elementType)); 1550ImmutableArray.Create<BoundExpression>(Literal(elements.Length)), 1559ImmutableArray.Create<BoundExpression>(length), 1595return new BoundCatchBlock(Syntax, ImmutableArray.Create(local), source, source.Type, exceptionFilterPrologueOpt: null, exceptionFilterOpt: null, body: block, isSynthesizedAsyncCatchAll: false); 1845sideEffects: ImmutableArray.Create<BoundExpression>(nonNullValue),

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

30return ImmutableArray.Create(statement);

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

75return new AliasSymbolFromResolvedTarget(targetSymbol, aliasToken.ValueText, containingSymbol, ImmutableArray.Create(aliasToken.GetLocation()), isExtern);

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

24_parameters = ImmutableArray.Create<ParameterSymbol>(

154ImmutableArray.Create(

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

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

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

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(

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

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

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

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

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

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

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

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

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

86return ImmutableArray.Create(this);

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

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

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

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

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

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

1282parameterOrdinals = ImmutableArray.Create(ordinal);

170ImmutableArray.Create<EventSymbol>(explicitlyImplementedEvent);

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

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

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

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

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)); 4351ImmutableArray.Create<ParameterSymbol>(new SignatureOnlyParameterSymbol( 4400ImmutableArray.Create<ParameterSymbol>(new SignatureOnlyParameterSymbol( 4727ImmutableArray.Create<ParameterSymbol>(new SignatureOnlyParameterSymbol(

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

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

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

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

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

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

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

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

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

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

14Parameters = ImmutableArray.Create(

14Parameters = ImmutableArray.Create(

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

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

30Parameters: ImmutableArray.Create<ParameterSymbol>(

24Parameters = ImmutableArray.Create(SynthesizedParameterSymbol.Create(

38Parameters: ImmutableArray.Create<ParameterSymbol>(

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

95Parameters: ImmutableArray.Create<ParameterSymbol>(

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

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

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

21_constructors = ImmutableArray.Create<MethodSymbol>(

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

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

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

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

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

426statements: ImmutableArray.Create<BoundStatement>( 502ImmutableArray.Create<LocalSymbol>(scriptLocal.LocalSymbol), 540_parameters = ImmutableArray.Create(SynthesizedParameterSymbol.Create(this, 590ImmutableArray.Create<BoundExpression>(submissionArrayParameter), 619ImmutableArray.Create<LocalSymbol>(submissionLocal.LocalSymbol),

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

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

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

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

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); 850return elementLocation == null ? ImmutableArray<Location>.Empty : ImmutableArray.Create(elementLocation);

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

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

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

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

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

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

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

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

65additionalLocations: ImmutableArray.Create(additionalLocation),

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

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

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

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

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

199additionalLocations: ImmutableArray.Create(initializer.GetLocation()), 208var locations = ImmutableArray.Create(expression.GetLocation()); 217var additionalUnnecessaryLocations = ImmutableArray.Create(

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

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

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

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

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

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

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

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

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

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

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

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

164=> ImmutableArray.Create(new DiagnosticDescriptor(

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

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))); 14895public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(_rule); 15964return ImmutableArray.Create(Info01); 15991return ImmutableArray.Create(Warning01); 16010public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Warning02);

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

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

315.Returns(ImmutableArray.Create("1.0")); 352.Returns(ImmutableArray.Create("1.0"));

4155MemberNames = ImmutableArray.Create("bar"), 4213MemberNames = ImmutableArray.Create("bar"), 4271MemberNames = ImmutableArray.Create("bar"), 4331MemberNames = ImmutableArray.Create("bar"),

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

968newFileFolderContainers: ImmutableArray.Create("outer"), 1017newFileFolderContainers: ImmutableArray.Create("outer"),

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"); 395var selectedMembers = ImmutableArray.Create("TestMethodBool"); 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"); 1039var selectedMembers = ImmutableArray.Create("TestMethod"); 1094var selectedMembers = ImmutableArray.Create("TestMethod"); 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"); 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"); 3088var selectedMembers = ImmutableArray.Create("Foo"); 3127var selectedMembers = ImmutableArray.Create("Goo");

58var analyzerReference = new AnalyzerImageReference(ImmutableArray.Create<DiagnosticAnalyzer>(analyzer)); 89var analyzerReference = new AnalyzerImageReference(ImmutableArray.Create<DiagnosticAnalyzer>(ideEngineAnalyzer)); 125var analyzerReference = new AnalyzerImageReference(ImmutableArray.Create(analyzer)); 166var options = new AnalyzerOptions(ImmutableArray.Create<AdditionalText>(additionalText)); 168var analyzerReference = new AnalyzerImageReference(ImmutableArray.Create<DiagnosticAnalyzer>(analyzer)); 181var diagnosticService = new HostDiagnosticAnalyzers([new AnalyzerImageReference(ImmutableArray.Create(analyzer))]); 223return ImmutableArray.Create(s_syntaxDiagnosticDescriptor); 294return ImmutableArray.Create(Descriptor); 349=> ImmutableArray.Create(Descriptor); 728nugetAnalyzer != null ? ImmutableArray.Create(nugetAnalyzer) : ImmutableArray<NuGetAnalyzer>.Empty, 730vsixAnalyzer != null ? ImmutableArray.Create(vsixAnalyzer) : ImmutableArray<VsixAnalyzer>.Empty,

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

29return ImmutableArray.Create(_descriptor);

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

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

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

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

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

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

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

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

228ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1))); 234ImmutableArray.Create( 333ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1))); 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( 2754ImmutableArray.Create( 2803ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 3256ImmutableArray.Create( 3495ImmutableArray.Create( 3763ImmutableArray.Create( 3795ImmutableArray.Create( 3888ImmutableArray.Create( 3900ImmutableArray.Create( 3988ImmutableArray.Create( 4040ImmutableArray.Create( 4134ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 4219ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 4301ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 4374ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 4456ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 4639ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 4698ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f0, f1, GetSyntaxMapFromMarkers(source0, source1)))); 4749ImmutableArray.Create(

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

62ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Insert, null, g1))); 241ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Insert, null, f1))); 358ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1))); 460ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1))); 534ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1))); 584ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, method0, method1))); 1134ImmutableArray.Create( 1559ImmutableArray.Create( 2001ImmutableArray.Create( 2006ImmutableArray.Create( 2578ImmutableArray.Create( 2747ImmutableArray.Create( 3286ImmutableArray.Create( 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)))); 7450ImmutableArray.Create( 7817ImmutableArray.Create( 7892ImmutableArray.Create( 8199ImmutableArray.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( 10846ImmutableArray.Create( 10899ImmutableArray.Create( 11029ImmutableArray.Create( 11080ImmutableArray.Create( 11131ImmutableArray.Create( 11185ImmutableArray.Create( 11246ImmutableArray.Create( 11301ImmutableArray.Create( 11368ImmutableArray.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))); 3058ImmutableArray.Create( 3454ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Insert, null, f1))); 3488ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, f1, f2))); 3784ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Insert, null, f3))); 3907ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Update, getP0, getP1))); 3977: ImmutableArray.Create(SemanticEdit.Create(SemanticEditKind.Insert, null, r1))); 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( 6387ImmutableArray.Create( 6465ImmutableArray.Create( 6480ImmutableArray.Create( 6550ImmutableArray.Create( 6565ImmutableArray.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))); 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))); 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))); 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( 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(

442edits: ImmutableArray.Create( 443new SemanticEdit(f0, f1, ImmutableArray.Create(InstrumentationKindExtensions.LocalStateTracing))));

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

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

44return ImmutableArray.Create(s_CA9999_UseOfVariableThatStartsWithX); 239return ImmutableArray.Create(s_descriptor); 506get { return ImmutableArray.Create(desc1); } 658public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get { return ImmutableArray.Create(Rule); } } 800ImmutableArray.Create(SyntaxKind.EqualsValueClause)); 803ImmutableArray.Create(SyntaxKind.BaseConstructorInitializer)); 822}, ImmutableArray.Create(SyntaxKind.ArrowExpressionClause)); 833get { return ImmutableArray.Create(Descriptor1); } 884return ImmutableArray.Create(SupportedDescriptor); 1645get { return ImmutableArray.Create(ExpressionDescriptor); } 2244var syntaxKinds = ImmutableArray.Create(SyntaxKind.VariableDeclaration); 2245var operationKinds = ImmutableArray.Create(OperationKind.VariableDeclarator); 3265var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(new SymbolStartAnalyzer(topLevelAction: false, SymbolKind.NamedType)); 3311var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(new SymbolStartAnalyzer(topLevelAction: false, SymbolKind.NamedType)); 3357var tree1SemanticDiagnostics = await compilationWithAnalyzers.GetAnalyzerSemanticDiagnosticsAsync(semanticModel1, filterSpan: null, ImmutableArray.Create<DiagnosticAnalyzer>(analyzer1), CancellationToken.None); 3694var analyzersToQuery = singleAnalyzer ? ImmutableArray.Create<DiagnosticAnalyzer>(analyzer1) : allAnalyzers; 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); 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); } } 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);

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

18802=> ImmutableArray.Create(Descriptor);

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

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

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

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

169symbols: ImmutableArray.Create(p),

340symbols: ImmutableArray.Create(symbol),

256var additionalFilterTexts = ImmutableArray.Create(staticSymbol.Name); 261symbols: ImmutableArray.Create(staticSymbol),

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

89symbols: ImmutableArray.Create(member),

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

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

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

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

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

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

65additionalLocations: ImmutableArray.Create(additionalLocation),

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

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

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

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

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

199additionalLocations: ImmutableArray.Create(initializer.GetLocation()), 208var locations = ImmutableArray.Create(expression.GetLocation()); 217var additionalUnnecessaryLocations = ImmutableArray.Create(

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

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

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

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

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

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

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

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

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

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

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

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

4753=> ImmutableArray.Create(new DiagnosticDescriptor(

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

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

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

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

36return ImmutableArray.Create(Decsciptor);

116public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 1300public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 1316=> ImmutableArray.Create<DiagnosticAnalyzer>(new NonLocalDiagnosticsAnalyzer());

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

164=> ImmutableArray.Create(new DiagnosticDescriptor(

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

34items, ImmutableArray.Create("Action1"), a => a); 46items, ImmutableArray.Create("Action2"), a => a);

1774=> ImmutableArray.Create(Descriptor);

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

5279var pathMap = ImmutableArray.Create(new KeyValuePair<string, string>(pathPrefix, "/_/")); 5315var pathMap = ImmutableArray.Create(new KeyValuePair<string, string>(pathPrefix, "/_/")); 5349var pathMap = ImmutableArray.Create(new KeyValuePair<string, string>(pathPrefix, "/_/")); 5458var pathMap = ImmutableArray.Create(new KeyValuePair<string, string>(pathPrefix, @"\_\")); 5493var pathMap = ImmutableArray.Create(new KeyValuePair<string, string>(pathPrefix, @"\_/")); 5535var pathMap = ImmutableArray.Create(new KeyValuePair<string, string>(pathPrefix, @"\_/")); 5976var pathMap = ImmutableArray.Create(new KeyValuePair<string, string>(pathPrefix, "/_/")); 6017var pathMap = ImmutableArray.Create(new KeyValuePair<string, string>(pathPrefix, "/_/")); 6079var pathMap = ImmutableArray.Create(new KeyValuePair<string, string>(directory2, "./"));

115877var modifiers = ImmutableArray.Create(CSharpCustomModifier.CreateOptional(comp.GetSpecialType(SpecialType.System_Object)));

5950=> ImmutableArray.Create(Descriptor); 6179=> ImmutableArray.Create(Descriptor); 6275=> ImmutableArray.Create(Descriptor); 6404=> ImmutableArray.Create(Descriptor); 6501=> ImmutableArray.Create(Descriptor); 6559=> ImmutableArray.Create(Descriptor); 6652=> ImmutableArray.Create(Descriptor); 6813=> 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);

181=> ImmutableArray.Create(Descriptor);

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); 78builder.AddEntries(ImmutableArray.Create(1), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 81builder.AddEntries(ImmutableArray.Create(6), EntryState.Added, TimeSpan.Zero, default, EntryState.Added); 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); 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); 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); 311nodeBuilder.AddEntries(ImmutableArray.Create(4), EntryState.Removed, TimeSpan.Zero, emptyInputSteps, EntryState.Removed); 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)); 829var transformNode = new TransformNode<int, int>(inputNode, (i, ct) => ImmutableArray.Create(i)).WithTrackingName("TestStep"); 863var input2Node = new InputNode<int>((_) => ImmutableArray.Create(0)); 940var filterNode = new TransformNode<int, int>(transformNode, (i, ct) => i <= 2 ? ImmutableArray.Create(i) : ImmutableArray<int>.Empty, name: "Filter"); 971var inputNode = new InputNode<ImmutableArray<int>>(_ => ImmutableArray.Create(values)).WithTrackingName("Input"); 1000var inputNode = new InputNode<ImmutableArray<int>>(_ => ImmutableArray.Create(values)).WithTrackingName("Input"); 1028ImmutableArray<ImmutableArray<string>> values = ImmutableArray.Create(ImmutableArray.Create("class1"), ImmutableArray.Create("class2")); 1040values = ImmutableArray.Create(ImmutableArray.Create("class3"), ImmutableArray.Create("class2")); 1048values = ImmutableArray.Create(ImmutableArray.Create("class3"), ImmutableArray.Create("class4")); 1057values = ImmutableArray.Create(ImmutableArray.Create("class1")); 1098values = ImmutableArray.Create(ImmutableArray.Create("class1", "class1.1")); 1295_ => ImmutableArray.Create("1.1")

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

2510ImmutableArray.Create((ITypeSymbol)null), 2523ImmutableArray.Create(true))); 2535memberLocations: ImmutableArray.Create(Location.None))); 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")); 2705Assert.Throws<ArgumentException>(() => comp.CreateAnonymousTypeSymbol(memberTypes, memberNames, memberNullableAnnotations: ImmutableArray.Create(CodeAnalysis.NullableAnnotation.NotAnnotated))); 3639var corlibReference = corlib.EmitToImageReference(aliases: ImmutableArray.Create("corlib")); 3667var otherReference = other.EmitToImageReference(aliases: ImmutableArray.Create("other"));

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

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

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

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

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

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

1534Assert.Throws<ArgumentNullException>("parameterTypes[0]", () => comp.CreateFunctionPointerTypeSymbol(returnType: @string, returnRefKind: RefKind.None, parameterTypes: ImmutableArray.Create((ITypeSymbol?)null)!, parameterRefKinds: ImmutableArray.Create(RefKind.None))); 1536Assert.Throws<ArgumentNullException>("callingConventionTypes[0]", () => comp.CreateFunctionPointerTypeSymbol(returnType: @string, returnRefKind: RefKind.None, parameterTypes: ImmutableArray<ITypeSymbol>.Empty, parameterRefKinds: ImmutableArray<RefKind>.Empty, callingConvention: SignatureCallingConvention.Unmanaged, ImmutableArray.Create((INamedTypeSymbol)null!))); 1537Assert.Throws<ArgumentException>(() => comp.CreateFunctionPointerTypeSymbol(returnType: @string, returnRefKind: RefKind.None, parameterTypes: ImmutableArray<ITypeSymbol>.Empty, parameterRefKinds: ImmutableArray.Create(RefKind.None))); 1540Assert.Throws<ArgumentException>(() => comp.CreateFunctionPointerTypeSymbol(returnType: @string, returnRefKind: RefKind.None, parameterTypes: ImmutableArray<ITypeSymbol>.Empty, parameterRefKinds: ImmutableArray<RefKind>.Empty, callingConvention: SignatureCallingConvention.Default, callingConventionTypes: ImmutableArray.Create(cdeclType)!)); 1541Assert.Throws<ArgumentException>(() => comp.CreateFunctionPointerTypeSymbol(returnType: @string, returnRefKind: RefKind.None, parameterTypes: ImmutableArray<ITypeSymbol>.Empty, parameterRefKinds: ImmutableArray<RefKind>.Empty, callingConvention: SignatureCallingConvention.StdCall, callingConventionTypes: ImmutableArray.Create(cdeclType)!)); 1542Assert.Throws<ArgumentException>(() => comp.CreateFunctionPointerTypeSymbol(returnType: @string, returnRefKind: RefKind.None, parameterTypes: ImmutableArray<ITypeSymbol>.Empty, parameterRefKinds: ImmutableArray<RefKind>.Empty, callingConvention: SignatureCallingConvention.FastCall, callingConventionTypes: ImmutableArray.Create(cdeclType)!)); 1543Assert.Throws<ArgumentException>(() => comp.CreateFunctionPointerTypeSymbol(returnType: @string, returnRefKind: RefKind.None, parameterTypes: ImmutableArray<ITypeSymbol>.Empty, parameterRefKinds: ImmutableArray<RefKind>.Empty, callingConvention: SignatureCallingConvention.CDecl, callingConventionTypes: ImmutableArray.Create(cdeclType)!)); 1544Assert.Throws<ArgumentException>(() => comp.CreateFunctionPointerTypeSymbol(returnType: @string, returnRefKind: RefKind.None, parameterTypes: ImmutableArray<ITypeSymbol>.Empty, parameterRefKinds: ImmutableArray<RefKind>.Empty, callingConvention: SignatureCallingConvention.ThisCall, callingConventionTypes: ImmutableArray.Create(cdeclType)!)); 1545Assert.Throws<ArgumentException>(() => comp.CreateFunctionPointerTypeSymbol(returnType: @string, returnRefKind: RefKind.None, parameterTypes: ImmutableArray<ITypeSymbol>.Empty, parameterRefKinds: ImmutableArray<RefKind>.Empty, callingConvention: SignatureCallingConvention.Unmanaged, callingConventionTypes: ImmutableArray.Create(@string)!)); 1585ImmutableArray.Create((ITypeSymbol)@string), 1586ImmutableArray.Create(RefKind.In)); 1602ImmutableArray.Create((ITypeSymbol)@string), 1603ImmutableArray.Create(RefKind.Out)); 1620ImmutableArray.Create((ITypeSymbol)@string), 1621ImmutableArray.Create(RefKind.Out)); 1658ptr = comp.CreateFunctionPointerTypeSymbol(@string, returnRefKind: RefKind.None, parameterTypes: ImmutableArray<ITypeSymbol>.Empty, parameterRefKinds: ImmutableArray<RefKind>.Empty, SignatureCallingConvention.Unmanaged, ImmutableArray.Create(cdeclType)!); 1987var funcPtrConventionThisCallWithThiscallMod = createTypeSymbol(customModifiers: ImmutableArray.Create(thiscallMod), CallingConvention.ThisCall); 1989var funcPtrThiscall = createTypeSymbol(customModifiers: ImmutableArray.Create(thiscallMod)); 2089var funcPtrCallConv = createTypeSymbol(customModifiers: ImmutableArray.Create(callConvMod)); 2141var funcPtrThiscallOnTypeThiscallOnRef = createTypeSymbol(typeCustomModifiers: ImmutableArray.Create(thiscallMod), refCustomModifiers: ImmutableArray.Create(thiscallMod)); 2142var funcPtrThiscallOnTypeStdcallOnRef = createTypeSymbol(typeCustomModifiers: ImmutableArray.Create(thiscallMod), refCustomModifiers: ImmutableArray.Create(stdcallMod)); 2143var funcPtrStdcallOnTypeThiscallOnRef = createTypeSymbol(typeCustomModifiers: ImmutableArray.Create(stdcallMod), refCustomModifiers: ImmutableArray.Create(thiscallMod));

1919var refA1 = compA1.EmitToImageReference(aliases: ImmutableArray.Create("A")); 1923var refB1 = compB1.EmitToImageReference(aliases: ImmutableArray.Create("B")); 1954comp = CreateCompilation(sourceProgram, references: new[] { refA1, compB2.EmitToImageReference(aliases: ImmutableArray.Create("B")), refBImpl }); 1961comp = CreateCompilation(sourceProgram, references: new[] { refA1, new CSharpCompilationReference(compB2, aliases: ImmutableArray.Create("B")), refBImpl }); 1983var refA1 = compA1.EmitToImageReference(aliases: ImmutableArray.Create("A")); 1987var refB1 = compB1.EmitToImageReference(aliases: ImmutableArray.Create("B")); 2018comp = CreateCompilation(sourceProgram, references: new[] { refA1, compB2.EmitToImageReference(aliases: ImmutableArray.Create("B")), refBImpl }); 2025comp = CreateCompilation(sourceProgram, references: new[] { refA1, new CSharpCompilationReference(compB2, aliases: ImmutableArray.Create("B")), refBImpl });

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

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

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

153var customModifiers = ImmutableArray.Create(CSharpCustomModifier.CreateOptional(intType));

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

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

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

151return ImmutableArray.Create(name);

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

48spans = ImmutableArray.Create(new TextSpan(start, length)); 59spans = ImmutableArray.Create(new TextSpan(0, allCode.Length));

247=> ImmutableArray.Create(_workspace.CurrentSolution.Projects.First().DocumentIds.First());

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

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

22public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 29return Task.FromResult(ImmutableArray.Create(

354return ImmutableArray.Create(new TextChangeRange(new TextSpan(0, oldTextLength), this.Length));

198var generators = ImmutableArray.Create<ISourceGenerator>(generator); 201var codeFixes = ImmutableArray.Create<CodeFixProvider>(codeFix); 293var reference = new MockAnalyzerReference(codefix, ImmutableArray.Create(diagnosticAnalyzer)); 333=> ServiceSetup(ImmutableArray.Create(codefix), includeConfigurationFixProviders, throwExceptionInFixerCreation, additionalDocument, code); 426get { return ImmutableArray.Create(Id); } 452private static readonly ImmutableArray<CodeFixProvider> s_defaultFixers = ImmutableArray.Create<CodeFixProvider>(new MockFixer()); 453private static readonly ImmutableArray<DiagnosticAnalyzer> s_defaultAnalyzers = ImmutableArray.Create<DiagnosticAnalyzer>(new MockDiagnosticAnalyzer()); 468: this(fixer != null ? ImmutableArray.Create(fixer) : ImmutableArray<CodeFixProvider>.Empty, 537: this(ImmutableArray.Create((diagnosticId, category))) 547: this(ImmutableArray.Create(MockFixer.Id)) 580: this(ImmutableArray.Create(MockFixer.Id)) 645var fixableDiagnosticIds = ImmutableArray.Create(MockFixer.Id); 721nugetFixer: new NuGetCodeFixProvider(ImmutableArray.Create(id1)), 722expectedDiagnosticIdsWithRegisteredCodeActionsByNuGetFixer: ImmutableArray.Create(id1), 723vsixFixer: new VsixCodeFixProvider(ImmutableArray.Create(id2)), 724expectedDiagnosticIdsWithRegisteredCodeActionsByVsixFixer: ImmutableArray.Create(id2), 731nugetFixer: new NuGetCodeFixProvider(ImmutableArray.Create(id1)), 732expectedDiagnosticIdsWithRegisteredCodeActionsByNuGetFixer: ImmutableArray.Create(id1), 734expectedDiagnosticIdsWithRegisteredCodeActionsByVsixFixer: ImmutableArray.Create(id2), 777var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(diagnosticAnalyzer); 828var analyzer = new MockAnalyzerReference.MockDiagnosticAnalyzer(ImmutableArray.Create(diagnosticId)); 847public override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(_diagnosticId); 878var analyzerReference = new MockAnalyzerReference(fixers, ImmutableArray.Create<DiagnosticAnalyzer>(analyzer)); 913public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(_descriptor); 940public sealed override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(AdditionalFileAnalyzer.DiagnosticId); 1033var analyzerReference = new MockAnalyzerReference(codeFix, ImmutableArray.Create<DiagnosticAnalyzer>(analyzer)); 1179public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 1220public override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(DeprioritizedAnalyzer.Descriptor.Id);

19get { return ImmutableArray.Create(CodeFixServiceTests.MockFixer.Id); }

18get { return ImmutableArray.Create(CodeFixServiceTests.MockFixer.Id); }

18get { return ImmutableArray.Create(CodeFixServiceTests.MockFixer.Id); }

153thisArguments: ImmutableArray.Create<SyntaxNode>(CS.SyntaxFactory.ParseExpression("42"))); 625typeParameters: ImmutableArray.Create(CodeGenerationSymbolFactory.CreateTypeParameterSymbol("T")), 1465var getMembers = ImmutableArray.Create(getField); 1491var getMembers = ImmutableArray.Create(getField);

162thisArguments: ImmutableArray.Create<SyntaxNode>(VB.SyntaxFactory.ParseExpression("42"))); 472var addStatements = ImmutableArray.Create<SyntaxNode>(VB.SyntaxFactory.ParseExecutableStatement("Console.WriteLine(0)")); 473var removeStatements = ImmutableArray.Create<SyntaxNode>(VB.SyntaxFactory.ParseExecutableStatement("Console.WriteLine(1)")); 474var raiseStatements = ImmutableArray.Create<SyntaxNode>(VB.SyntaxFactory.ParseExecutableStatement("Console.WriteLine(2)")); 593typeParameters: ImmutableArray.Create(CodeGenerationSymbolFactory.CreateTypeParameterSymbol("T")), 1535var getMembers = ImmutableArray.Create(getField);

92=> ImmutableArray.Create(_completionProvider);

163allowableExtensions: ImmutableArray.Create(".cs"),

60var analyzerReference = new AnalyzerImageReference(ImmutableArray.Create<DiagnosticAnalyzer>(new Analyzer())); 81var analyzerReference = new AnalyzerImageReference(ImmutableArray.Create<DiagnosticAnalyzer>(new Analyzer())); 99var analyzerReference = new AnalyzerImageReference(ImmutableArray.Create<DiagnosticAnalyzer>(new Analyzer())); 149var analyzerReference = new AnalyzerImageReference(ImmutableArray.Create<DiagnosticAnalyzer>(new DisabledByDefaultAnalyzer())); 378.AddAnalyzerReference(new AnalyzerImageReference(ImmutableArray.Create(analyzer))) 429var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(analyzer); 746var analyzerReference = new AnalyzerImageReference(ImmutableArray.Create<DiagnosticAnalyzer>(analyzer)); 949public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(s_syntaxRule); 952=> Task.FromResult(ImmutableArray.Create(Diagnostic.Create(s_syntaxRule, Location.Create(document.FilePath, TextSpan.FromBounds(0, 0), new LinePositionSpan(new LinePosition(0, 0), new LinePosition(0, 0)))))); 1011public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(s_syntaxRule); 1016return ImmutableArray.Create(Diagnostic.Create(s_syntaxRule, root.GetLocation())); 1026public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(s_rule); 1037=> _supportedDiagnostics = ImmutableArray.Create(new DiagnosticDescriptor(DiagnosticId, "test", "test", "test", defaultSeverity, isEnabledByDefault: true));

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

69=> new(ReferenceType.Project, projectPath, treatAsUsed, ImmutableArray.Create(Path.ChangeExtension(projectPath, "dll")), dependencies.ToImmutableArray()); 73=> new(ReferenceType.Package, Path.GetFileNameWithoutExtension(assemblyPath), treatAsUsed, ImmutableArray.Create(assemblyPath), dependencies.ToImmutableArray());

185compilationAssemblies: ImmutableArray.Create(assemblyPath), 194compilationAssemblies: ImmutableArray.Create(assemblyPath), 203compilationAssemblies: ImmutableArray.Create(assemblyPath),

45Return ImmutableArray.Create(New TaggedText("", "DisplayText"))

52Dim analyzerReference = New AnalyzerImageReference(ImmutableArray.Create(Of DiagnosticAnalyzer)(workspaceDiagnosticAnalyzer)) 88Dim projectAnalyzerReferences = ImmutableArray.Create(Of AnalyzerReference)(projectAnalyzerReference) 124Dim analyzerReference = New AnalyzerImageReference(ImmutableArray.Create(Of DiagnosticAnalyzer)(workspaceDiagnosticAnalyzer)) 160Dim projectAnalyzerReferences = ImmutableArray.Create(Of AnalyzerReference)(projectAnalyzerReference) 196Return ImmutableArray.Create(DiagDescriptor) 221Return ImmutableArray.Create("TEST0000") 246Return ImmutableArray.Create("TEST1111") 339Return Task.FromResult(ImmutableArray.Create("Title"))

138analyzeReferences = {New AnalyzerImageReference(ImmutableArray.Create(analyzer))}

72Return ImmutableArray.Create(Rule) 108Return ImmutableArray.Create(AdditionalFileAnalyzer.Rule.Id)

284NoCompilationConstants.LanguageName, ImmutableArray.Create(Of DiagnosticAnalyzer)(New NoCompilationDocumentDiagnosticAnalyzer()))

86Dim analyzerReference = New AnalyzerImageReference(ImmutableArray.Create(Of DiagnosticAnalyzer)(workspaceDiagnosticAnalyzer)) 109Dim projectAnalyzers1 = ImmutableArray.Create(Of DiagnosticAnalyzer)(projectDiagnosticAnalyzer1) 111Dim projectAnalyzerReferences1 = ImmutableArray.Create(Of AnalyzerReference)(projectAnalyzerReference1) 125Dim projectAnalyzers2 = ImmutableArray.Create(Of DiagnosticAnalyzer)(projectDiagnosticAnalyzer2) 191Dim analyzerReference = New AnalyzerImageReference(ImmutableArray.Create(Of DiagnosticAnalyzer)(workspaceDiagnosticAnalyzer)) 203Dim projectAnalyzerReferences1 = ImmutableArray.Create(Of AnalyzerReference)(projectAnalyzerReference1) 231ImmutableArray.Create(Of DiagnosticAnalyzer)(New TestDiagnosticAnalyzer1(0)), display:=referenceName) 240ImmutableArray.Create(Of DiagnosticAnalyzer)(New TestDiagnosticAnalyzer1(1)), display:=referenceName) 244project = project.WithAnalyzerReferences(ImmutableArray.Create(Of AnalyzerReference)(projectAnalyzerReference)) 271Dim analyzerReference = New AnalyzerImageReference(ImmutableArray.Create(Of DiagnosticAnalyzer)(workspaceDiagnosticAnalyzer)) 340p1 = p1.WithAnalyzerReferences(SpecializedCollections.SingletonCollection(New AnalyzerImageReference(ImmutableArray.Create(analyzer1)))) 344p2 = p2.WithAnalyzerReferences(SpecializedCollections.SingletonCollection(New AnalyzerImageReference(ImmutableArray.Create(analyzer2)))) 383{LanguageNames.CSharp, ImmutableArray.Create(Of DiagnosticAnalyzer)(analyzer1)}, 384{LanguageNames.VisualBasic, ImmutableArray.Create(Of DiagnosticAnalyzer)(analyzer2)} 464Dim analyzerReference1 = New AnalyzerImageReference(ImmutableArray.Create(Of DiagnosticAnalyzer)(analyzer)) 465Dim analyzerReference2 = New AnalyzerImageReference(ImmutableArray.Create(Of DiagnosticAnalyzer)(analyzer)) 488Dim analyzerReference = New AnalyzerImageReference(ImmutableArray.Create(Of DiagnosticAnalyzer)(analyzer)) 523Dim analyzerReference = New AnalyzerImageReference(ImmutableArray.Create(Of DiagnosticAnalyzer)(analyzer)) 569Dim analyzerReference = New AnalyzerImageReference(ImmutableArray.Create(Of DiagnosticAnalyzer)(analyzer)) 603Dim analyzerReference = New AnalyzerImageReference(ImmutableArray.Create(Of DiagnosticAnalyzer)(analyzer)) 636Dim analyzerReference = New AnalyzerImageReference(ImmutableArray.Create(Of DiagnosticAnalyzer)(analyzer)) 670Dim analyzerReference = New AnalyzerImageReference(ImmutableArray.Create(Of DiagnosticAnalyzer)(analyzer)) 746Dim analyzerReference = New AnalyzerImageReference(ImmutableArray.Create(Of DiagnosticAnalyzer)(analyzer)) 782Dim analyzerReference = New AnalyzerImageReference(ImmutableArray.Create(Of DiagnosticAnalyzer)(analyzer)) 842Dim analyzerReference = New AnalyzerImageReference(ImmutableArray.Create(Of DiagnosticAnalyzer)(analyzer)) 867Dim analyzerReference = New AnalyzerImageReference(ImmutableArray.Create(Of DiagnosticAnalyzer)(analyzer)) 906Dim analyzerReference = New AnalyzerImageReference(ImmutableArray.Create(Of DiagnosticAnalyzer)(analyzer)) 941Dim analyzerReference = New AnalyzerImageReference(ImmutableArray.Create(Of DiagnosticAnalyzer)(analyzer)) 980Dim analyzerReference = New AnalyzerImageReference(ImmutableArray.Create(Of DiagnosticAnalyzer)(analyzer)) 1003Await TestDiagnosticsReportedOnAllPartialDefinitionsCoreAsync(ImmutableArray.Create(Of DiagnosticAnalyzer)(analyzer)) 1088Dim analyzerReference = New AnalyzerImageReference(ImmutableArray.Create(analyzer)) 1131Dim analyzerReference = New AnalyzerImageReference(ImmutableArray.Create(analyzer)) 1174Dim analyzerReference = New AnalyzerImageReference(ImmutableArray.Create(analyzer)) 1226Dim analyzerReference = New AnalyzerImageReference(ImmutableArray.Create(Of DiagnosticAnalyzer)(analyzer)) 1252Return ImmutableArray.Create(Descriptor1) 1289Dim analyzerReference = New AnalyzerImageReference(ImmutableArray.Create(Of DiagnosticAnalyzer)(analyzer)) 1336Dim analyzerReference = New AnalyzerImageReference(ImmutableArray.Create(Of DiagnosticAnalyzer)(analyzer)) 1371Return ImmutableArray.Create(Descriptor1) 1402Dim analyzerReference = New AnalyzerImageReference(ImmutableArray.Create(Of DiagnosticAnalyzer)(analyzer)) 1451Return ImmutableArray.Create(Descriptor) 1539Return ImmutableArray.Create(DiagDescriptor) 1564Return ImmutableArray.Create(DiagDescriptor) 1591Return ImmutableArray.Create(DiagDescriptor) 1616Return ImmutableArray.Create(DiagDescriptor) 1659Return ImmutableArray.Create(Descriptor) 1687Return ImmutableArray.Create(Descriptor) 1713Return ImmutableArray.Create(Descriptor) 1739Return ImmutableArray.Create(Descriptor) 1767Return ImmutableArray.Create(Descriptor) 1880Return ImmutableArray.Create(Descriptor) 1957Dim analyzerReference = New AnalyzerImageReference(ImmutableArray.Create(Of DiagnosticAnalyzer)(analyzer)) 2084Dim analyzerReference = New AnalyzerImageReference(ImmutableArray.Create(Of DiagnosticAnalyzer)(analyzer)) 2123Dim analyzerReference = New AnalyzerImageReference(ImmutableArray.Create(Of DiagnosticAnalyzer)(analyzer)) 2180Dim analyzerReference = New AnalyzerImageReference(ImmutableArray.Create(analyzer)) 2227Dim analyzerReference = New AnalyzerImageReference(ImmutableArray.Create(Of DiagnosticAnalyzer)(analyzer)) 2396Return ImmutableArray.Create(Descriptor) 2432Dim analyzerReference = New AnalyzerImageReference(ImmutableArray.Create(Of DiagnosticAnalyzer)(analyzer)) 2512Return ImmutableArray.Create(s_descriptor)

10919Dim result = ImmutableArray.Create("PythiaRecommendName")

332MockDefaultSource.Defaults = ImmutableArray.Create("FirstDefault") 389MockDefaultSource.Defaults = ImmutableArray.Create("SecondStarred") 459MockDefaultSource.Defaults = ImmutableArray.Create("if") 568MockDefaultSource.Defaults = ImmutableArray.Create("ItemExpanded1") 608MockDefaultSource.Defaults = ImmutableArray.Create("Title")

52ImmutableArray.Create(New TaggedText(TextTags.Text, "Writes the specified string value, followed by the current line terminator, to the standard output stream."))),

224ImmutableArray.Create(type));

246ImmutableArray.Create(type));

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

18=> ImmutableArray.Create(exportAttribute.Language);

18=> ImmutableArray.Create(exportAttribute.Language);

18=> ImmutableArray.Create(exportAttribute.Language);

51public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(_descriptor);

53public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(_descriptor);

48public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(_descriptor);

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

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

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

861Telemetry.LogProjectAnalysisSummary(ProjectAnalysisSummary.ValidChanges, newProject.State.ProjectInfo.Attributes.TelemetryId, ImmutableArray.Create(mvidReadError.Descriptor.Id));

95var fields = ImmutableArray.Create(field);

78ImmutableArray.Create(memberAccessExpression.GetLocation()),

119statements = ImmutableArray.Create(parent);

92editor.ReplaceNode(ifOrElseIf, (currentNode, _) => generator.ScopeBlock(ImmutableArray.Create(currentNode)));

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

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

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

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

107var additionalLocations = ImmutableArray.Create(

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

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

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

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

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

221? ImmutableArray.Create(disposeMethod) : default;

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

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

420_debuggerService.GetCapabilitiesImpl = () => ImmutableArray.Create("Baseline"); 422var openDocumentIds = open ? ImmutableArray.Create(designTimeOnlyDocumentId) : ImmutableArray<DocumentId>.Empty; 453var asSpans = await debuggingSession.GetBaseActiveStatementSpansAsync(solution, ImmutableArray.Create(designTimeOnlyDocumentId), CancellationToken.None); 1978_debuggerService.GetCapabilitiesImpl = () => ImmutableArray.Create("Baseline"); 2066_debuggerService.GetCapabilitiesImpl = () => ImmutableArray.Create("Baseline"); 2101_debuggerService.GetCapabilitiesImpl = () => ImmutableArray.Create("Baseline"); 3133_debuggerService.GetCapabilitiesImpl = () => ImmutableArray.Create("Baseline");

265updatedMethodTokens: ImmutableArray.Create(0x06000004), // contains only recompiled methods in the project we are interested in (module2) 380updatedMethodTokens: ImmutableArray.Create(0x06000001), // F1

87customTags: ImmutableArray.Create("Test2"), 103customTags: ImmutableArray.Create("Test2"), 120customTags: ImmutableArray.Create("Test3"),

148captureMatchingDocuments: ImmutableArray.Create(documentId), 190updatedMethods: ImmutableArray.Create(0x06000001), 191updatedTypes: ImmutableArray.Create(0x02000001), 289mockEncService.GetDocumentDiagnosticsImpl = (document, activeStatementProvider) => ImmutableArray.Create(diagnostic);

79return ImmutableArray.Create(map(items[0])); 119return ImmutableArray.Create(map(items[0], arg)); 159return ImmutableArray.Create(map(items[0], 0, arg));

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

24_analyzerReferences = ImmutableArray.Create<(AnalyzerFileReference reference, string extensionId)>((

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

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

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

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

85return ImmutableArray.Create(codeSnippetsElement);

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

50builder.Add(LanguageNames.VisualBasic, ImmutableArray.Create(DiagnosticExtensions.GetCompilerDiagnosticAnalyzer(LanguageNames.VisualBasic))); 377public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 384return Task.FromResult(ImmutableArray.Create(

129=> ImmutableArray.Create(_descriptor);

93public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(s_descriptor); 105public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(s_descriptor);

132public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(_descriptor); 146public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(_descriptor);

78=> ImmutableArray.Create(_descriptor);

123ImmutableArray.Create(InternalLanguageNames.TypeScript),

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

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

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

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

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

30MetadataReferenceProperties.Assembly.WithAliases(ImmutableArray.Create("<implicit>")); 161return ImmutableArray.Create(result); 170return ImmutableArray.Create(CreateFromFile(resolvedPath, properties)); 181return ImmutableArray.Create(CreateFromFile(path, properties)); 190return ImmutableArray.Create(result);

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

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

31new RelativePathResolver(ImmutableArray.Create(directory.Path), directory.Path), 51searchPaths: ImmutableArray.Create(directory.Path),

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

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

649public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(DiagnosticDescriptor); 679ImmutableArray.Create(Rule); 718ImmutableArray.Create(Rule); 743public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(DummyRule); 760public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule); 785ImmutableArray.Create(Rule); 821public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 832public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create((DiagnosticDescriptor)null); 852public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 873public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 896public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 959public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 998public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule); 1037public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule); 1069public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 1102public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 1136public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 1199public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 1327public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 1385public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 1416public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 1461public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 1562ImmutableArray.Create(ClassDeclarationSyntaxKind)); 1691public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule); 1855public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(ParameterDescriptor); 2169=> ImmutableArray.Create(SuppressionDescriptor); 2231=> ImmutableArray.Create(SuppressionDescriptor); 2274=> ImmutableArray.Create(_descriptor); 2302=> ImmutableArray.Create(_supportedDescriptor); 2334=> ImmutableArray.Create(_supportedDescriptor); 2416public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(_rule); 2482public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 2532public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 2560public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(s_descriptor); 2592public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 2638public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 2679public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(s_descriptor); 2727public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(s_descriptor); 2875public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Descriptor); 2922public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(s_descriptor); 3006public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(s_descriptor); 3096public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(s_descriptor); 3237public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(_descriptor);

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

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

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

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

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

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

76return ImmutableArray.Create(DefaultDiagnostic);

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

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

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

110var set = AnalyzerConfigSet.Create(ImmutableArray.Create(config)); 132var set = AnalyzerConfigSet.Create(ImmutableArray.Create(config)); 2372var set = AnalyzerConfigSet.Create(ImmutableArray.Create(config)); 2387var set = AnalyzerConfigSet.Create(ImmutableArray.Create(config));

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

25a = ImmutableArray.Create<int>(2); 117var singleton1 = ImmutableArray.Create<int>(1); 118var singleton2 = ImmutableArray.Create<int>(2); 145Assert.Equal(1, ImmutableArray.Create<int>(1).Single()); 161Assert.Equal(1, ImmutableArray.Create<int>(1).Single((x, a) => x == a, 1)); 378AssertEx.Equal(new[] { 10 }, ImmutableArray.Create(1).SelectAsArray(i => 10 * i)); 402var single1 = ImmutableArray.Create(1); 403var single2 = ImmutableArray.Create(10); 404var single3 = ImmutableArray.Create(11); 434var single1 = ImmutableArray.Create(1); 435var single2 = ImmutableArray.Create(10); 436var single3 = ImmutableArray.Create(13); 479Assert.True(a.WhereAsArray(i => i == 0).SequenceEqual(ImmutableArray.Create<int>(0))); 481Assert.True(a.WhereAsArray(i => i == 5).SequenceEqual(ImmutableArray.Create<int>(5))); 496Assert.Same(x, ImmutableArray.Create<object>(x).WhereAsArray((o, arg) => o == arg, x)[0]);

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

60var analyzers = ImmutableArray.Create(analyzer);

378return ImmutableArray.Create(_descriptor);

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

654(LocalName: "a", SlotIndex: 1, ScopeStart: 0, ScopeEnd: 0, Names: ImmutableArray.Create("e")),

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

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

47Verify(OneOrMany.Create(ImmutableArray.Create(2)), 2); 50Verify(new OneOrMany<int>(ImmutableArray.Create(2)), 2); 71Verify(OneOrMany.Create(ImmutableArray.Create(1)).Add(4), 1, 4); 72Verify(OneOrMany.Create(ImmutableArray.Create(1)), 1); 85Assert.True(OneOrMany.Create(ImmutableArray.Create(1)).Contains(1)); 86Assert.False(OneOrMany.Create(ImmutableArray.Create(1)).Contains(0)); 110Verify(OneOrMany.Create(ImmutableArray.Create(1)).Select(i => i + 1), 2); 119Verify(OneOrMany.Create(ImmutableArray.Create(1)).Select((i, a) => i + a, 1), 2); 129Assert.Equal(1, OneOrMany.Create(ImmutableArray.Create(1)).FirstOrDefault(i => i < 2)); 130Assert.Equal(0, OneOrMany.Create(ImmutableArray.Create(1)).FirstOrDefault(i => i > 2)); 141Assert.Equal(1, OneOrMany.Create(ImmutableArray.Create(1)).FirstOrDefault((i, a) => i < a, 2)); 142Assert.Equal(0, OneOrMany.Create(ImmutableArray.Create(1)).FirstOrDefault((i, a) => i > a, 2)); 234Assert.True(OneOrMany.Create(1).SequenceEqual(OneOrMany.Create(ImmutableArray.Create(1)))); 255Assert.False(ImmutableArray.Create(1).SequenceEqual(OneOrMany<int>.Empty)); 257Assert.True(ImmutableArray.Create(1).SequenceEqual(OneOrMany.Create(1))); 258Assert.False(ImmutableArray.Create(1).SequenceEqual(OneOrMany.Create(2)));

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

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

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

34ImmutableArray.Create(""), 36ImmutableArray.Create(KeyValuePairUtil.Create<string, string>("key", null))); 46ImmutableArray.Create(""), 48ImmutableArray.Create(KeyValuePairUtil.Create<string, string>("key", ""))); 57ImmutableArray.Create(""), 59ImmutableArray.Create(KeyValuePairUtil.Create<string, string>("key", "value")));

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

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

1271statementList = ImmutableArray.Create(returnstmt)

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

532ImmutableArray.Create(boundInitValue),

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

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

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

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

222ImmutableArray.Create(Of Binder)(intoBinder), 239ImmutableArray.Create(Of Binder)(intoBinder), 272ImmutableArray.Create(Of Binder)(intoBinder), 358ImmutableArray.Create(Of BoundExpression)(letSelectorLambda), 553ImmutableArray.Create(Of BoundExpression)(selectSelectorLambda), 624ImmutableArray.Create(Of BoundExpression)(selectorLambda), 695ImmutableArray.Create(Of BoundExpression)(selectorLambda), 704ImmutableArray.Create(Of Binder)(selectorBinder), 781ImmutableArray.Create(Me), 841ImmutableArray.Create(Of BoundExpression)(selectorLambda), 850ImmutableArray.Create(Of Binder)(selectorBinder), 988ImmutableArray.Create(Me), 996ImmutableArray.Create(Me), 1120lambdaBinders = ImmutableArray.Create(Of Binder)(manySelectorBinder) 1809ImmutableArray.Create(Of BoundExpression)(source).AddRange(groupByArguments), 2386ImmutableArray.Create(Of BoundExpression)(filterLambda), 2395ImmutableArray.Create(Of Binder)(filterBinder), 2494ImmutableArray.Create(boundCount), 2537ImmutableArray.Create(Me), 2607ImmutableArray.Create(Of BoundExpression)(keyLambda), 2626ImmutableArray.Create(Of Binder)(keyBinder), 3948arguments = ImmutableArray.Create(Of BoundExpression)(aggregationLambda) 3956ImmutableArray.Create(m_GroupReference).AddRange(arguments), 3976ImmutableArray.Create(Of Binder)(aggregationBinder), 4295ImmutableArray.Create(Of BoundExpression)(selectorLambda), 4305ImmutableArray.Create(Of Binder)(selectorBinder), 4692childBoundNodes = ImmutableArray.Create(If(methodGroup, source))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

3370Return ImmutableArray.Create(symbol)

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

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

63Return ImmutableArray.Create(loc)

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

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

214Return ImmutableArray.Create(result)

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

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

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

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

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

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

514ImmutableArray.Create(result),

239ImmutableArray.Create(handler),

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

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

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

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

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

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

76ImmutableArray.Create(rewrittenReceiver),

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

128statementList = ImmutableArray.Create(returnstmt)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

3251ImmutableArray.Create(argument1),

77Me._aliasLocations = ImmutableArray.Create(aliasLocation)

73_parameters = ImmutableArray.Create(Of ParameterSymbol)(

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

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

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

183ImmutableArray.Create(value), 212Return ImmutableArray.Create(TypeDescr.Location)

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

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

92_parameters = ImmutableArray.Create(Of ParameterSymbol)(

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

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

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

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

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

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

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

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

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

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

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

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

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

1554ImmutableArray.Create(typedConstantNoStringInterning))) 1610ImmutableArray.Create(typedConstantDebugMode))) 1624AddSynthesizedAttribute(attributes, _compilation.TrySynthesizeAttribute(WellKnownMember.System_Reflection_AssemblyKeyNameAttribute__ctor, ImmutableArray.Create(typedConstant))) 1633AddSynthesizedAttribute(attributes, _compilation.TrySynthesizeAttribute(WellKnownMember.System_Reflection_AssemblyKeyFileAttribute__ctor, ImmutableArray.Create(typedConstant)))

446Return ImmutableArray.Create(_location)

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

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

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

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

199interfaces = ImmutableArray.Create(comClassInterface)

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

61Return ImmutableArray.Create(valueParameter)

453Return ImmutableArray.Create(_location)

340Return ImmutableArray.Create(GetSymbolLocation(_syntaxRef))

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

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

140ImmutableArray.Create(FunctionLocal),

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

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

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

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

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

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

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

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

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

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

224Return TrySynthesizeAttribute(ctor, ImmutableArray.Create(arg))

65Dim additionalLocations = ImmutableArray.Create(member.GetLocation())

62additionalUnnecessaryLocations:=ImmutableArray.Create(syntaxTree.GetLocation(fadeSpan)))) 86additionalUnnecessaryLocations:=ImmutableArray.Create(syntaxTree.GetLocation(fadeSpan))))

76ImmutableArray.Create(notExpression.GetLocation()),

267ImmutableArray.Create(Of ISymbol)(preprocessingSymbol),

605localVariables = ImmutableArray.Create(DirectCast(model.GetDeclaredSymbol(forEach), ILocalSymbol))

28ImmutableArray.Create(BC36556)

25Public Overrides ReadOnly Property FixableDiagnosticIds As ImmutableArray(Of String) = ImmutableArray.Create(BC30561)

22Friend ReadOnly Ids As ImmutableArray(Of String) = ImmutableArray.Create(Of String)(BC37001)

22Friend Shared ReadOnly TooManyArgumentsDiagnosticIds As ImmutableArray(Of String) = ImmutableArray.Create(BC30057)

31Return ImmutableArray.Create(BC30456)

31Return ImmutableArray.Create(BC30311)

90Return ImmutableArray.Create(typeParameter)

25Public Overrides ReadOnly Property FixableDiagnosticIds As ImmutableArray(Of String) = ImmutableArray.Create(BC30149)

66interfaceTypes = ImmutableArray.Create(GetInterfaceType(model, interfaceNode, cancellationToken))

23Friend Shared ReadOnly Ids As ImmutableArray(Of String) = ImmutableArray.Create(BC36942)

25Friend Shared ReadOnly Ids As ImmutableArray(Of String) = ImmutableArray.Create(BC30451)

21Private Shared ReadOnly s_diagnosticIds As ImmutableArray(Of String) = ImmutableArray.Create(BC42356)

23ImmutableArray.Create("BC31411")

23Public Overrides ReadOnly Property FixableDiagnosticIds As ImmutableArray(Of String) = ImmutableArray.Create(BC40046)

21Private Shared ReadOnly s_diagnosticIds As ImmutableArray(Of String) = ImmutableArray.Create(BC42356)

24ImmutableArray.Create(BC30299)

34Return SyntaxFactory.List(ImmutableArray.Create(convertedStatement))

3577AssertEx.Equal(ImmutableArray.Create(sdkPath), parser.ReferencePaths) 3605AssertEx.Equal(ImmutableArray.Create(sdkDir.Path), parser.ReferencePaths) 10986Return ImmutableArray.Create(Hidden01) 11061Return ImmutableArray.Create(Warning04) 11085Return ImmutableArray.Create(Error01) 11106Return ImmutableArray.Create(Rule)

196handlesExpressions:=ImmutableArray.Create(Of SyntaxNode)(handlesSyntax))

52Return New DesktopStrongNameProvider(ImmutableArray.Create(keyFilePath), New VirtualizedStrongNameFileSystem())

6868Dim ex = Assert.Throws(Of ArgumentException)(Function() comp.CreateTupleTypeSymbol(vt2, ImmutableArray.Create("Item1"))) 6873ex = Assert.Throws(Of ArgumentException)(Function() comp.CreateTupleTypeSymbol(vt2, elementLocations:=ImmutableArray.Create(loc1))) 7224Assert.Throws(Of ArgumentException)(Sub() comp.CreateTupleTypeSymbol(elementTypes:=ImmutableArray.Create(intType), elementNames:=Nothing)) 7227Assert.Throws(Of ArgumentException)(Sub() comp.CreateTupleTypeSymbol(elementTypes:=ImmutableArray.Create(intType, intType), elementNames:=ImmutableArray.Create("Item1")))

76Dim peImage = c.EmitToArray(EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage))) 193Dim peImage = c.EmitToArray(EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage))) 293Dim peImage = c.EmitToArray(EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage))) 361Dim peImage = c.EmitToArray(EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage))) 455Dim peImage = c.EmitToArray(EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage))) 560Dim peImage = c.EmitToArray(EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage))) 650Dim peImage = c.EmitToArray(EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage))) 747Dim peImage = c.EmitToArray(EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage)))

1915Dim diagnostics As ImmutableArray(Of Diagnostic) = CreateCompilation(source).GetEmitDiagnostics(EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage))) 2345Dim verifier = CompileAndVerify(c, emitOptions:=EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage))) 2382Dim verifier = CompileAndVerify(c, emitOptions:=EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage))) 2819emitOptions:=EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage))) 2827emitOptions:=EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage))) 2835emitOptions:=EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage)),