Empty

Binder\Binder.cs (1)

854: new BoundSequence(scopeDesignator, locals, ImmutableArray<BoundExpression>.Empty, expression, getType()) { WasCompilerGenerated = true };

Binder\Binder.IdentifierUsedAsValueFinder.cs (2)

186ImmutableArray<TypeWithAnnotations>.Empty, 187ImmutableArray<RefKind>.Empty,

Binder\Binder.QueryTranslationState.cs (1)

57result.Add(vars, ImmutableArray<string>.Empty);

Binder\Binder.ValueChecks.cs (10)

653(object)otherSymbol == null ? ImmutableArray<Symbol>.Empty : ImmutableArray.Create(otherSymbol), 654receiver == null ? ImmutableArray<BoundExpression>.Empty : ImmutableArray.Create(receiver), 5503ImmutableArray<TypeParameterSymbol>.Empty, 5506ImmutableArray<CustomModifier>.Empty, 5515ImmutableArray<CustomModifier>.Empty, 5516ImmutableArray<MethodSymbol>.Empty); 5543ImmutableArray<TypeParameterSymbol>.Empty, 5546ImmutableArray<CustomModifier>.Empty, 5555ImmutableArray<CustomModifier>.Empty, 5556ImmutableArray<MethodSymbol>.Empty);

Binder\Binder_Attributes.cs (5)

264ImmutableArray<BoundAssignmentOperator> boundNamedArguments = analyzedArguments.NamedArguments?.ToImmutableAndFree() ?? ImmutableArray<BoundAssignmentOperator>.Empty; 763var validatedArguments = ImmutableArray<TypedConstant>.Empty; 802return ImmutableArray<KeyValuePair<string, TypedConstant>>.Empty; 989initializer = ImmutableArray<TypedConstant>.Empty; 995initializer = ImmutableArray<TypedConstant>.Empty;

Binder\Binder_Await.cs (2)

333getAwaiterCall = MakeInvocationExpression(node, expression, WellKnownMemberNames.GetAwaiter, ImmutableArray<BoundExpression>.Empty, diagnostics); 438getAwaiterGetResultCall = MakeInvocationExpression(node, awaiterExpression, WellKnownMemberNames.GetResult, ImmutableArray<BoundExpression>.Empty, diagnostics);

Binder\Binder_Constraints.cs (1)

347return (TypeParameterConstraintClause.Create(constraints, constraintTypes?.ToImmutableAndFree() ?? ImmutableArray<TypeWithAnnotations>.Empty), syntaxBuilder);

Binder\Binder_Crefs.cs (17)

Binder\Binder_Expressions.cs (32)

Binder\Binder_Initializers.cs (2)

51return ImmutableArray<BoundInitializer>.Empty; 132boundInitializers.Add(new BoundFieldEqualsValue(parameterSyntax, fieldSymbol, ImmutableArray<LocalSymbol>.Empty,

Binder\Binder_InterpolatedString.cs (2)

764return (ImmutableArray<ImmutableArray<BoundExpression>>.Empty, false, ImmutableArray<ImmutableArray<(bool IsLiteral, bool HasAlignment, bool HasFormat)>>.Empty, 0, 0);

Binder\Binder_Invocation.cs (5)

51return ImmutableArray<MethodSymbol>.Empty; 348result = BindDynamicInvocation(node, boundExpression, analyzedArguments, ImmutableArray<MethodSymbol>.Empty, diagnostics, queryClause); 1571BoundExpression collection = CreateParamsCollection(node, parameters[paramsIndex], collectionArgs: ImmutableArray<BoundExpression>.Empty, diagnostics); 1775emptyCollection ??= new BoundUnconvertedCollectionExpression(node, ImmutableArray<BoundNode>.CastUp(ImmutableArray<BoundExpression>.Empty)) { WasCompilerGenerated = true, IsParamsArrayOrCollection = true }; 2231var originalMethods = (expr.Kind == BoundKind.MethodGroup) ? ((BoundMethodGroup)expr).Methods : ImmutableArray<MethodSymbol>.Empty;

Binder\Binder_Lookup.cs (6)

1045return ImmutableArray<NamedTypeSymbol>.Empty; 1052return ImmutableArray<NamedTypeSymbol>.Empty; 1305return ImmutableArray<Symbol>.Empty; 1329return ImmutableArray<Symbol>.Empty; 1442diagInfo = diagnose ? new CSDiagnosticInfo(ErrorCode.ERR_BadAccess, new[] { unwrappedSymbol }, unwrappedSymbols, additionalLocations: ImmutableArray<Location>.Empty) : null; 1466diagInfo = new CSDiagnosticInfo(ErrorCode.ERR_BadAccess, new[] { unwrappedSymbol }, ImmutableArray.Create<Symbol>(unwrappedSymbol), additionalLocations: ImmutableArray<Location>.Empty);

Binder\Binder_Operators.cs (2)

1358originalUserDefinedOperators = ImmutableArray<MethodSymbol>.Empty; 1467originalUserDefinedOperators = ImmutableArray<MethodSymbol>.Empty;

Binder\Binder_Patterns.cs (4)

370lengthAccess = new BoundBadExpression(node, LookupResultKind.Empty, ImmutableArray<Symbol?>.Empty, ImmutableArray<BoundExpression>.Empty, CreateErrorType(), hasErrors: true) { WasCompilerGenerated = true }; 988positionalClause, declType, ImmutableArray<TypeWithAnnotations>.Empty, permitDesignations, ref hasErrors, patternsBuilder, diagnostics); 1384addSubpatternsForTuple(ImmutableArray<TypeWithAnnotations>.Empty);

Binder\Binder_Query.cs (8)

Binder\Binder_Statements.cs (17)

146result = new BoundBadStatement(node, ImmutableArray<BoundNode>.Empty, hasErrors: true); 543childNodes = ImmutableArray<BoundNode>.Empty; 1838ImmutableArray<BoundExpression>.Empty); 2770declarations = ImmutableArray<BoundLocalDeclaration>.Empty; 2877return new BoundBadStatement(node, ImmutableArray<BoundNode>.Empty, hasErrors: true); 2888return new BoundBadStatement(node, ImmutableArray<BoundNode>.Empty, hasErrors: true); 3187return ImmutableArray<BoundCatchBlock>.Empty; 3666constructorLocals = ImmutableArray<LocalSymbol>.Empty; 3672blockBody: new BoundBlock(typeDecl, ImmutableArray<LocalSymbol>.Empty, ImmutableArray<BoundStatement>.Empty).MakeCompilerGenerated(), 3932arguments: ImmutableArray<BoundExpression>.Empty, 3933argumentNamesOpt: ImmutableArray<string?>.Empty, 3934argumentRefKindsOpt: ImmutableArray<RefKind>.Empty, 3938argsToParamsOpt: ImmutableArray<int>.Empty, 4014return ImmutableArray<LocalSymbol>.Empty; 4022return ImmutableArray<LocalFunctionSymbol>.Empty; 4030return ImmutableArray<LabelSymbol>.Empty;

Binder\Binder_Symbols.cs (1)

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

Binder\Binder_XmlNameAttribute.cs (2)

25return ImmutableArray<Symbol>.Empty; 36return ImmutableArray<Symbol>.Empty;

Binder\BindingDiagnosticBag.cs (1)

176var info = new CSDiagnosticInfo(code, args, symbols, ImmutableArray<Location>.Empty);

Binder\BlockBinder.cs (1)

55return (labels != null) ? labels.ToImmutableAndFree() : ImmutableArray<LabelSymbol>.Empty;

Binder\EmbeddedStatementBinder.cs (2)

42return locals?.ToImmutableAndFree() ?? ImmutableArray<LocalFunctionSymbol>.Empty; 58return labels?.ToImmutableAndFree() ?? ImmutableArray<LabelSymbol>.Empty;

Binder\FixedStatementBinder.cs (1)

57return ImmutableArray<LocalSymbol>.Empty;

Binder\ForEachLoopBinder.cs (1)

725ImmutableArray<Symbol>.Empty,

Binder\ForLoopBinder.cs (1)

92var innerLocals = ImmutableArray<LocalSymbol>.Empty;

Binder\HostObjectModeBinder.cs (2)

42ImmutableArray<Symbol>.Empty, 43ImmutableArray<Location>.Empty

Binder\Imports.cs (2)

29ImmutableArray<NamespaceOrTypeAndUsingDirective>.Empty, 30ImmutableArray<AliasAndExternAliasDirective>.Empty);

Binder\LocalScopeBinder.cs (4)

50return ImmutableArray<LocalSymbol>.Empty; 68return ImmutableArray<LocalFunctionSymbol>.Empty; 86return ImmutableArray<LabelSymbol>.Empty; 304return locals?.ToImmutableAndFree() ?? ImmutableArray<LocalFunctionSymbol>.Empty;

Binder\MethodArgumentInfo.cs (1)

37return new MethodArgumentInfo(method, arguments: ImmutableArray<BoundExpression>.Empty, defaultArguments: default, expanded: false);

Binder\PatternExplainer.cs (1)

313return map.TryGetValue(temp, out var builder) ? builder.ToImmutable() : ImmutableArray<T>.Empty;

Binder\RefSafetyAnalysis.cs (1)

1082using var _ = new LocalScope(this, ImmutableArray<LocalSymbol>.Empty);

Binder\Semantics\Conversions\Conversion.cs (2)

35conversionResult: UserDefinedConversionResult.NoApplicableOperators(ImmutableArray<UserDefinedConversionAnalysis>.Empty), 1106return ImmutableArray<MethodSymbol>.Empty;

Binder\Semantics\OverloadResolution\OverloadResolution.cs (1)

550return ImmutableArray<Symbol>.Empty;

Binder\Semantics\OverloadResolution\OverloadResolutionResult.cs (1)

1338ImmutableArray<CustomModifier>.Empty,

Binder\SimpleProgramBinder.cs (2)

53return locals?.ToImmutableAndFree() ?? ImmutableArray<LocalFunctionSymbol>.Empty; 76return labels?.ToImmutableAndFree() ?? ImmutableArray<LabelSymbol>.Empty;

Binder\SimpleProgramUnitBinder.cs (1)

46return ImmutableArray<LabelSymbol>.Empty;

Binder\SwitchBinder.cs (2)

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

Binder\WithUsingNamespacesAndTypesBinder.cs (1)

352return Imports.Create(ImmutableDictionary<string, AliasAndUsingDirective>.Empty, _usings, ImmutableArray<AliasAndExternAliasDirective>.Empty);

BoundTree\BoundNewT.cs (1)

13public override ImmutableArray<BoundExpression> Arguments => ImmutableArray<BoundExpression>.Empty;

BoundTree\BoundNoPiaObjectCreationExpression.cs (1)

13public override ImmutableArray<BoundExpression> Arguments => ImmutableArray<BoundExpression>.Empty;

BoundTree\BoundObjectCreationExpression.cs (2)

15: this(syntax, constructor, ImmutableArray<MethodSymbol>.Empty, arguments, argumentNamesOpt, argumentRefKindsOpt, expanded, argsToParamsOpt, defaultArguments, constantValueOpt, initializerExpressionOpt, wasTargetTyped: false, type, hasErrors) 21return this.Update(constructor, ImmutableArray<MethodSymbol>.Empty, arguments, argumentNamesOpt, argumentRefKindsOpt, expanded, argsToParamsOpt, defaultArguments, constantValueOpt, initializerExpressionOpt, this.WasTargetTyped, type);

BoundTree\Constructors.cs (6)

170return Synthesized(syntax, receiverOpt, initialBindingReceiverIsSubjectToCloning: initialBindingReceiverIsSubjectToCloning, method, ImmutableArray<BoundExpression>.Empty); 550: this(syntax, aliasOpt, boundContainingTypeOpt, ImmutableArray<BoundExpression>.Empty, typeWithAnnotations, hasErrors) 656: this(syntax, locals, ImmutableArray<LocalFunctionSymbol>.Empty, hasUnsafeModifier: false, instrumentation: null, statements, hasErrors) 662return new BoundBlock(syntax, ImmutableArray<LocalSymbol>.Empty, ImmutableArray.Create(statement)) 668return new BoundBlock(syntax, ImmutableArray<LocalSymbol>.Empty, statements) { WasCompilerGenerated = true }; 673return new BoundBlock(syntax, ImmutableArray<LocalSymbol>.Empty, statements.AsImmutableOrNull()) { WasCompilerGenerated = true };

BoundTree\Expression.cs (3)

26return ImmutableArray<BoundExpression>.Empty; 133return arrayInitializer?.Initializers ?? ImmutableArray<BoundExpression>.Empty; 170(this.Kind == BoundKind.StatementList || this.Kind == BoundKind.Scope) ? StaticCast<BoundNode?>.From(this.Statements) : ImmutableArray<BoundNode?>.Empty;

BoundTree\Statement.cs (1)

18protected virtual ImmutableArray<BoundNode?> Children => ImmutableArray<BoundNode?>.Empty;

BoundTree\TupleBinaryOperatorInfo.cs (1)

106new Multiple(operators: ImmutableArray<TupleBinaryOperatorInfo>.Empty, leftConvertedTypeOpt: null, rightConvertedTypeOpt: null);

BoundTree\UnboundLambda.cs (11)

239useSiteInfo.AccumulatesDependencies ? useSiteInfo.Dependencies.AsImmutableOrEmpty() : ImmutableArray<AssemblySymbol>.Empty); 949ImmutableArray<DiagnosticInfo>.Empty, 950ImmutableArray<AssemblySymbol>.Empty); 1029public static readonly ReturnInferenceCacheKey Empty = new ReturnInferenceCacheKey(ImmutableArray<TypeWithAnnotations>.Empty, ImmutableArray<RefKind>.Empty, null); 1097parameterTypes = ImmutableArray<TypeWithAnnotations>.Empty; 1098parameterRefKinds = ImmutableArray<RefKind>.Empty; 1183?? rebind(ReallyInferReturnType(delegateType: null, ImmutableArray<TypeWithAnnotations>.Empty, ImmutableArray<RefKind>.Empty)); 1234ImmutableArray<DiagnosticInfo>.Empty, 1235ImmutableArray<AssemblySymbol>.Empty))

CodeGen\CodeGenerator.cs (4)

187dynamicTransformFlags: ImmutableArray<bool>.Empty, 188tupleElementNames: ImmutableArray<string>.Empty, 236asyncYieldPoints = ImmutableArray<int>.Empty; 237asyncResumePoints = ImmutableArray<int>.Empty;

CodeGen\EmitStatement.cs (2)

1760ImmutableArray<bool>.Empty; 1763ImmutableArray<string>.Empty;

CodeGen\Optimizer.cs (2)

1174receiver = typeExpression.Update(aliasOpt: null, boundContainingTypeOpt: null, boundDimensionsOpt: ImmutableArray<BoundExpression>.Empty, 2265receiverOpt = typeExpression.Update(aliasOpt: null, boundContainingTypeOpt: null, boundDimensionsOpt: ImmutableArray<BoundExpression>.Empty,

CommandLine\CSharpCommandLineParser.cs (2)

77ImmutableArray<KeyValuePair<string, string>> pathMap = ImmutableArray<KeyValuePair<string, string>>.Empty; 1953var aliases = (alias != null) ? ImmutableArray.Create(alias) : ImmutableArray<string>.Empty;

CommandLine\CSharpCompiler.cs (1)

148var sourceFileResolver = new LoggingSourceFileResolver(ImmutableArray<string>.Empty, Arguments.BaseDirectory, Arguments.PathMap, touchedFilesLogger);

Compilation\BuiltInOperators.cs (17)

Compilation\CSharpCompilation.cs (8)

429ImmutableArray<SyntaxTree>.Empty, 971syntaxAndDeclarations: syntaxAndDeclarations.WithExternalSyntaxTrees(ImmutableArray<SyntaxTree>.Empty)); 1569var previousSubmissionImports = previousSubmission is object ? Imports.ExpandPreviousSubmissionImports(previousSubmission.GlobalImports, this) : ImmutableArray<NamespaceOrTypeAndUsingDirective>.Empty; 1773ImmutableArray<Symbol>.Empty, 1774ImmutableArray<Location>.Empty 3239return new ReadOnlyBindingDiagnostic<AssemblySymbol>(result.AsImmutable(), ImmutableArray<AssemblySymbol>.Empty); 4073: ImmutableArray<CustomModifier>.Empty; 4782return ImmutableArray<string>.Empty;

Compilation\CSharpCompilation.UsingsFromOptionsAndDiagnostics.cs (1)

19public static readonly UsingsFromOptionsAndDiagnostics Empty = new UsingsFromOptionsAndDiagnostics() { UsingNamespacesOrTypes = ImmutableArray<NamespaceOrTypeAndUsingDirective>.Empty, Diagnostics = null };

Compilation\CSharpSemanticModel.cs (17)

1090: ImmutableArray<ISymbol>.Empty; 1104: ImmutableArray<ISymbol>.Empty; 1118: ImmutableArray<ISymbol>.Empty; 1141: ImmutableArray<IPropertySymbol>.Empty; 1585return ImmutableArray<ISymbol>.Empty; 1597return ImmutableArray<ISymbol>.Empty; 1949return SymbolInfoFactory.Create(ImmutableArray<Symbol>.Empty, LookupResultKind.Empty, isDynamic); 2155conversion = Conversion.MakeConditionalExpression(ImmutableArray<Conversion>.Empty); 2288return ImmutableArray<Symbol>.Empty; 2305return ImmutableArray<IPropertySymbol>.Empty; 3350memberGroup = ImmutableArray<Symbol>.Empty; 4054candidateConstructors = ImmutableArray<MethodSymbol>.Empty; 4089return ImmutableArray<IPropertySymbol>.Empty; 4099return ImmutableArray<IPropertySymbol>.Empty; 5005return ImmutableArray<ISymbol>.Empty; 5183: ImmutableArray<ISymbol>.Empty; 5416xmlNamespaces: ImmutableArray<ImportedXmlNamespace>.Empty));

Compilation\DeconstructionInfo.cs (2)

66return ImmutableArray<DeconstructionInfo>.Empty; 72? ImmutableArray<DeconstructionInfo>.Empty

Compilation\SyntaxAndDeclarationManager.cs (1)

400oldLoadDirectives = ImmutableArray<LoadDirective>.Empty;

Compilation\SyntaxTreeSemanticModel.cs (2)

403return model == null ? ImmutableArray<Symbol>.Empty : model.GetMemberGroupWorker(node, options, cancellationToken); 412return model == null ? ImmutableArray<IPropertySymbol>.Empty : model.GetIndexerGroupWorker(node, options, cancellationToken);

Compilation\SyntaxTreeSemanticModel_RegionAnalysisContext.cs (2)

34var node = new BoundBadStatement(expression, ImmutableArray<BoundNode>.Empty, hasErrors: true); 51var node = new BoundBadStatement(firstStatement, ImmutableArray<BoundNode>.Empty, hasErrors: true);

Compiler\DocumentationCommentCompiler.cs (3)

632return ImmutableArray<ParameterSymbol>.Empty; 648return ImmutableArray<TypeParameterSymbol>.Empty; 727nodes = ImmutableArray<DocumentationCommentTriviaSyntax>.Empty;

Compiler\DocumentationCommentCompiler.IncludeElementExpander.cs (1)

558ImmutableArray<ParameterSymbol> parameters = ImmutableArray<ParameterSymbol>.Empty;

Compiler\MethodBodySynthesizer.cs (7)

48arguments: ImmutableArray<BoundExpression>.Empty, 49argumentNamesOpt: ImmutableArray<string>.Empty, 50argumentRefKindsOpt: ImmutableArray<RefKind>.Empty, 54argsToParamsOpt: ImmutableArray<int>.Empty, 565ImmutableArray<LocalSymbol>.Empty, 570ImmutableArray<BoundCatchBlock>.Empty, 573ImmutableArray<LocalSymbol>.Empty,

Compiler\MethodCompiler.cs (19)

308ImmutableArray<EncLambdaInfo>.Empty, 309ImmutableArray<LambdaRuntimeRudeEditInfo>.Empty, 310ImmutableArray<EncClosureInfo>.Empty, 311ImmutableArray<StateMachineStateDebugInfo>.Empty, 318codeCoverageSpans: ImmutableArray<SourceSpan>.Empty, 638var processedInitializers = new Binder.ProcessedFieldInitializers() { BoundInitializers = ImmutableArray<BoundInitializer>.Empty }; 765ImmutableArray<EncLambdaInfo>.Empty, 766ImmutableArray<LambdaRuntimeRudeEditInfo>.Empty, 767ImmutableArray<EncClosureInfo>.Empty, 775codeCoverageSpans: ImmutableArray<SourceSpan>.Empty, 900sourceMethod.SetDiagnostics(ImmutableArray<Diagnostic>.Empty, out diagsWritten); 961body = new BoundBlock(methodSymbol.GetNonNullSyntaxNode(), ImmutableArray<LocalSymbol>.Empty, ImmutableArray<BoundStatement>.Empty) { WasCompilerGenerated = true }; 1004new BoundBlock(analyzedInitializers.Syntax, ImmutableArray<LocalSymbol>.Empty, analyzedInitializers.Statements), // The block is necessary to establish the right local scope for the analysis 1198codeCoverageSpans = ImmutableArray<SourceSpan>.Empty; 1222boundStatements = ImmutableArray<BoundStatement>.Empty; 1384codeCoverageSpans = ImmutableArray<SourceSpan>.Empty; 1476codeCoverageSpans = ImmutableArray<SourceSpan>.Empty; 1951statements = ImmutableArray<BoundStatement>.Empty;

CSharpCompilationOptions.cs (1)

347value = ImmutableArray<byte>.Empty;

CSharpParseOptions.cs (2)

124symbols = ImmutableArray<string>.Empty; 192: ImmutableArray<ImmutableArray<string>>.Empty;

Declarations\DeclarationTreeBuilder.cs (13)

134return ImmutableArray<SingleNamespaceOrTypeDeclaration>.Empty; 190var diagnostics = ImmutableArray<Diagnostic>.Empty; 227children: ImmutableArray<SingleTypeDeclaration>.Empty, 228diagnostics: ImmutableArray<Diagnostic>.Empty, 255children: ImmutableArray<SingleTypeDeclaration>.Empty, 309return ImmutableArray<ReferenceDirective>.Empty; 343diagnostics: ImmutableArray<Diagnostic>.Empty, 355diagnostics: ImmutableArray<Diagnostic>.Empty); 469referenceDirectives: isForScript ? GetReferenceDirectives(compilationUnit) : ImmutableArray<ReferenceDirective>.Empty, 516diagnostics: ImmutableArray<Diagnostic>.Empty); 787return ImmutableArray<SingleTypeDeclaration>.Empty; 826children: ImmutableArray<SingleTypeDeclaration>.Empty, 864children: ImmutableArray<SingleTypeDeclaration>.Empty,

DocumentationComments\SourceDocumentationCommentUtils.cs (2)

37return ImmutableArray<DocumentationCommentTriviaSyntax>.Empty; 112return ImmutableArray<DocumentationCommentTriviaSyntax>.Empty;

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (2)

399var otherParameterTypes = ImmutableArray<TypeWithAnnotations>.Empty; 916var translatedParameterTypes = ImmutableArray<TypeWithAnnotations>.Empty;

Emitter\Model\AttributeDataAdapter.cs (3)

24return ImmutableArray<Cci.IMetadataExpression>.Empty; 61return ImmutableArray<Cci.IMetadataNamedArgument>.Empty; 129ImmutableArray<Cci.IMetadataExpression>.Empty);

Emitter\Model\MethodReference.cs (1)

67return ImmutableArray<Cci.IParameterTypeInformation>.Empty;

Emitter\Model\MethodSymbolAdapter.cs (1)

178return ImmutableArray<Cci.IParameterTypeInformation>.Empty;

Emitter\Model\ParameterTypeInformation.cs (2)

97get { return ImmutableArray<Cci.ICustomModifier>.Empty; } 107get { return ImmutableArray<Cci.ICustomModifier>.Empty; }

Emitter\Model\PEAssemblyBuilder.cs (19)

Emitter\Model\PEModuleBuilder.cs (4)

147public sealed override ImmutableArray<Cci.UsedNamespaceOrType> GetImports() => ImmutableArray<Cci.UsedNamespaceOrType>.Empty; 510return ImmutableArray<AnonymousTypeKey>.Empty; 515return ImmutableArray<SynthesizedDelegateKey>.Empty; 1658attribute = SynthesizeNativeIntegerAttribute(WellKnownMember.System_Runtime_CompilerServices_NativeIntegerAttribute__ctor, ImmutableArray<TypedConstant>.Empty);

Emitter\Model\SynthesizedPrivateImplementationDetailsStaticConstructor.cs (1)

21this.SetParameters(ImmutableArray<ParameterSymbol>.Empty);

Emitter\NoPia\EmbeddedType.cs (3)

263return SynthesizedAttributeData.Create(TypeManager.ModuleBeingBuilt.Compilation, ctor, ImmutableArray<TypedConstant>.Empty, ImmutableArray<KeyValuePair<string, TypedConstant>>.Empty); 283ImmutableArray<KeyValuePair<string, TypedConstant>>.Empty);

Emitter\NoPia\EmbeddedTypesManager.cs (2)

140ImmutableArray<KeyValuePair<string, TypedConstant>>.Empty); 149ImmutableArray<KeyValuePair<string, TypedConstant>>.Empty);

Errors\CSDiagnosticInfo.cs (5)

23: this(code, Array.Empty<object>(), ImmutableArray<Symbol>.Empty, ImmutableArray<Location>.Empty) 28: this(code, args, ImmutableArray<Symbol>.Empty, ImmutableArray<Location>.Empty) 33: this(code, args, symbols, ImmutableArray<Location>.Empty)

Errors\DiagnosticBagExtensions.cs (1)

47var info = new CSDiagnosticInfo(code, args, symbols, ImmutableArray<Location>.Empty);

Errors\MessageProvider.cs (2)

89var info = new CSDiagnosticInfo((ErrorCode)code, args, ImmutableArray<Symbol>.Empty, ImmutableArray<Location>.Empty);

FlowAnalysis\AbstractFlowPass.cs (1)

471return (object)method == null ? ImmutableArray<ParameterSymbol>.Empty : method.Parameters;

FlowAnalysis\ControlFlowAnalysis.cs (2)

45var result = _context.Failed ? ImmutableArray<SyntaxNode>.Empty : 65: ImmutableArray<SyntaxNode>.Empty;

FlowAnalysis\CSharpDataFlowAnalysis.cs (6)

68: ImmutableArray<ISymbol>.Empty; 102var result = _context.Failed ? ImmutableArray<ISymbol>.Empty : 132var entryResult = ImmutableArray<ISymbol>.Empty; 133var exitResult = ImmutableArray<ISymbol>.Empty; 161: ImmutableArray<ISymbol>.Empty; 180: ImmutableArray<ISymbol>.Empty;

FlowAnalysis\ExitPointsWalker.cs (1)

63return ImmutableArray<StatementSyntax>.Empty;

FlowAnalysis\FlowAnalysisPass.cs (2)

86block = new BoundBlock(block.Syntax, ImmutableArray<LocalSymbol>.Empty, newStatements) { WasCompilerGenerated = true }; 176return body.Update(body.Locals, ImmutableArray<LocalFunctionSymbol>.Empty, body.HasUnsafeModifier, body.Instrumentation, builder.ToImmutableAndFree());

FlowAnalysis\NullableWalker.cs (9)

656: ImmutableArray<string>.Empty; 681checkMemberStateOnConstructorExit(method, member, state, thisSlot, exitLocation, membersWithStateEnforcedByRequiredMembers: ImmutableArray<string>.Empty, forcePropertyAnalysis: true); 789var info = new CSDiagnosticInfo(errorCode, new object[] { symbol.Kind.Localize(), symbol.Name }, ImmutableArray<Symbol>.Empty, additionalLocations: symbol.Locations); 972return ImmutableArray<Symbol>.Empty; 1017=> ImmutableArray<Symbol>.Empty, 5437_ => ImmutableArray<NamedTypeSymbol>.Empty, 7106return ImmutableArray<VisitResult>.Empty; 8743_ => (null, ImmutableArray<ParameterSymbol>.Empty), 11872VisitArguments(node, node.ConstructorArguments, ImmutableArray<RefKind>.Empty, node.Constructor, argsToParamsOpt: node.ConstructorArgumentsToParamsOpt, defaultArguments: node.ConstructorDefaultArguments,

FlowAnalysis\NullableWalker.PlaceholderLocal.cs (2)

50public override ImmutableArray<SyntaxReference> DeclaringSyntaxReferences => ImmutableArray<SyntaxReference>.Empty; 51public override ImmutableArray<Location> Locations => ImmutableArray<Location>.Empty;

Lowering\AsyncRewriter\AsyncExceptionHandlerRewriter.cs (2)

176return _F.Try((BoundBlock)finalizedRegion, ImmutableArray<BoundCatchBlock>.Empty, rewrittenFinally); 598handlerLocals = ImmutableArray<LocalSymbol>.Empty;

Lowering\AsyncRewriter\AsyncIteratorMethodToStateMachineRewriter.cs (1)

150ImmutableArray<BoundExpression>.Empty));

Lowering\AsyncRewriter\AsyncMethodToStateMachineRewriter.cs (6)

151F.Block(ImmutableArray<LocalSymbol>.Empty, 223: ImmutableArray<BoundExpression>.Empty)); 421typeArgumentsWithAnnotations: ImmutableArray<TypeWithAnnotations>.Empty, 422loweredArguments: ImmutableArray<BoundExpression>.Empty, 423argumentNames: ImmutableArray<string>.Empty, 424refKinds: ImmutableArray<RefKind>.Empty,

Lowering\AsyncRewriter\AsyncRewriter.cs (1)

223return new BoundBadStatement(F.Syntax, ImmutableArray<BoundNode>.Empty, hasErrors: true);

Lowering\ClosureConversion\ClosureConversion.cs (2)

1123locals: ImmutableArray<LocalSymbol>.Empty, 1731return new BoundBadExpression(F.Syntax, LookupResultKind.Empty, ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundExpression>(node), node.Type);

Lowering\ClosureConversion\ExpressionLambdaRewriter.cs (5)

353return new BoundBadExpression(node.Syntax, default(LookupResultKind), ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundExpression>(node), ExpressionType); 384return new BoundBadExpression(node.Syntax, 0, ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundExpression>(node), ExpressionType); 1007return new BoundBadExpression(node.Syntax, default(LookupResultKind), ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundExpression>(node), node.Type); 1014return new BoundBadExpression(node.Syntax, default(LookupResultKind), ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundExpression>(node), node.Type); 1046return new BoundBadExpression(node.Syntax, default(LookupResultKind), ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundExpression>(node), node.Type);

Lowering\ClosureConversion\LambdaCapturedVariable.cs (1)

122public override ImmutableArray<CustomModifier> RefCustomModifiers => ImmutableArray<CustomModifier>.Empty;

Lowering\Instrumentation\CodeCoverageInstrumenter.cs (1)

31private ImmutableArray<SourceSpan> _dynamicAnalysisSpans = ImmutableArray<SourceSpan>.Empty;

Lowering\Instrumentation\LocalStateTracingInstrumenter.cs (1)

609return _factory.Sequence(ImmutableArray<LocalSymbol>.Empty, builder.ToImmutableAndFree(), lastExpression);

Lowering\IteratorRewriter\IteratorFinallyMethodSymbol.cs (6)

156get { return ImmutableArray<TypeWithAnnotations>.Empty; } 161get { return ImmutableArray<TypeParameterSymbol>.Empty; } 166get { return ImmutableArray<ParameterSymbol>.Empty; } 171get { return ImmutableArray<MethodSymbol>.Empty; } 176get { return ImmutableArray<CustomModifier>.Empty; } 186return ImmutableArray<string>.Empty;

Lowering\IteratorRewriter\IteratorMethodToStateMachineRewriter.cs (2)

274ImmutableArray<BoundCatchBlock>.Empty, 404ImmutableArray<LocalSymbol>.Empty,

Lowering\LocalRewriter\LocalRewriter.cs (4)

161codeCoverageSpans = codeCoverageInstrumenter?.DynamicAnalysisSpans ?? ImmutableArray<SourceSpan>.Empty; 172codeCoverageSpans = ImmutableArray<SourceSpan>.Empty; 593return new BoundBadExpression(syntax, LookupResultKind.NotReferencable, ImmutableArray<Symbol?>.Empty, children, resultType); 783rewrittenStatements = ImmutableArray<BoundStatement>.Empty;

Lowering\LocalRewriter\LocalRewriter_AsOperator.cs (1)

73locals: ImmutableArray<LocalSymbol>.Empty,

Lowering\LocalRewriter\LocalRewriter_AssignmentOperator.cs (2)

190ImmutableArray<BoundExpression>.Empty, 367ImmutableArray<BoundExpression>.Empty,

Lowering\LocalRewriter\LocalRewriter_BinaryOperator.cs (3)

852locals: ImmutableArray<LocalSymbol>.Empty, 1396locals: ImmutableArray<LocalSymbol>.Empty, 1964locals: ImmutableArray<LocalSymbol>.Empty,

Lowering\LocalRewriter\LocalRewriter_Block.cs (2)

130? new BoundBlock(node.Syntax, ImmutableArray<LocalSymbol>.Empty, ImmutableArray<BoundStatement>.Empty)

Lowering\LocalRewriter\LocalRewriter_Call.cs (7)

515sideEffects: ImmutableArray<BoundExpression>.Empty, 808ImmutableArray<LocalSymbol>.Empty, 885visitedArgumentsBuilder[argIndex] = _factory.Sequence(ImmutableArray<LocalSymbol>.Empty, ImmutableArray.Create<BoundExpression>(store), local); 904return ImmutableArray<BoundInterpolatedStringArgumentPlaceholder>.Empty; 1441ImmutableArray<BoundExpression>.Empty, 1580ImmutableArray<LocalSymbol>.Empty, 1644locals: ImmutableArray<LocalSymbol>.Empty,

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (4)

601locals: ImmutableArray<LocalSymbol>.Empty, 1035rewrittenReceiver = _factory.New(constructor, ImmutableArray<BoundExpression>.Empty); 1211new BoundBlock(iteratorBody.Syntax, locals: ImmutableArray<LocalSymbol>.Empty, statements); 1368ImmutableArray<LocalSymbol>.Empty,

Lowering\LocalRewriter\LocalRewriter_Conversion.cs (2)

106BadExpression(node.Syntax, byteArray, ImmutableArray<BoundExpression>.Empty) : 111result = BadExpression(node.Syntax, node.Type, ImmutableArray<BoundExpression>.Empty);

Lowering\LocalRewriter\LocalRewriter_Event.cs (5)

128clearCall = new BoundBadExpression(syntax, LookupResultKind.NotInvocable, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create<BoundExpression>(removeDelegate), ErrorTypeSymbol.UnknownResultType); 170marshalCall = new BoundBadExpression(syntax, LookupResultKind.NotInvocable, ImmutableArray<Symbol?>.Empty, marshalArguments, ErrorTypeSymbol.UnknownResultType); 180? ImmutableArray<LocalSymbol>.Empty 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);

Lowering\LocalRewriter\LocalRewriter_FixedStatement.cs (5)

67ImmutableArray<BoundCatchBlock>.Empty, 379locals: ImmutableArray<LocalSymbol>.Empty, 483helperCall = new BoundBadExpression(fixedInitializer.Syntax, LookupResultKind.NotInvocable, ImmutableArray<Symbol?>.Empty, ImmutableArray<BoundExpression>.Empty, ErrorTypeSymbol.UnknownResultType); 544lengthCall = new BoundBadExpression(fixedInitializer.Syntax, LookupResultKind.NotInvocable, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create<BoundExpression>(factory.Local(pinnedTemp)), ErrorTypeSymbol.UnknownResultType);

Lowering\LocalRewriter\LocalRewriter_ForEachStatement.cs (4)

260tryBlock: new BoundBlock(forEachSyntax, locals: ImmutableArray<LocalSymbol>.Empty, statements: ImmutableArray.Create(whileLoop)), 261catchBlocks: ImmutableArray<BoundCatchBlock>.Empty, 411locals: ImmutableArray<LocalSymbol>.Empty, 548return BoundCall.Synthesized(syntax, receiver, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, methodArgumentInfo.Method, arguments: ImmutableArray<BoundExpression>.Empty);

Lowering\LocalRewriter\LocalRewriter_FunctionPointerInvocation.cs (1)

60rewrittenInvocation = new BoundSequence(rewrittenInvocation.Syntax, temps.ToImmutableAndFree(), sideEffects: ImmutableArray<BoundExpression>.Empty, rewrittenInvocation, node.Type);

Lowering\LocalRewriter\LocalRewriter_IndexerAccess.cs (1)

192ImmutableArray<BoundExpression>.Empty,

Lowering\LocalRewriter\LocalRewriter_IsOperator.cs (1)

91locals: ImmutableArray<LocalSymbol>.Empty,

Lowering\LocalRewriter\LocalRewriter_IsPatternOperator.cs (2)

181test = _factory.Sequence(ImmutableArray<LocalSymbol>.Empty, _sideEffectBuilder.ToImmutable(), test); 319result = _factory.Sequence(allTemps, ImmutableArray<BoundExpression>.Empty, result);

Lowering\LocalRewriter\LocalRewriter_LockStatement.cs (4)

117exitCallExpr = new BoundBadExpression(lockSyntax, LookupResultKind.NotInvocable, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create<BoundExpression>(boundLockTemp), ErrorTypeSymbol.UnknownResultType); 179ImmutableArray<BoundCatchBlock>.Empty, 212enterCallExpr = new BoundBadExpression(lockSyntax, LookupResultKind.NotInvocable, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create<BoundExpression>(boundLockTemp), ErrorTypeSymbol.UnknownResultType); 228ImmutableArray<BoundCatchBlock>.Empty,

Lowering\LocalRewriter\LocalRewriter_NullCoalescingAssignmentOperator.cs (1)

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

Lowering\LocalRewriter\LocalRewriter_ObjectCreationExpression.cs (8)

107ImmutableArray<BoundExpression>.Empty, 350ImmutableArray<BoundExpression>.Empty, 389newGuid = new BoundBadExpression(node.Syntax, LookupResultKind.NotCreatable, ImmutableArray<Symbol?>.Empty, ImmutableArray<BoundExpression>.Empty, ErrorTypeSymbol.UnknownResultType); 407callGetTypeFromCLSID = new BoundBadExpression(node.Syntax, LookupResultKind.OverloadResolutionFailure, ImmutableArray<Symbol?>.Empty, ImmutableArray<BoundExpression>.Empty, ErrorTypeSymbol.UnknownResultType); 419rewrittenObjectCreation = new BoundBadExpression(node.Syntax, LookupResultKind.OverloadResolutionFailure, ImmutableArray<Symbol?>.Empty, ImmutableArray<BoundExpression>.Empty, node.Type);

Lowering\LocalRewriter\LocalRewriter_ObjectOrCollectionInitializerExpression.cs (1)

129ImmutableArray<TypeWithAnnotations>.Empty,

Lowering\LocalRewriter\LocalRewriter_PropertyAccess.cs (1)

70return MakePropertyGetAccess(syntax, rewrittenReceiver, property, ImmutableArray<BoundExpression>.Empty, default, null, oldNodeOpt);

Lowering\LocalRewriter\LocalRewriter_Range.cs (1)

195return F.StaticCall(constructionMethod, ImmutableArray<BoundExpression>.Empty);

Lowering\LocalRewriter\LocalRewriter_StackAlloc.cs (2)

70symbols: ImmutableArray<Symbol?>.Empty, 71childBoundNodes: ImmutableArray<BoundExpression>.Empty,

Lowering\LocalRewriter\LocalRewriter_StringInterpolation.cs (2)

377: new BoundBadExpression(syntax, LookupResultKind.Empty, symbols: ImmutableArray<Symbol?>.Empty, childBoundNodes: ImmutableArray<BoundExpression>.Empty, type);

Lowering\LocalRewriter\LocalRewriter_TryStatement.cs (1)

25(optimizing && !HasSideEffects(tryBlock)) ? ImmutableArray<BoundCatchBlock>.Empty

Lowering\LocalRewriter\LocalRewriter_TupleBinaryOperator.cs (12)

84tuple.Syntax, sourceTuple: null, wasTargetTyped: true, newArguments, ImmutableArray<string?>.Empty, 85ImmutableArray<bool>.Empty, conversion.Type, conversion.HasErrors); 126syntax, sourceTuple: null, wasTargetTyped: true, fieldAccessorsBuilder.ToImmutableAndFree(), ImmutableArray<string?>.Empty, 127ImmutableArray<bool>.Empty, expr.Type, expr.HasErrors); 162tuple.Syntax, sourceTuple: null, wasTargetTyped: false, newArguments, ImmutableArray<string?>.Empty, 163ImmutableArray<bool>.Empty, tuple.Type, tuple.HasErrors); 308BoundExpression innerSequence = _factory.Sequence(locals: ImmutableArray<LocalSymbol>.Empty, innerEffects.ToImmutableAndFree(), logicalExpression); 322return _factory.Sequence(ImmutableArray<LocalSymbol>.Empty, outerEffects.ToImmutableAndFree(), 330return _factory.Sequence(ImmutableArray<LocalSymbol>.Empty, outerEffects.ToImmutableAndFree(), 339_factory.Sequence(ImmutableArray<LocalSymbol>.Empty, outerEffects.ToImmutableAndFree(), 459argumentNamesOpt: ImmutableArray<string?>.Empty, 460inferredNamesOpt: ImmutableArray<bool>.Empty,

Lowering\LocalRewriter\LocalRewriter_TupleCreationExpression.cs (2)

69Binder.CheckRequiredMembersInObjectInitializer(smallestConstructor, initializers: ImmutableArray<BoundExpression>.Empty, syntax, _diagnostics); 83Binder.CheckRequiredMembersInObjectInitializer(tuple8Ctor, initializers: ImmutableArray<BoundExpression>.Empty, syntax, _diagnostics);

Lowering\LocalRewriter\LocalRewriter_UnaryOperator.cs (1)

549ImmutableArray<LocalSymbol>.Empty,

Lowering\LocalRewriter\LocalRewriter_UsingStatement.cs (4)

92BoundBlock body = new BoundBlock(syntax, ImmutableArray<LocalSymbol>.Empty, statements); 96ImmutableArray<LocalSymbol>.Empty, 422catchBlocks: ImmutableArray<BoundCatchBlock>.Empty, 463disposeCall = new BoundBadExpression(resourceSyntax, LookupResultKind.NotInvocable, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create(disposedExpression), ErrorTypeSymbol.UnknownResultType);

Lowering\LocalRewriter\LoweredDynamicOperation.cs (1)

55var bad = new BoundBadExpression(children[0].Syntax, LookupResultKind.Empty, ImmutableArray<Symbol?>.Empty, children, resultType);

Lowering\LocalRewriter\LoweredDynamicOperationFactory.cs (5)

270var loweredArguments = ImmutableArray<BoundExpression>.Empty; 372var loweredArguments = ImmutableArray<BoundExpression>.Empty; 414var loweredArguments = ImmutableArray<BoundExpression>.Empty; 516return MakeDynamicOperation(binderConstruction, loweredReceiver, RefKind.None, ImmutableArray<BoundExpression>.Empty, default(ImmutableArray<RefKind>), null, resultType); 676return ImmutableArray<LocalSymbol>.Empty;

Lowering\MethodToClassRewriter.cs (1)

750typeParameters = ImmutableArray<TypeParameterSymbol>.Empty;

Lowering\SpillSequenceSpiller.cs (2)

69return (_locals == null) ? ImmutableArray<LocalSymbol>.Empty : _locals.ToImmutable(); 76return ImmutableArray<BoundStatement>.Empty;

Lowering\StateMachineRewriter\MethodToStateMachineRewriter.cs (2)

421hoistedLocals = ImmutableArray<StateMachineFieldSymbol>.Empty; 554return F.Sequence(ImmutableArray<LocalSymbol>.Empty, sideEffects.ToImmutableAndFree(), last);

Lowering\StateMachineRewriter\StateMachineFieldSymbol.cs (1)

64public override ImmutableArray<CustomModifier> RefCustomModifiers => ImmutableArray<CustomModifier>.Empty;

Lowering\StateMachineRewriter\StateMachineRewriter.cs (1)

123return new BoundBadStatement(F.Syntax, ImmutableArray<BoundNode>.Empty, hasErrors: true);

Lowering\StateMachineRewriter\StateMachineTypeSymbol.cs (1)

78builder == null ? ImmutableArray<CSharpAttributeData>.Empty : builder.ToImmutableAndFree(),

Lowering\StateMachineRewriter\SynthesizedStateMachineMethod.cs (1)

97builder == null ? ImmutableArray<CSharpAttributeData>.Empty : builder.ToImmutableAndFree(),

Lowering\StateMachineRewriter\SynthesizedStateMachineProperty.cs (2)

111get { return ImmutableArray<Location>.Empty; } 116get { return ImmutableArray<SyntaxReference>.Empty; }

Lowering\SynthesizedMethodBaseSymbol.cs (4)

97=> ImmutableArray<ImmutableArray<TypeWithAnnotations>>.Empty; 100=> ImmutableArray<TypeParameterConstraintKind>.Empty; 170: ImmutableArray<CSharpAttributeData>.Empty; 176return InheritsBaseMethodAttributes ? BaseMethod.GetReturnTypeAttributes() : ImmutableArray<CSharpAttributeData>.Empty;

Lowering\SyntheticBoundNodeFactory.cs (15)

284return new BoundBadExpression(Syntax, LookupResultKind.Empty, ImmutableArray<Symbol?>.Empty, ImmutableArray<BoundExpression>.Empty, type, hasErrors: true); 496return Block(ImmutableArray<BoundStatement>.Empty); 501return Block(ImmutableArray<LocalSymbol>.Empty, statements); 536return StatementList(ImmutableArray<BoundStatement>.Empty); 584statements.Add(Try(Block(statement), ImmutableArray<BoundCatchBlock>.Empty, Block(instrumentation.Epilogue))); 856return new BoundBadExpression(Syntax, default(LookupResultKind), ImmutableArray<Symbol?>.Empty, args.AsImmutable(), receiver); 882return Call(receiver, method, ImmutableArray<BoundExpression>.Empty); 946argsToParamsOpt: ImmutableArray<int>.Empty, defaultArguments: default(BitVector), resultKind: LookupResultKind.Viable, type: method.ReturnType) 972return If(condition, ImmutableArray<LocalSymbol>.Empty, thenClause, elseClauseOpt); 1048return MakeSequence(ImmutableArray<LocalSymbol>.Empty, parts); 1077return new BoundSequence(Syntax, ImmutableArray<LocalSymbol>.Empty, sideEffects.AsImmutableOrNull(), result, resultType) { WasCompilerGenerated = true }; 1658return new BoundCatchBlock(Syntax, ImmutableArray<LocalSymbol>.Empty, source, source.Type, exceptionFilterPrologueOpt: null, exceptionFilterOpt: null, body: block, isSynthesizedAsyncCatchAll: false); 1663return new BoundTryStatement(Syntax, tryBlock, ImmutableArray<BoundCatchBlock>.Empty, faultBlock, finallyLabelOpt: null, preferFaultHandler: true); 1900locals: ImmutableArray<LocalSymbol>.Empty,

Operations\CSharpOperationFactory.cs (24)

341return ImmutableArray<TOperation>.Empty; 378return ImmutableArray<IOperation>.Empty; 543dimensions = ImmutableArray<BoundExpression>.Empty; 615var arguments = ImmutableArray<IArgumentOperation>.Empty; 723declarations: ImmutableArray<BoundAnonymousPropertyDeclaration>.Empty, 764return CreateBoundDynamicMemberAccessOperation(implicitReceiver, typeArgumentsOpt: ImmutableArray<TypeSymbol>.Empty, memberName: "Add", 897arguments = ImmutableArray<IArgumentOperation>.Empty; 914ImmutableArray<ITypeSymbol> typeArguments = ImmutableArray<ITypeSymbol>.Empty; 964ImmutableArray<ITypeSymbol> typeArguments = ImmutableArray<ITypeSymbol>.Empty; 981return new DynamicInvocationOperation(operation, arguments, argumentNames: ImmutableArray<string?>.Empty, argumentRefKinds: ImmutableArray<RefKind>.Empty, _semanticModel, syntax, type, isImplicit); 1940return ImmutableArray<IArgumentOperation>.Empty; 1969return new VariableDeclaratorOperation(local.GetPublicSymbol(), initializer: null, ignoredArguments: ImmutableArray<IOperation>.Empty, semanticModel: _semanticModel, syntax: declaratorSyntax, isImplicit: false); 1981var nextVariables = ImmutableArray<IOperation>.Empty; 2483return new InvalidOperation(ImmutableArray<IOperation>.Empty, _semanticModel, syntax, type, placeholder.ConstantValueOpt, isImplicit); 2552: ImmutableArray<IPatternOperation>.Empty; 2555: ImmutableArray<IPropertySubpatternOperation>.Empty; 2573: ImmutableArray<IPatternOperation>.Empty; 2579propertySubpatterns: ImmutableArray<IPropertySubpatternOperation>.Empty, 2855var reference = OperationFactory.CreateInvalidOperation(_semanticModel, subpatternSyntax, ImmutableArray<IOperation>.Empty, isImplicit: true); 2877matchedType: previousType, deconstructSymbol: null, deconstructionSubpatterns: ImmutableArray<IPatternOperation>.Empty, 2901reference = new PropertyReferenceOperation(property.GetPublicSymbol(), constrainedToType: null, ImmutableArray<IArgumentOperation>.Empty, 2909reference = OperationFactory.CreateInvalidOperation(_semanticModel, nameSyntax, ImmutableArray<IOperation>.Empty, isImplicit: false); 2941return ImmutableArray<IArgumentOperation>.Empty;

Operations\CSharpOperationFactory_Methods.cs (6)

22return ImmutableArray<BoundStatement>.Empty; 75return new VariableInitializerOperation(locals: ImmutableArray<ILocalSymbol>.Empty, value, _semanticModel, initializerSyntax, initializerIsImplicit); 95return boundLocal == null ? null : new VariableDeclaratorOperation(boundLocal.LocalSymbol.GetPublicSymbol(), initializer: null, ignoredArguments: ImmutableArray<IOperation>.Empty, semanticModel: _semanticModel, syntax: boundLocal.Syntax, isImplicit: false); 276return ImmutableArray<IArgumentOperation>.Empty; 443arguments: ImmutableArray<IArgumentOperation>.Empty, 455ImmutableArray<IArgumentOperation>.Empty,

src\Compilers\CSharp\CSharpAnalyzerDriver\CSharpDeclarationComputer.cs (1)

95builder.Add(new DeclarationInfo(name, ImmutableArray<SyntaxNode>.Empty, declaredSymbol));

Symbols\AliasSymbol.cs (1)

70return new AliasSymbolFromResolvedTarget(globalNamespace, "global", globalNamespace, ImmutableArray<Location>.Empty, isExtern: false);

Symbols\AnonymousTypes\AnonymousTypeManager.Templates.cs (1)

374typeParameters = ImmutableArray<TypeParameterSymbol>.Empty;

Symbols\AnonymousTypes\PublicSymbols\AnonymousManager.TypeOrDelegatePublicSymbol.cs (8)

92get { return ImmutableArray<TypeParameterSymbol>.Empty; } 97get { return ImmutableArray<TypeWithAnnotations>.Empty; } 134return ImmutableArray<NamedTypeSymbol>.Empty; 139return ImmutableArray<NamedTypeSymbol>.Empty; 144return ImmutableArray<NamedTypeSymbol>.Empty; 154return ImmutableArray<NamedTypeSymbol>.Empty; 248return ImmutableArray<string>.Empty; 263return ImmutableArray<NamedTypeSymbol>.Empty;

Symbols\AnonymousTypes\PublicSymbols\AnonymousType.DelegatePublicSymbol.cs (1)

75public override ImmutableArray<SyntaxReference> DeclaringSyntaxReferences => ImmutableArray<SyntaxReference>.Empty;

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.ConstructorSymbol.cs (1)

39_parameters = ImmutableArray<ParameterSymbol>.Empty;

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.DelegateTemplateSymbol.cs (3)

171TypeParameters = ImmutableArray<TypeParameterSymbol>.Empty; 238internal override ImmutableArray<NamedTypeSymbol> GetInterfacesToEmit() => ImmutableArray<NamedTypeSymbol>.Empty; 240internal override ImmutableArray<NamedTypeSymbol> InterfacesNoUseSiteDiagnostics(ConsList<TypeSymbol>? basesBeingResolved = null) => ImmutableArray<NamedTypeSymbol>.Empty;

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.FieldSymbol.cs (3)

37public override ImmutableArray<CustomModifier> RefCustomModifiers => ImmutableArray<CustomModifier>.Empty; 120get { return ImmutableArray<Location>.Empty; } 127return ImmutableArray<SyntaxReference>.Empty;

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.GetHashCodeMethodSymbol.cs (1)

54get { return ImmutableArray<ParameterSymbol>.Empty; }

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.PropertyAccessorSymbol.cs (1)

51get { return ImmutableArray<ParameterSymbol>.Empty; }

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.PropertySymbol.cs (4)

30this(container, field, fieldTypeWithAnnotations, index, ImmutableArray<Location>.Empty, includeBackingField: true) 143get { return ImmutableArray<ParameterSymbol>.Empty; } 153get { return ImmutableArray<CustomModifier>.Empty; } 163get { return ImmutableArray<PropertySymbol>.Empty; }

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.SynthesizedMethodBase.cs (6)

56get { return ImmutableArray<Location>.Empty; } 110get { return ImmutableArray<TypeWithAnnotations>.Empty; } 115get { return ImmutableArray<TypeParameterSymbol>.Empty; } 125get { return ImmutableArray<MethodSymbol>.Empty; } 135get { return ImmutableArray<CustomModifier>.Empty; } 212return ImmutableArray<string>.Empty;

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.TemplateSymbol.cs (2)

140return ImmutableArray<NamedTypeSymbol>.Empty; 145return ImmutableArray<NamedTypeSymbol>.Empty;

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.ToStringMethodSymbol.cs (1)

54get { return ImmutableArray<ParameterSymbol>.Empty; }

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.TypeOrDelegateTemplateSymbol.cs (7)

187return ImmutableArray<NamedTypeSymbol>.Empty; 192return ImmutableArray<NamedTypeSymbol>.Empty; 197return ImmutableArray<NamedTypeSymbol>.Empty; 212get { return ImmutableArray<Location>.Empty; } 217get { return ImmutableArray<SyntaxReference>.Empty; } 239return ImmutableArray<NamedTypeSymbol>.Empty; 307return ImmutableArray<string>.Empty;

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.TypeParameterSymbol.cs (4)

46get { return ImmutableArray<Location>.Empty; } 53return ImmutableArray<SyntaxReference>.Empty; 124return ImmutableArray<TypeWithAnnotations>.Empty; 134return ImmutableArray<NamedTypeSymbol>.Empty;

Symbols\ArrayTypeSymbol.cs (9)

153return ImmutableArray<int>.Empty; 263return ImmutableArray<Symbol>.Empty; 268return ImmutableArray<Symbol>.Empty; 273return ImmutableArray<NamedTypeSymbol>.Empty; 278return ImmutableArray<NamedTypeSymbol>.Empty; 283return ImmutableArray<NamedTypeSymbol>.Empty; 314return ImmutableArray<Location>.Empty; 322return ImmutableArray<SyntaxReference>.Empty; 597return ImmutableArray<NamedTypeSymbol>.Empty;

Symbols\AssemblySymbol.cs (1)

285return ImmutableArray<SyntaxReference>.Empty;

Symbols\Attributes\SourceAttributeData.cs (2)

67constructorArguments: ImmutableArray<TypedConstant>.Empty, 69namedArguments: ImmutableArray<KeyValuePair<string, TypedConstant>>.Empty,

Symbols\Attributes\WellKnownAttributeData\MethodWellKnownAttributeData.cs (3)

63private ImmutableArray<string> _memberNotNullAttributeData = ImmutableArray<string>.Empty; 88private ImmutableArray<string> _memberNotNullWhenTrueAttributeData = ImmutableArray<string>.Empty; 89private ImmutableArray<string> _memberNotNullWhenFalseAttributeData = ImmutableArray<string>.Empty;

Symbols\Attributes\WellKnownAttributeData\ParameterWellKnownAttributeData.cs (1)

162private ImmutableArray<int> _interpolatedStringHandlerArguments = ImmutableArray<int>.Empty;

Symbols\Attributes\WellKnownAttributeData\PropertyWellKnownAttributeData.cs (3)

113private ImmutableArray<string> _memberNotNullAttributeData = ImmutableArray<string>.Empty; 138private ImmutableArray<string> _memberNotNullWhenTrueAttributeData = ImmutableArray<string>.Empty; 139private ImmutableArray<string> _memberNotNullWhenFalseAttributeData = ImmutableArray<string>.Empty;

Symbols\Compilation_UsedAssemblies.cs (1)

29return ImmutableArray<MetadataReference>.Empty;

Symbols\Compilation_WellKnownMembers.cs (4)

405arguments = ImmutableArray<TypedConstant>.Empty; 411namedStringArguments = ImmutableArray<KeyValuePair<string, TypedConstant>>.Empty; 452arguments: ImmutableArray<TypedConstant>.Empty, 453namedArguments: ImmutableArray<KeyValuePair<string, TypedConstant>>.Empty);

Symbols\ConstraintsHelper.cs (5)

148interfaces = ImmutableArray<NamedTypeSymbol>.Empty; 354return ImmutableArray<ImmutableArray<TypeWithAnnotations>>.Empty; 368return ImmutableArray<ImmutableArray<TypeWithAnnotations>>.Empty; 383return ImmutableArray<TypeParameterConstraintKind>.Empty; 409return ImmutableArray<TypeParameterConstraintKind>.Empty;

Symbols\CustomModifier.cs (1)

62return ImmutableArray<CustomModifier>.Empty;

Symbols\DiscardSymbol.cs (2)

23public override ImmutableArray<SyntaxReference> DeclaringSyntaxReferences => ImmutableArray<SyntaxReference>.Empty; 32public override ImmutableArray<Location> Locations => ImmutableArray<Location>.Empty;

Symbols\DynamicTypeSymbol.cs (7)

74return ImmutableArray<Location>.Empty; 82return ImmutableArray<SyntaxReference>.Empty; 90return ImmutableArray<NamedTypeSymbol>.Empty; 134return ImmutableArray<Symbol>.Empty; 139return ImmutableArray<Symbol>.Empty; 144return ImmutableArray<NamedTypeSymbol>.Empty; 149return ImmutableArray<NamedTypeSymbol>.Empty;

Symbols\ErrorMethodSymbol.cs (8)

93get { return ImmutableArray<Location>.Empty; } 100return ImmutableArray<SyntaxReference>.Empty; 121get { return ImmutableArray<CustomModifier>.Empty; } 131get { return ImmutableArray<MethodSymbol>.Empty; } 145get { return ImmutableArray<ParameterSymbol>.Empty; } 150get { return ImmutableArray<TypeParameterSymbol>.Empty; } 155get { return ImmutableArray<TypeWithAnnotations>.Empty; } 254return ImmutableArray<string>.Empty;

Symbols\ErrorPropertySymbol.cs (5)

62public override ImmutableArray<Location> Locations { get { return ImmutableArray<Location>.Empty; } } 64public override ImmutableArray<SyntaxReference> DeclaringSyntaxReferences { get { return ImmutableArray<SyntaxReference>.Empty; } } 86public override ImmutableArray<ParameterSymbol> Parameters { get { return ImmutableArray<ParameterSymbol>.Empty; } } 92public override ImmutableArray<PropertySymbol> ExplicitInterfaceImplementations { get { return ImmutableArray<PropertySymbol>.Empty; } } 94public override ImmutableArray<CustomModifier> RefCustomModifiers { get { return ImmutableArray<CustomModifier>.Empty; } }

Symbols\ErrorTypeSymbol.cs (13)

Symbols\ErrorTypeSymbol.ErrorTypeParameterSymbol.cs (4)

130return ImmutableArray<Location>.Empty; 138return ImmutableArray<SyntaxReference>.Empty; 164return ImmutableArray<TypeWithAnnotations>.Empty; 169return ImmutableArray<NamedTypeSymbol>.Empty;

Symbols\EventSymbol.cs (1)

118ImmutableArray<CSharpAttributeData>.Empty :

Symbols\ExtendedErrorTypeSymbol.cs (2)

180return ImmutableArray<Location>.Empty; 199return ImmutableArray<NamedTypeSymbol>.Empty;

Symbols\FunctionPointers\FunctionPointerMethodSymbol.cs (17)

87var refCustomModifiers = ImmutableArray<CustomModifier>.Empty; 287refCustomModifiers = ImmutableArray<CustomModifier>.Empty; 354var mergedParameterTypes = ImmutableArray<TypeWithAnnotations>.Empty; 404var transformedParameterTypes = ImmutableArray<TypeWithAnnotations>.Empty; 479_parameters = ImmutableArray<FunctionPointerParameterSymbol>.Empty; 514=> GetCustomModifierForRefKind(refKind, compilation) is { } modifier ? ImmutableArray.Create(modifier) : ImmutableArray<CustomModifier>.Empty; 540: ImmutableArray<FunctionPointerParameterSymbol>.Empty; 577return ImmutableArray<FunctionPointerParameterSymbol>.Empty; 606var newParamTypes = ImmutableArray<TypeWithAnnotations>.Empty; 645return ImmutableArray<NamedTypeSymbol>.Empty; 651return ImmutableArray<NamedTypeSymbol>.Empty; 820public override ImmutableArray<TypeParameterSymbol> TypeParameters => ImmutableArray<TypeParameterSymbol>.Empty; 824public override ImmutableArray<MethodSymbol> ExplicitInterfaceImplementations => ImmutableArray<MethodSymbol>.Empty; 826public override ImmutableArray<Location> Locations => ImmutableArray<Location>.Empty; 827public override ImmutableArray<SyntaxReference> DeclaringSyntaxReferences => ImmutableArray<SyntaxReference>.Empty; 836public override ImmutableArray<TypeWithAnnotations> TypeArgumentsWithAnnotations => ImmutableArray<TypeWithAnnotations>.Empty; 844internal override ImmutableArray<string> GetAppliedConditionalSymbols() => ImmutableArray<string>.Empty;

Symbols\FunctionPointers\FunctionPointerParameterSymbol.cs (3)

70public override ImmutableArray<Location> Locations => ImmutableArray<Location>.Empty; 71public override ImmutableArray<SyntaxReference> DeclaringSyntaxReferences => ImmutableArray<SyntaxReference>.Empty; 89internal override ImmutableArray<int> InterpolatedStringHandlerArgumentIndexes => ImmutableArray<int>.Empty;

Symbols\FunctionPointers\FunctionPointerTypeSymbol.cs (7)

80public override ImmutableArray<Location> Locations => ImmutableArray<Location>.Empty; 81public override ImmutableArray<SyntaxReference> DeclaringSyntaxReferences => ImmutableArray<SyntaxReference>.Empty; 92public override ImmutableArray<Symbol> GetMembers() => ImmutableArray<Symbol>.Empty; 93public override ImmutableArray<Symbol> GetMembers(string name) => ImmutableArray<Symbol>.Empty; 94public override ImmutableArray<NamedTypeSymbol> GetTypeMembers() => ImmutableArray<NamedTypeSymbol>.Empty; 95public override ImmutableArray<NamedTypeSymbol> GetTypeMembers(ReadOnlyMemory<char> name) => ImmutableArray<NamedTypeSymbol>.Empty; 97internal override ImmutableArray<NamedTypeSymbol> InterfacesNoUseSiteDiagnostics(ConsList<TypeSymbol>? basesBeingResolved = null) => ImmutableArray<NamedTypeSymbol>.Empty;

Symbols\FunctionTypeSymbol.cs (1)

158internal override ImmutableArray<NamedTypeSymbol> InterfacesNoUseSiteDiagnostics(ConsList<TypeSymbol>? basesBeingResolved = null) => ImmutableArray<NamedTypeSymbol>.Empty;

Symbols\MemberSymbolExtensions.cs (5)

42return ImmutableArray<ParameterSymbol>.Empty; 60return ImmutableArray<TypeWithAnnotations>.Empty; 334return ImmutableArray<TypeParameterSymbol>.Empty; 352return ImmutableArray<TypeSymbol>.Empty; 603return ImmutableArray<Symbol>.Empty;

Symbols\Metadata\PE\DynamicTypeDecoder.cs (1)

360var transformedParameters = ImmutableArray<TypeWithAnnotations>.Empty;

Symbols\Metadata\PE\NativeIntegerTypeDecoder.cs (1)

180var transformedParameterTypes = ImmutableArray<TypeWithAnnotations>.Empty;

Symbols\Metadata\PE\PEEventSymbol.cs (2)

356return ImmutableArray<SyntaxReference>.Empty; 386return ImmutableArray<EventSymbol>.Empty;

Symbols\Metadata\PE\PEFieldSymbol.cs (1)

526return ImmutableArray<SyntaxReference>.Empty;

Symbols\Metadata\PE\PEMethodSymbol.cs (22)

Symbols\Metadata\PE\PEModuleSymbol.cs (2)

290(moduleAssemblyAttributesBuilder != null) ? moduleAssemblyAttributesBuilder.ToImmutableAndFree() : ImmutableArray<CSharpAttributeData>.Empty, 410return ImmutableArray<CSharpAttributeData>.Empty;

Symbols\Metadata\PE\PENamedTypeSymbol.cs (10)

590return ImmutableArray<NamedTypeSymbol>.Empty; 699return ImmutableArray<CSharpAttributeData>.Empty; 1498m = ImmutableArray<Symbol>.Empty; 1511m = ImmutableArray<Symbol>.Empty; 1596return ImmutableArray<NamedTypeSymbol>.Empty; 1616return ImmutableArray<SyntaxReference>.Empty; 1640return ImmutableArray<TypeWithAnnotations>.Empty; 1648return ImmutableArray<TypeParameterSymbol>.Empty; 2375return ImmutableArray<string>.Empty; 2633_lazyTypeParameters = ImmutableArray<TypeParameterSymbol>.Empty;

Symbols\Metadata\PE\PENamespaceSymbol.cs (3)

144return ImmutableArray<Symbol>.Empty; 162: ImmutableArray<NamedTypeSymbol>.Empty; 182return ImmutableArray<SyntaxReference>.Empty;

Symbols\Metadata\PE\PEParameterSymbol.cs (7)

270_lazyCustomAttributes = ImmutableArray<CSharpAttributeData>.Empty; 271_lazyHiddenAttributes = ImmutableArray<CSharpAttributeData>.Empty; 865return ImmutableArray<int>.Empty; 874return ImmutableArray<int>.Empty; 933return ImmutableArray<CustomModifier>.Empty; 1045return ImmutableArray<SyntaxReference>.Empty; 1128ImmutableInterlocked.InterlockedInitialize(ref _lazyHiddenAttributes, ImmutableArray<CSharpAttributeData>.Empty);

Symbols\Metadata\PE\PEPropertySymbol.cs (8)

165/// <see cref="ImmutableArray{T}.Empty"/>. In this case, again, no race has occurred, and the consuming code can simply trust the empty value.</item> 367retVal._lazyCustomAttributes = ImmutableArray<CSharpAttributeData>.Empty; 692get { return ImmutableArray<CustomModifier>.Empty; } 726return ImmutableArray<SyntaxReference>.Empty; 755return ImmutableArray<CSharpAttributeData>.Empty; 762result = ImmutableArray<CSharpAttributeData>.Empty; 793return ImmutableArray<PropertySymbol>.Empty; 893return ImmutableArray<ParameterSymbol>.Empty;

Symbols\Metadata\PE\PETypeParameterSymbol.cs (4)

229declaredConstraintTypes = ImmutableArray<TypeWithAnnotations>.Empty; 442return ImmutableArray<SyntaxReference>.Empty; 618return (bounds != null) ? bounds.ConstraintTypes : ImmutableArray<TypeWithAnnotations>.Empty; 624return (bounds != null) ? bounds.Interfaces : ImmutableArray<NamedTypeSymbol>.Empty;

Symbols\Metadata\PE\TupleTypeDecoder.cs (1)

211var parameterTypes = ImmutableArray<TypeWithAnnotations>.Empty;

Symbols\MethodSymbol.cs (5)

104internal virtual ImmutableArray<string> NotNullMembers => ImmutableArray<string>.Empty; 106internal virtual ImmutableArray<string> NotNullWhenTrueMembers => ImmutableArray<string>.Empty; 108internal virtual ImmutableArray<string> NotNullWhenFalseMembers => ImmutableArray<string>.Empty; 396return ImmutableArray<CSharpAttributeData>.Empty; 925internal virtual ImmutableArray<NamedTypeSymbol> UnmanagedCallingConventionTypes => ImmutableArray<NamedTypeSymbol>.Empty;

Symbols\MissingAssemblySymbol.cs (3)

120return ImmutableArray<Location>.Empty; 131return ImmutableArray<AssemblySymbol>.Empty; 141return ImmutableArray<AssemblySymbol>.Empty;

Symbols\MissingModuleSymbol.cs (3)

126return ImmutableArray<Location>.Empty; 155return ImmutableArray<AssemblyIdentity>.Empty; 160return ImmutableArray<AssemblySymbol>.Empty;

Symbols\MissingNamespaceSymbol.cs (7)

98return ImmutableArray<Location>.Empty; 106return ImmutableArray<SyntaxReference>.Empty; 112return ImmutableArray<NamedTypeSymbol>.Empty; 117return ImmutableArray<NamedTypeSymbol>.Empty; 122return ImmutableArray<NamedTypeSymbol>.Empty; 127return ImmutableArray<Symbol>.Empty; 132return ImmutableArray<Symbol>.Empty;

Symbols\ModuleSymbol.cs (1)

192return ImmutableArray<SyntaxReference>.Empty;

Symbols\NamedTypeSymbol.cs (5)

214return ImmutableArray<MethodSymbol>.Empty; 268: ImmutableArray<Symbol>.Empty; 271: ImmutableArray<Symbol>.Empty; 275return ImmutableArray<MethodSymbol>.Empty; 312return ImmutableArray<PropertySymbol>.Empty;

Symbols\NativeIntegerTypeSymbol.cs (10)

Symbols\NonMissingModuleSymbol.cs (2)

120ImmutableArray<Location>.Empty); 138ImmutableArray<Location>.Empty);

Symbols\OverriddenOrHiddenMembersHelpers.cs (8)

Symbols\OverriddenOrHiddenMembersResult.cs (2)

23ImmutableArray<Symbol>.Empty, 24ImmutableArray<Symbol>.Empty);

Symbols\ParameterSignature.cs (1)

22new ParameterSignature(ImmutableArray<TypeWithAnnotations>.Empty, default(ImmutableArray<RefKind>));

Symbols\PointerTypeSymbol.cs (8)

90return ImmutableArray<NamedTypeSymbol>.Empty; 134return ImmutableArray<Symbol>.Empty; 139return ImmutableArray<Symbol>.Empty; 144return ImmutableArray<NamedTypeSymbol>.Empty; 149return ImmutableArray<NamedTypeSymbol>.Empty; 154return ImmutableArray<NamedTypeSymbol>.Empty; 185return ImmutableArray<Location>.Empty; 193return ImmutableArray<SyntaxReference>.Empty;

Symbols\PropertySymbol.cs (3)

62internal virtual ImmutableArray<string> NotNullMembers => ImmutableArray<string>.Empty; 64internal virtual ImmutableArray<string> NotNullWhenTrueMembers => ImmutableArray<string>.Empty; 66internal virtual ImmutableArray<string> NotNullWhenFalseMembers => ImmutableArray<string>.Empty;

Symbols\PublicModel\PreprocessingSymbol.cs (3)

60ImmutableArray<Location> ISymbol.Locations => ImmutableArray<Location>.Empty; 62ImmutableArray<SyntaxReference> ISymbol.DeclaringSyntaxReferences => ImmutableArray<SyntaxReference>.Empty; 64ImmutableArray<AttributeData> ISymbol.GetAttributes() => ImmutableArray<AttributeData>.Empty;

Symbols\RangeVariableSymbol.cs (2)

49=> _location is null ? ImmutableArray<Location>.Empty : ImmutableArray.Create(_location); 59return ImmutableArray<SyntaxReference>.Empty;

Symbols\ReducedExtensionMethodSymbol.cs (2)

543get { return ImmutableArray<MethodSymbol>.Empty; } 564return ImmutableArray<ParameterSymbol>.Empty;

Symbols\ReferenceManager.cs (1)

149return ImmutableArray<AssemblySymbol>.Empty;

Symbols\Retargeting\RetargetingMethodSymbol.cs (3)

101_lazyTypeParameters = ImmutableArray<TypeParameterSymbol>.Empty; 124return ImmutableArray<TypeWithAnnotations>.Empty; 171return ImmutableArray<ParameterSymbol>.Empty;

Symbols\Retargeting\RetargetingNamedTypeSymbol.cs (1)

71_lazyTypeParameters = ImmutableArray<TypeParameterSymbol>.Empty;

Symbols\Retargeting\RetargetingPropertySymbol.cs (1)

108return ImmutableArray<ParameterSymbol>.Empty;

Symbols\Retargeting\RetargetingSymbolTranslator.cs (3)

766var newParameterTypes = ImmutableArray<TypeWithAnnotations>.Empty; 1027ImmutableArray<MethodSymbol>.Empty); 1093ImmutableArray<PropertySymbol>.Empty);

Symbols\Source\CrefTypeParameterSymbol.cs (2)

199return ImmutableArray<TypeWithAnnotations>.Empty; 204return ImmutableArray<NamedTypeSymbol>.Empty;

Symbols\Source\CustomModifierUtils.cs (2)

43destinationMethod.RefKind != RefKind.None ? constructedSourceMethod.RefCustomModifiers : ImmutableArray<CustomModifier>.Empty; 146destinationParameter.RefKind != RefKind.None ? sourceParameter.RefCustomModifiers : ImmutableArray<CustomModifier>.Empty,

Symbols\Source\ImplicitNamedTypeSymbol.cs (6)

37return ImmutableArray<CSharpAttributeData>.Empty; 73return ImmutableArray<NamedTypeSymbol>.Empty; 78return ImmutableArray<NamedTypeSymbol>.Empty; 88get { return ImmutableArray<TypeParameterSymbol>.Empty; } 93get { return ImmutableArray<TypeWithAnnotations>.Empty; } 164return ImmutableArray<string>.Empty;

Symbols\Source\IndexedTypeParameterSymbol.cs (4)

196return ImmutableArray<Location>.Empty; 204return ImmutableArray<SyntaxReference>.Empty; 214return ImmutableArray<TypeWithAnnotations>.Empty; 219return ImmutableArray<NamedTypeSymbol>.Empty;

Symbols\Source\LambdaParameterSymbol.cs (1)

41get { return ImmutableArray<CustomModifier>.Empty; }

Symbols\Source\LambdaSymbol.cs (6)

169get { return ImmutableArray<CustomModifier>.Empty; } 179get { return ImmutableArray<MethodSymbol>.Empty; } 189get { return ImmutableArray<TypeWithAnnotations>.Empty; } 194get { return ImmutableArray<TypeParameterSymbol>.Empty; } 427public override ImmutableArray<ImmutableArray<TypeWithAnnotations>> GetTypeParameterConstraintTypes() => ImmutableArray<ImmutableArray<TypeWithAnnotations>>.Empty; 429public override ImmutableArray<TypeParameterConstraintKind> GetTypeParameterConstraintKinds() => ImmutableArray<TypeParameterConstraintKind>.Empty;

Symbols\Source\LocalFunctionSymbol.cs (3)

70_typeParameters = ImmutableArray<SourceMethodTypeParameterSymbol>.Empty; 334public override ImmutableArray<MethodSymbol> ExplicitInterfaceImplementations => ImmutableArray<MethodSymbol>.Empty; 342public override ImmutableArray<CustomModifier> RefCustomModifiers => ImmutableArray<CustomModifier>.Empty;

Symbols\Source\ParameterHelpers.cs (2)

95_ => ImmutableArray<CustomModifier>.Empty 994return ImmutableArray<CustomModifier>.Empty;

Symbols\Source\SourceAssemblySymbol.cs (3)

1304netModuleNames = ImmutableArray<string>.Empty; 1305return ImmutableArray<CSharpAttributeData>.Empty; 1995ImmutableArray<TypedConstant>.Empty,

Symbols\Source\SourceClonedParameterSymbol.cs (1)

43return ImmutableArray<SyntaxReference>.Empty;

Symbols\Source\SourceComplexParameterSymbol.cs (2)

345ImmutableArray<LocalSymbol>.Empty, 1709public override ImmutableArray<CustomModifier> RefCustomModifiers => ImmutableArray<CustomModifier>.Empty;

Symbols\Source\SourceConstructorSymbolBase.cs (3)

134get { return ImmutableArray<TypeParameterSymbol>.Empty; } 138=> ImmutableArray<ImmutableArray<TypeWithAnnotations>>.Empty; 141=> ImmutableArray<TypeParameterConstraintKind>.Empty;

Symbols\Source\SourceCustomEventSymbol.cs (1)

169ImmutableArray<EventSymbol>.Empty :

Symbols\Source\SourceDelegateMethodSymbol.cs (4)

148return ImmutableArray<TypeParameterSymbol>.Empty; 153=> ImmutableArray<ImmutableArray<TypeWithAnnotations>>.Empty; 156=> ImmutableArray<TypeParameterConstraintKind>.Empty; 287_refCustomModifiers = ImmutableArray<CustomModifier>.Empty;

Symbols\Source\SourceDestructorSymbol.cs (4)

106get { return ImmutableArray<ParameterSymbol>.Empty; } 111get { return ImmutableArray<TypeParameterSymbol>.Empty; } 115=> ImmutableArray<ImmutableArray<TypeWithAnnotations>>.Empty; 118=> ImmutableArray<TypeParameterConstraintKind>.Empty;

Symbols\Source\SourceEventAccessorSymbol.cs (6)

56explicitInterfaceImplementations = ImmutableArray<MethodSymbol>.Empty; 64explicitInterfaceImplementations = (object)implementedAccessor == null ? ImmutableArray<MethodSymbol>.Empty : ImmutableArray.Create<MethodSymbol>(implementedAccessor); 174return ImmutableArray<CustomModifier>.Empty; // Same as base, but this is clear and explicit. 188get { return ImmutableArray<TypeParameterSymbol>.Empty; } 192=> ImmutableArray<ImmutableArray<TypeWithAnnotations>>.Empty; 195=> ImmutableArray<TypeParameterConstraintKind>.Empty;

Symbols\Source\SourceFieldLikeEventSymbol.cs (1)

174get { return ImmutableArray<EventSymbol>.Empty; }

Symbols\Source\SourceFieldSymbol.cs (2)

84return ImmutableArray<CustomModifier>.Empty; 96public sealed override ImmutableArray<CustomModifier> RefCustomModifiers => ImmutableArray<CustomModifier>.Empty;

Symbols\Source\SourceFixedFieldSymbol.cs (2)

156: base(GeneratedNames.MakeFixedFieldImplementationName(field.Name), typeParameters: ImmutableArray<TypeParameterSymbol>.Empty, typeMap: TypeMap.Empty) 228ImmutableArray<Symbol>.Empty;

Symbols\Source\SourceLabelSymbol.cs (2)

82? ImmutableArray<Location>.Empty 103return node == null ? ImmutableArray<SyntaxReference>.Empty : ImmutableArray.Create<SyntaxReference>(node.GetReference());

Symbols\Source\SourceMemberContainerSymbol.cs (41)

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (1)

229var info = new CSDiagnosticInfo(ErrorCode.ERR_MixingWinRTEventWithRegular, args, ImmutableArray<Symbol>.Empty, ImmutableArray.Create<Location>(this.GetFirstLocation()));

Symbols\Source\SourceMemberMethodSymbol.cs (2)

794return ImmutableArray<CustomModifier>.Empty; 832return ImmutableArray<MethodSymbol>.Empty;

Symbols\Source\SourceMethodSymbolWithAttributes.cs (5)

105return (this.syntaxReferenceOpt == null) ? ImmutableArray<SyntaxReference>.Empty : ImmutableArray.Create(this.syntaxReferenceOpt); 507return data != null ? data.ConditionalSymbols : ImmutableArray<string>.Empty; 660GetDecodedWellKnownAttributeData()?.NotNullMembers ?? ImmutableArray<string>.Empty; 663GetDecodedWellKnownAttributeData()?.NotNullWhenTrueMembers ?? ImmutableArray<string>.Empty; 666GetDecodedWellKnownAttributeData()?.NotNullWhenFalseMembers ?? ImmutableArray<string>.Empty;

Symbols\Source\SourceNamedTypeSymbol.cs (7)

142return ImmutableArray<TypeParameterSymbol>.Empty; 268return (constraintTypes.Length > 0) ? constraintTypes[ordinal] : ImmutableArray<TypeWithAnnotations>.Empty; 316var results = ImmutableArray<TypeParameterConstraintClause>.Empty; 372results = ImmutableArray<TypeParameterConstraintClause>.Empty; 397var results = ImmutableArray<TypeParameterConstraintClause>.Empty; 455results = ImmutableArray<TypeParameterConstraintClause>.Empty; 1560return data != null ? data.ConditionalSymbols : ImmutableArray<string>.Empty;

Symbols\Source\SourceNamedTypeSymbol_Bases.cs (3)

72return ImmutableArray<NamedTypeSymbol>.Empty; 285return new Tuple<NamedTypeSymbol, ImmutableArray<NamedTypeSymbol>>(null, ImmutableArray<NamedTypeSymbol>.Empty); 665return ImmutableArray<NamedTypeSymbol>.Empty;

Symbols\Source\SourceNamespaceSymbol.AliasesAndUsings.cs (14)

Symbols\Source\SourceNamespaceSymbol.cs (2)

176: ImmutableArray<Symbol>.Empty; 200: ImmutableArray<NamedTypeSymbol>.Empty;

Symbols\Source\SourceOrdinaryMethodOrUserDefinedOperatorSymbol.cs (3)

85_lazyRefCustomModifiers = ImmutableArray<CustomModifier>.Empty; 95_lazyExplicitInterfaceImplementations = ImmutableArray<MethodSymbol>.Empty; 144_lazyExplicitInterfaceImplementations = ImmutableArray<MethodSymbol>.Empty;

Symbols\Source\SourceOrdinaryMethodSymbol.cs (4)

939=> ImmutableArray<TypeParameterSymbol>.Empty; 942=> ImmutableArray<ImmutableArray<TypeWithAnnotations>>.Empty; 945=> ImmutableArray<TypeParameterConstraintKind>.Empty; 1095return ImmutableArray<TypeParameterSymbol>.Empty;

Symbols\Source\SourceParameterSymbol.cs (2)

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

Symbols\Source\SourcePropertyAccessorSymbol.cs (7)

265_lazyRefCustomModifiers = ImmutableArray<CustomModifier>.Empty; 336get { return ImmutableArray<TypeParameterSymbol>.Empty; } 340=> ImmutableArray<ImmutableArray<TypeWithAnnotations>>.Empty; 343=> ImmutableArray<TypeParameterConstraintKind>.Empty; 613explicitInterfaceImplementations = ImmutableArray<MethodSymbol>.Empty; 622? ImmutableArray<MethodSymbol>.Empty 768return ImmutableArray<ParameterSymbol>.Empty;

Symbols\Source\SourcePropertySymbol.cs (1)

573return ImmutableArray<ParameterSymbol>.Empty;

Symbols\Source\SourcePropertySymbolBase.cs (7)

118_lazyExplicitInterfaceImplementations = ImmutableArray<PropertySymbol>.Empty; 197_lazyRefCustomModifiers = ImmutableArray<CustomModifier>.Empty; 242_lazyRefCustomModifiers = _refKind != RefKind.None ? overriddenOrImplementedProperty.RefCustomModifiers : ImmutableArray<CustomModifier>.Empty; 271ImmutableArray<PropertySymbol>.Empty : 280GetDecodedWellKnownAttributeData()?.NotNullMembers ?? ImmutableArray<string>.Empty; 283GetDecodedWellKnownAttributeData()?.NotNullWhenTrueMembers ?? ImmutableArray<string>.Empty; 286GetDecodedWellKnownAttributeData()?.NotNullWhenFalseMembers ?? ImmutableArray<string>.Empty;

Symbols\Source\SourceSimpleParameterSymbol.cs (2)

80get { return ImmutableArray<CustomModifier>.Empty; } 123internal override ImmutableArray<int> InterpolatedStringHandlerArgumentIndexes => ImmutableArray<int>.Empty;

Symbols\Source\SourceTypeParameterSymbol.cs (3)

95return (bounds != null) ? bounds.ConstraintTypes : ImmutableArray<TypeWithAnnotations>.Empty; 101return (bounds != null) ? bounds.Interfaces : ImmutableArray<NamedTypeSymbol>.Empty; 733var constraintTypes = constraints.IsEmpty ? ImmutableArray<TypeWithAnnotations>.Empty : constraints[Ordinal];

Symbols\Source\SourceUserDefinedOperatorSymbolBase.cs (3)

779get { return ImmutableArray<TypeParameterSymbol>.Empty; } 783=> ImmutableArray<ImmutableArray<TypeWithAnnotations>>.Empty; 786=> ImmutableArray<TypeParameterConstraintKind>.Empty;

Symbols\Source\ThisParameterSymbol.cs (4)

20get { return ImmutableArray<SyntaxReference>.Empty; } 90get { return ImmutableArray<CustomModifier>.Empty; } 119internal sealed override ImmutableArray<int> InterpolatedStringHandlerArgumentIndexes => ImmutableArray<int>.Empty; 168get { return _containingMethod is not null ? _containingMethod.Locations : ImmutableArray<Location>.Empty; }

Symbols\Source\TypeParameterConstraintClause.cs (2)

76ImmutableArray<TypeWithAnnotations>.Empty); 80ImmutableArray<TypeWithAnnotations>.Empty);

Symbols\Source\TypeParameterInfo.cs (3)

32LazyTypeParameters = ImmutableArray<TypeParameterSymbol>.Empty, 33LazyTypeParameterConstraintTypes = ImmutableArray<ImmutableArray<TypeWithAnnotations>>.Empty, 34LazyTypeParameterConstraintKinds = ImmutableArray<TypeParameterConstraintKind>.Empty,

Symbols\SubstitutedMethodSymbol.cs (2)

272return ImmutableArray<MethodSymbol>.Empty; 338return ImmutableArray<ParameterSymbol>.Empty;

Symbols\SubstitutedNamedTypeSymbol.cs (2)

151return _unbound ? ImmutableArray<NamedTypeSymbol>.Empty : Map.SubstituteNamedTypes(OriginalDefinition.GetDeclaredInterfaces(basesBeingResolved)); 176return _unbound ? ImmutableArray<NamedTypeSymbol>.Empty : Map.SubstituteNamedTypes(OriginalDefinition.InterfacesNoUseSiteDiagnostics(basesBeingResolved));

Symbols\Symbol.cs (1)

499return ImmutableArray<SyntaxReference>.Empty;

Symbols\Symbol_Attributes.cs (4)

35return ImmutableArray<CSharpAttributeData>.Empty; 393boundAttributes = ImmutableArray<CSharpAttributeData>.Empty; 658binders = ImmutableArray<Binder>.Empty; 659return ImmutableArray<AttributeSyntax>.Empty;

Symbols\SymbolExtensions.cs (4)

496refCustomModifiers = ImmutableArray<CustomModifier>.Empty; 514refCustomModifiers = ImmutableArray<CustomModifier>.Empty; 520refCustomModifiers = ImmutableArray<CustomModifier>.Empty; 531refCustomModifiers = ImmutableArray<CustomModifier>.Empty;

Symbols\Synthesized\GeneratedLabelSymbol.cs (1)

51return ImmutableArray<SyntaxReference>.Empty;

Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListEnumeratorTypeSymbol.cs (7)

122public override ImmutableArray<TypeParameterSymbol> TypeParameters => ImmutableArray<TypeParameterSymbol>.Empty; 150public override ImmutableArray<Location> Locations => ImmutableArray<Location>.Empty; 152public override ImmutableArray<SyntaxReference> DeclaringSyntaxReferences => ImmutableArray<SyntaxReference>.Empty; 204public override ImmutableArray<NamedTypeSymbol> GetTypeMembers() => ImmutableArray<NamedTypeSymbol>.Empty; 206public override ImmutableArray<NamedTypeSymbol> GetTypeMembers(ReadOnlyMemory<char> name, int arity) => ImmutableArray<NamedTypeSymbol>.Empty; 208public override ImmutableArray<NamedTypeSymbol> GetTypeMembers(ReadOnlyMemory<char> name) => ImmutableArray<NamedTypeSymbol>.Empty; 214internal override ImmutableArray<string> GetAppliedConditionalSymbols() => ImmutableArray<string>.Empty;

Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListProperty.cs (1)

37public override ImmutableArray<CustomModifier> RefCustomModifiers => ImmutableArray<CustomModifier>.Empty;

Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListTypeParameterSymbol.cs (2)

59internal override ImmutableArray<TypeWithAnnotations> GetConstraintTypes(ConsList<TypeParameterSymbol> inProgress) => ImmutableArray<TypeWithAnnotations>.Empty; 65internal override ImmutableArray<NamedTypeSymbol> GetInterfaces(ConsList<TypeParameterSymbol> inProgress) => ImmutableArray<NamedTypeSymbol>.Empty;

Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListTypeSymbol.cs (4)

827public override ImmutableArray<Location> Locations => ImmutableArray<Location>.Empty; 829public override ImmutableArray<SyntaxReference> DeclaringSyntaxReferences => ImmutableArray<SyntaxReference>.Empty; 884: ImmutableArray<NamedTypeSymbol>.Empty; 896internal override ImmutableArray<string> GetAppliedConditionalSymbols() => ImmutableArray<string>.Empty;

Symbols\Synthesized\Records\SynthesizedPrimaryConstructorParameterBackingFieldSymbol.cs (1)

47public override ImmutableArray<CustomModifier> RefCustomModifiers => ImmutableArray<CustomModifier>.Empty;

Symbols\Synthesized\Records\SynthesizedRecordClone.cs (1)

101Parameters: ImmutableArray<ParameterSymbol>.Empty);

Symbols\Synthesized\Records\SynthesizedRecordEqualityContractProperty.cs (3)

51public override ImmutableArray<SyntaxReference> DeclaringSyntaxReferences => ImmutableArray<SyntaxReference>.Empty; 82ImmutableArray<ParameterSymbol>.Empty); 166public override ImmutableArray<SyntaxReference> DeclaringSyntaxReferences => ImmutableArray<SyntaxReference>.Empty;

Symbols\Synthesized\Records\SynthesizedRecordGetHashCode.cs (1)

35Parameters: ImmutableArray<ParameterSymbol>.Empty);

Symbols\Synthesized\Records\SynthesizedRecordOrdinaryMethod.cs (3)

51public sealed override ImmutableArray<TypeParameterSymbol> TypeParameters => ImmutableArray<TypeParameterSymbol>.Empty; 53public sealed override ImmutableArray<ImmutableArray<TypeWithAnnotations>> GetTypeParameterConstraintTypes() => ImmutableArray<ImmutableArray<TypeWithAnnotations>>.Empty; 55public sealed override ImmutableArray<TypeParameterConstraintKind> GetTypeParameterConstraintKinds() => ImmutableArray<TypeParameterConstraintKind>.Empty;

Symbols\Synthesized\Records\SynthesizedRecordPropertySymbol.cs (1)

95ImmutableArray<ParameterSymbol>.Empty);

Symbols\Synthesized\Records\SynthesizedRecordToString.cs (1)

44Parameters: ImmutableArray<ParameterSymbol>.Empty);

Symbols\Synthesized\SynthesizedAccessorValueParameterSymbol.cs (1)

59return ImmutableArray<CustomModifier>.Empty; // since RefKind is always None.

Symbols\Synthesized\SynthesizedBackingFieldSymbol.cs (1)

64=> ImmutableArray<SyntaxReference>.Empty;

Symbols\Synthesized\SynthesizedContainer.cs (10)

33_typeParameters = ImmutableArray<TypeParameterSymbol>.Empty; 86public override ImmutableArray<Location> Locations => ImmutableArray<Location>.Empty; 88public override ImmutableArray<SyntaxReference> DeclaringSyntaxReferences => ImmutableArray<SyntaxReference>.Empty; 118return (object)constructor == null ? ImmutableArray<Symbol>.Empty : ImmutableArray.Create(constructor); 124return ((object)ctor != null && name == ctor.Name) ? ImmutableArray.Create<Symbol>(ctor) : ImmutableArray<Symbol>.Empty; 144public override ImmutableArray<NamedTypeSymbol> GetTypeMembers() => ImmutableArray<NamedTypeSymbol>.Empty; 146public override ImmutableArray<NamedTypeSymbol> GetTypeMembers(ReadOnlyMemory<char> name) => ImmutableArray<NamedTypeSymbol>.Empty; 148public override ImmutableArray<NamedTypeSymbol> GetTypeMembers(ReadOnlyMemory<char> name, int arity) => ImmutableArray<NamedTypeSymbol>.Empty; 158internal override ImmutableArray<NamedTypeSymbol> InterfacesNoUseSiteDiagnostics(ConsList<TypeSymbol> basesBeingResolved) => ImmutableArray<NamedTypeSymbol>.Empty; 189internal sealed override ImmutableArray<string> GetAppliedConditionalSymbols() => ImmutableArray<string>.Empty;

Symbols\Synthesized\SynthesizedDelegateSymbol.cs (6)

173get { return ImmutableArray<TypeWithAnnotations>.Empty; } 178get { return ImmutableArray<TypeParameterSymbol>.Empty; } 185get { return ImmutableArray<MethodSymbol>.Empty; } 190get { return ImmutableArray<CustomModifier>.Empty; } 200return ImmutableArray<string>.Empty; 220get { return ImmutableArray<Location>.Empty; }

Symbols\Synthesized\SynthesizedEmbeddedAttributeSymbol.cs (13)

Symbols\Synthesized\SynthesizedEmbeddedLifetimeAnnotationAttributeSymbol.cs (1)

24getParameters: m => ImmutableArray<ParameterSymbol>.Empty,

Symbols\Synthesized\SynthesizedEmbeddedNativeIntegerAttributeSymbol.cs (1)

49m => ImmutableArray<ParameterSymbol>.Empty,

Symbols\Synthesized\SynthesizedEntryPointSymbol.cs (13)

94get { return ImmutableArray<TypeParameterSymbol>.Empty; } 104get { return ImmutableArray<Location>.Empty; } 111return ImmutableArray<SyntaxReference>.Empty; 122get { return ImmutableArray<CustomModifier>.Empty; } 127get { return ImmutableArray<TypeWithAnnotations>.Empty; } 220get { return ImmutableArray<MethodSymbol>.Empty; } 277return ImmutableArray<string>.Empty; 298ImmutableArray<BoundExpression>.Empty, 402locals: ImmutableArray<LocalSymbol>.Empty, 425locals: ImmutableArray<LocalSymbol>.Empty, 456public override ImmutableArray<ParameterSymbol> Parameters => ImmutableArray<ParameterSymbol>.Empty; 496locals: ImmutableArray<LocalSymbol>.Empty, 497statements: ImmutableArray<BoundStatement>.Empty,

Symbols\Synthesized\SynthesizedEnumValueFieldSymbol.cs (1)

31public override ImmutableArray<CustomModifier> RefCustomModifiers => ImmutableArray<CustomModifier>.Empty;

Symbols\Synthesized\SynthesizedFieldSymbol.cs (1)

38public override ImmutableArray<CustomModifier> RefCustomModifiers => ImmutableArray<CustomModifier>.Empty;

Symbols\Synthesized\SynthesizedFieldSymbolBase.cs (2)

160get { return ImmutableArray<Location>.Empty; } 167return ImmutableArray<SyntaxReference>.Empty;

Symbols\Synthesized\SynthesizedGlobalMethodSymbol.cs (9)

43_typeParameters = ImmutableArray<TypeParameterSymbol>.Empty; 150return ImmutableArray<string>.Empty; 165return ImmutableArray<TypeParameterSymbol>.Empty; 179return ImmutableArray<ParameterSymbol>.Empty; 193get { return ImmutableArray<Location>.Empty; } 200return ImmutableArray<SyntaxReference>.Empty; 221get { return ImmutableArray<CustomModifier>.Empty; } 226get { return ImmutableArray<TypeWithAnnotations>.Empty; } 332get { return ImmutableArray<MethodSymbol>.Empty; }

Symbols\Synthesized\SynthesizedImplementationMethod.cs (2)

163get { return ImmutableArray<Location>.Empty; } 266return ImmutableArray<string>.Empty;

Symbols\Synthesized\SynthesizedInlineArrayTypeSymbol.cs (14)

Symbols\Synthesized\SynthesizedInstanceConstructor.cs (6)

37get { return ImmutableArray<ParameterSymbol>.Empty; } 124return ImmutableArray<string>.Empty; 134get { return ImmutableArray<TypeParameterSymbol>.Empty; } 165get { return ImmutableArray<CustomModifier>.Empty; } 170get { return ImmutableArray<TypeWithAnnotations>.Empty; } 265get { return ImmutableArray<MethodSymbol>.Empty; }

Symbols\Synthesized\SynthesizedInstanceMethodSymbol.cs (1)

25return ImmutableArray<SyntaxReference>.Empty;

Symbols\Synthesized\SynthesizedInteractiveInitializerMethod.cs (6)

66get { return ImmutableArray<MethodSymbol>.Empty; } 136get { return ImmutableArray<ParameterSymbol>.Empty; } 155get { return ImmutableArray<CustomModifier>.Empty; } 160get { return ImmutableArray<TypeWithAnnotations>.Empty; } 165get { return ImmutableArray<TypeParameterSymbol>.Empty; } 215return ImmutableArray<string>.Empty;

Symbols\Synthesized\SynthesizedIntrinsicOperatorSymbol.cs (8)

242return ImmutableArray<TypeWithAnnotations>.Empty; 250return ImmutableArray<TypeParameterSymbol>.Empty; 266return ImmutableArray<MethodSymbol>.Empty; 279return ImmutableArray<CustomModifier>.Empty; 293return ImmutableArray<string>.Empty; 332return ImmutableArray<Location>.Empty; 340return ImmutableArray<SyntaxReference>.Empty; 500get { return ImmutableArray<CustomModifier>.Empty; }

Symbols\Synthesized\SynthesizedLambdaCacheFieldSymbol.cs (1)

38public override ImmutableArray<CustomModifier> RefCustomModifiers => ImmutableArray<CustomModifier>.Empty;

Symbols\Synthesized\SynthesizedLocal.cs (2)

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

Symbols\Synthesized\SynthesizedParameterlessThrowMethod.cs (2)

21this.SetParameters(ImmutableArray<ParameterSymbol>.Empty); 33var body = F.Throw(F.New(_exceptionConstructor, ImmutableArray<BoundExpression>.Empty));

Symbols\Synthesized\SynthesizedParameterSymbol.cs (5)

137get { return ImmutableArray<Location>.Empty; } 144return ImmutableArray<SyntaxReference>.Empty; 223internal override ImmutableArray<int> InterpolatedStringHandlerArgumentIndexes => ImmutableArray<int>.Empty; 323get { return ImmutableArray<CustomModifier>.Empty; } 376return _baseParameterForAttributes?.GetAttributes() ?? ImmutableArray<CSharpAttributeData>.Empty;

Symbols\Synthesized\SynthesizedPrivateImplementationDetailsType.cs (15)

Symbols\Synthesized\SynthesizedSealedPropertyAccessor.cs (5)

60return ImmutableArray<Location>.Empty; 205return ImmutableArray<TypeWithAnnotations>.Empty; 213return ImmutableArray<TypeParameterSymbol>.Empty; 234return ImmutableArray<MethodSymbol>.Empty; 358return ImmutableArray<string>.Empty;

Symbols\Synthesized\SynthesizedSimpleProgramEntryPointSymbol.cs (4)

135return ImmutableArray<TypeParameterSymbol>.Empty; 173return ImmutableArray<CustomModifier>.Empty; 203=> ImmutableArray<ImmutableArray<TypeWithAnnotations>>.Empty; 206=> ImmutableArray<TypeParameterConstraintKind>.Empty;

Symbols\Synthesized\SynthesizedStaticConstructor.cs (7)

68return ImmutableArray<TypeParameterSymbol>.Empty; 84return ImmutableArray<ParameterSymbol>.Empty; 123return ImmutableArray<SyntaxReference>.Empty; 153return ImmutableArray<CustomModifier>.Empty; 161return ImmutableArray<TypeWithAnnotations>.Empty; 287return ImmutableArray<MethodSymbol>.Empty; 372return ImmutableArray<string>.Empty;

Symbols\Synthesized\SynthesizedSubstitutedTypeParameterSymbol.cs (1)

52return ImmutableArray<CSharpAttributeData>.Empty;

Symbols\SynthesizedNamespaceSymbol.cs (7)

62=> ImmutableArray<Location>.Empty; 65=> ImmutableArray<SyntaxReference>.Empty; 68=> ImmutableArray<NamedTypeSymbol>.Empty; 71=> ImmutableArray<NamedTypeSymbol>.Empty; 74=> ImmutableArray<NamedTypeSymbol>.Empty; 77=> ImmutableArray<Symbol>.Empty; 80=> ImmutableArray<Symbol>.Empty;

Symbols\SynthesizedSimpleMethodTypeParameterSymbol.cs (1)

112return ImmutableArray<TypeWithAnnotations>.Empty;

Symbols\Tuples\TupleErrorFieldSymbol.cs (3)

52_locations = location == null ? ImmutableArray<Location>.Empty : ImmutableArray.Create(location); 128ImmutableArray<SyntaxReference>.Empty : 159public override ImmutableArray<CustomModifier> RefCustomModifiers => ImmutableArray<CustomModifier>.Empty;

Symbols\Tuples\TupleFieldSymbol.cs (1)

188ImmutableArray<SyntaxReference>.Empty :

Symbols\Tuples\TupleTypeSymbol.cs (4)

61var locations = locationOpt is null ? ImmutableArray<Location>.Empty : ImmutableArray.Create(locationOpt); 846return ImmutableArray<Location>.Empty; 850return elementLocation == null ? ImmutableArray<Location>.Empty : ImmutableArray.Create(elementLocation); 927Locations = ImmutableArray<Location>.Empty;

Symbols\TypeMap.cs (1)

107newTypeParameters = ImmutableArray<TypeParameterSymbol>.Empty;

Symbols\TypeParameterSymbol.cs (7)

145return ImmutableArray<Symbol>.Empty; 151return ImmutableArray<Symbol>.Empty; 157return ImmutableArray<NamedTypeSymbol>.Empty; 163return ImmutableArray<NamedTypeSymbol>.Empty; 169return ImmutableArray<NamedTypeSymbol>.Empty; 244return ImmutableArray<NamedTypeSymbol>.Empty; 249return ImmutableArray<NamedTypeSymbol>.Empty;

Symbols\TypeSymbol.cs (1)

322return ImmutableArray<NamedTypeSymbol>.Empty;

Symbols\TypeSymbolExtensions.cs (2)

421return ImmutableArray<NamedTypeSymbol>.Empty; 1997var paramTypes = ImmutableArray<TypeWithAnnotations>.Empty;

Symbols\TypeWithAnnotations.cs (2)

840internal static readonly Extensions Default = new NonLazyType(customModifiers: ImmutableArray<CustomModifier>.Empty); 1110internal override ImmutableArray<CustomModifier> CustomModifiers => ImmutableArray<CustomModifier>.Empty;

Utilities\ValueSetFactory.NumericValueSet.cs (1)

29public static NumericValueSet<T> NoValues(INumericTC<T> tc) => new NumericValueSet<T>(ImmutableArray<(T first, T last)>.Empty, tc);