Empty

Binder\Binder.cs (1)

877: 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)

898(object)otherSymbol == null ? ImmutableArray<Symbol>.Empty : ImmutableArray.Create(otherSymbol), 899receiver == null ? ImmutableArray<BoundExpression>.Empty : ImmutableArray.Create(AdjustBadExpressionChild(receiver)), 5702ImmutableArray<TypeParameterSymbol>.Empty, 5705ImmutableArray<CustomModifier>.Empty, 5714ImmutableArray<CustomModifier>.Empty, 5715ImmutableArray<MethodSymbol>.Empty); 5742ImmutableArray<TypeParameterSymbol>.Empty, 5745ImmutableArray<CustomModifier>.Empty, 5754ImmutableArray<CustomModifier>.Empty, 5755ImmutableArray<MethodSymbol>.Empty);

Binder\Binder_Attributes.cs (5)

266ImmutableArray<BoundAssignmentOperator> boundNamedArguments = analyzedArguments.NamedArguments?.ToImmutableAndFree() ?? ImmutableArray<BoundAssignmentOperator>.Empty; 765var validatedArguments = ImmutableArray<TypedConstant>.Empty; 804return ImmutableArray<KeyValuePair<string, TypedConstant>>.Empty; 991initializer = ImmutableArray<TypedConstant>.Empty; 997initializer = ImmutableArray<TypedConstant>.Empty;

Binder\Binder_Await.cs (2)

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

Binder\Binder_Constraints.cs (1)

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

Binder\Binder_Crefs.cs (19)

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)

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

Binder\Binder_Invocation.cs (4)

52return ImmutableArray<MethodSymbol>.Empty; 356result = BindDynamicInvocation(node, boundExpression, analyzedArguments, ImmutableArray<MethodSymbol>.Empty, diagnostics, queryClause); 1637BoundExpression collection = CreateParamsCollection(node, parameters[paramsIndex], collectionArgs: ImmutableArray<BoundExpression>.Empty, diagnostics); 2333var originalMethods = (expr.Kind == BoundKind.MethodGroup) ? ((BoundMethodGroup)expr).Methods : ImmutableArray<MethodSymbol>.Empty;

Binder\Binder_Lookup.cs (6)

1119return ImmutableArray<NamedTypeSymbol>.Empty; 1126return ImmutableArray<NamedTypeSymbol>.Empty; 1379return ImmutableArray<Symbol>.Empty; 1403return ImmutableArray<Symbol>.Empty; 1520diagInfo = diagnose ? new CSDiagnosticInfo(ErrorCode.ERR_BadAccess, new[] { unwrappedSymbol }, unwrappedSymbols, additionalLocations: ImmutableArray<Location>.Empty) : null; 1544diagInfo = new CSDiagnosticInfo(ErrorCode.ERR_BadAccess, new[] { unwrappedSymbol }, ImmutableArray.Create<Symbol>(unwrappedSymbol), additionalLocations: ImmutableArray<Location>.Empty);

Binder\Binder_Operators.cs (4)

526originalUserDefinedOperatorsOpt: ImmutableArray<MethodSymbol>.Empty, 2218originalUserDefinedOperators = ImmutableArray<MethodSymbol>.Empty; 2386originalUserDefinedOperators = ImmutableArray<MethodSymbol>.Empty; 3612ImmutableArray<MethodSymbol>.Empty,

Binder\Binder_Patterns.cs (4)

382lengthAccess = new BoundBadExpression(node, LookupResultKind.Empty, ImmutableArray<Symbol?>.Empty, ImmutableArray<BoundExpression>.Empty, CreateErrorType(), hasErrors: true) { WasCompilerGenerated = true }; 1000positionalClause, declType, ImmutableArray<TypeWithAnnotations>.Empty, permitDesignations, ref hasErrors, patternsBuilder, diagnostics); 1396addSubpatternsForTuple(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; 1883ImmutableArray<BoundExpression>.Empty); 2847declarations = ImmutableArray<BoundLocalDeclaration>.Empty; 2954return new BoundBadStatement(node, ImmutableArray<BoundNode>.Empty, hasErrors: true); 2965return new BoundBadStatement(node, ImmutableArray<BoundNode>.Empty, hasErrors: true); 3264return ImmutableArray<BoundCatchBlock>.Empty; 3745constructorLocals = ImmutableArray<LocalSymbol>.Empty; 3751blockBody: new BoundBlock(typeDecl, ImmutableArray<LocalSymbol>.Empty, ImmutableArray<BoundStatement>.Empty).MakeCompilerGenerated(), 4011arguments: ImmutableArray<BoundExpression>.Empty, 4012argumentNamesOpt: ImmutableArray<string?>.Empty, 4013argumentRefKindsOpt: ImmutableArray<RefKind>.Empty, 4017argsToParamsOpt: ImmutableArray<int>.Empty, 4094return ImmutableArray<LocalSymbol>.Empty; 4102return ImmutableArray<LocalFunctionSymbol>.Empty; 4110return ImmutableArray<LabelSymbol>.Empty;

Binder\Binder_Symbols.cs (2)

1519receiver = new BoundBadExpression(receiver.Syntax, LookupResultKind.Ambiguous, ImmutableArray<Symbol>.Empty, ImmutableArray.Create(receiver), receiver.Type, hasErrors: true).MakeCompilerGenerated(); 1529receiver = new BoundBadExpression(receiver.Syntax, LookupResultKind.Empty, ImmutableArray<Symbol>.Empty, childBoundNodes: [AdjustBadExpressionChild(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\DecisionDagBuilder_CheckOrReachability.cs (1)

1097ImmutableArray<BoundPropertySubpattern>.Empty, isExplicitNotNullTest: false, variable: null, variableAccess: null, node.InputType, node.InputType);

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)

745ImmutableArray<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)

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

Binder\RefSafetyAnalysis.cs (1)

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

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

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

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

551return ImmutableArray<Symbol>.Empty;

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

1379ImmutableArray<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)

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

Binder\WithUsingNamespacesAndTypesBinder.cs (1)

398return 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)

177return Synthesized(syntax, receiverOpt, initialBindingReceiverIsSubjectToCloning: initialBindingReceiverIsSubjectToCloning, method, ImmutableArray<BoundExpression>.Empty); 491: this(syntax, aliasOpt, boundContainingTypeOpt, ImmutableArray<BoundExpression>.Empty, typeWithAnnotations, hasErrors) 597: this(syntax, locals, ImmutableArray<MethodSymbol>.Empty, hasUnsafeModifier: false, instrumentation: null, statements, hasErrors) 603return new BoundBlock(syntax, ImmutableArray<LocalSymbol>.Empty, ImmutableArray.Create(statement)) 609return new BoundBlock(syntax, ImmutableArray<LocalSymbol>.Empty, statements) { WasCompilerGenerated = true }; 614return 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)

254useSiteInfo.AccumulatesDependencies ? useSiteInfo.Dependencies.AsImmutableOrEmpty() : ImmutableArray<AssemblySymbol>.Empty); 995ImmutableArray<DiagnosticInfo>.Empty, 996ImmutableArray<AssemblySymbol>.Empty); 1086public static readonly ReturnInferenceCacheKey Empty = new ReturnInferenceCacheKey(ImmutableArray<TypeWithAnnotations>.Empty, ImmutableArray<RefKind>.Empty, null); 1154parameterTypes = ImmutableArray<TypeWithAnnotations>.Empty; 1155parameterRefKinds = ImmutableArray<RefKind>.Empty; 1240?? rebind(ReallyInferReturnType(delegateType: null, ImmutableArray<TypeWithAnnotations>.Empty, ImmutableArray<RefKind>.Empty)); 1294ImmutableArray<DiagnosticInfo>.Empty, 1295ImmutableArray<AssemblySymbol>.Empty))

CodeGen\CodeGenerator.cs (4)

203dynamicTransformFlags: ImmutableArray<bool>.Empty, 204tupleElementNames: ImmutableArray<string>.Empty, 252asyncYieldPoints = ImmutableArray<int>.Empty; 253asyncResumePoints = ImmutableArray<int>.Empty;

CodeGen\EmitStatement.cs (2)

1794ImmutableArray<bool>.Empty; 1797ImmutableArray<string>.Empty;

CodeGen\Optimizer.cs (2)

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

CommandLine\CSharpCommandLineParser.cs (2)

80ImmutableArray<KeyValuePair<string, string>> pathMap = ImmutableArray<KeyValuePair<string, string>>.Empty; 1989var 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)

496ImmutableArray<SyntaxTree>.Empty, 1038syntaxAndDeclarations: syntaxAndDeclarations.WithExternalSyntaxTrees(ImmutableArray<SyntaxTree>.Empty)); 1636var previousSubmissionImports = previousSubmission is object ? Imports.ExpandPreviousSubmissionImports(previousSubmission.GlobalImports, this) : ImmutableArray<NamespaceOrTypeAndUsingDirective>.Empty; 1840ImmutableArray<Symbol>.Empty, 1841ImmutableArray<Location>.Empty 3346return new ReadOnlyBindingDiagnostic<AssemblySymbol>(result.AsImmutable(), ImmutableArray<AssemblySymbol>.Empty); 4215: ImmutableArray<CustomModifier>.Empty; 4924return 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)

1106: ImmutableArray<ISymbol>.Empty; 1120: ImmutableArray<ISymbol>.Empty; 1134: ImmutableArray<ISymbol>.Empty; 1157: ImmutableArray<IPropertySymbol>.Empty; 1601return ImmutableArray<ISymbol>.Empty; 1613return ImmutableArray<ISymbol>.Empty; 1969return SymbolInfoFactory.Create(ImmutableArray<Symbol>.Empty, LookupResultKind.Empty, isDynamic); 2166conversion = Conversion.MakeConditionalExpression(ImmutableArray<Conversion>.Empty); 2299return ImmutableArray<Symbol>.Empty; 2316return ImmutableArray<IPropertySymbol>.Empty; 3361memberGroup = ImmutableArray<Symbol>.Empty; 4072candidateConstructors = ImmutableArray<MethodSymbol>.Empty; 4107return ImmutableArray<IPropertySymbol>.Empty; 4117return ImmutableArray<IPropertySymbol>.Empty; 5066return ImmutableArray<ISymbol>.Empty; 5244: ImmutableArray<ISymbol>.Empty; 5477xmlNamespaces: 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)

770return ImmutableArray<ParameterSymbol>.Empty; 786return ImmutableArray<TypeParameterSymbol>.Empty; 865nodes = 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, 567ImmutableArray<LocalSymbol>.Empty, 572ImmutableArray<BoundCatchBlock>.Empty, 575ImmutableArray<LocalSymbol>.Empty,

Compiler\MethodCompiler.cs (26)

315ImmutableArray<EncLambdaInfo>.Empty, 316ImmutableArray<LambdaRuntimeRudeEditInfo>.Empty, 317ImmutableArray<EncClosureInfo>.Empty, 318ImmutableArray<StateMachineStateDebugInfo>.Empty, 325codeCoverageSpans: ImmutableArray<SourceSpan>.Empty, 663var processedInitializers = new Binder.ProcessedFieldInitializers() { BoundInitializers = ImmutableArray<BoundInitializer>.Empty }; 803ImmutableArray<EncLambdaInfo>.Empty, 804ImmutableArray<LambdaRuntimeRudeEditInfo>.Empty, 805ImmutableArray<EncClosureInfo>.Empty, 813codeCoverageSpans: ImmutableArray<SourceSpan>.Empty, 948sourceMethod.SetDiagnostics(ImmutableArray<Diagnostic>.Empty, out diagsWritten); 1009body = new BoundBlock(methodSymbol.GetNonNullSyntaxNode(), ImmutableArray<LocalSymbol>.Empty, ImmutableArray<BoundStatement>.Empty) { WasCompilerGenerated = true }; 1052new BoundBlock(analyzedInitializers.Syntax, ImmutableArray<LocalSymbol>.Empty, analyzedInitializers.Statements), // The block is necessary to establish the right local scope for the analysis 1247codeCoverageSpans = ImmutableArray<SourceSpan>.Empty; 1271boundStatements = ImmutableArray<BoundStatement>.Empty; 1451exceptionHandlers: ImmutableArray<Cci.ExceptionHandlerRegion>.Empty, 1454localScopes: ImmutableArray<Cci.LocalScope>.Empty, 1457lambdaDebugInfo: ImmutableArray<EncLambdaInfo>.Empty, 1458orderedLambdaRuntimeRudeEdits: ImmutableArray<LambdaRuntimeRudeEditInfo>.Empty, 1459closureDebugInfo: ImmutableArray<EncClosureInfo>.Empty, 1464StateMachineStatesDebugInfo.Create(variableSlotAllocator: null, ImmutableArray<StateMachineStateDebugInfo>.Empty), 1466codeCoverageSpans: ImmutableArray<SourceSpan>.Empty, 1499codeCoverageSpans = ImmutableArray<SourceSpan>.Empty; 1622codeCoverageSpans = ImmutableArray<SourceSpan>.Empty; 2101statements = ImmutableArray<BoundStatement>.Empty;

CSharpCompilationOptions.cs (1)

347value = ImmutableArray<byte>.Empty;

CSharpParseOptions.cs (2)

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

Declarations\DeclarationTreeBuilder.cs (13)

135return ImmutableArray<SingleNamespaceOrTypeDeclaration>.Empty; 191var diagnostics = ImmutableArray<Diagnostic>.Empty; 228children: ImmutableArray<SingleTypeDeclaration>.Empty, 229diagnostics: ImmutableArray<Diagnostic>.Empty, 256children: ImmutableArray<SingleTypeDeclaration>.Empty, 310return ImmutableArray<ReferenceDirective>.Empty; 344diagnostics: ImmutableArray<Diagnostic>.Empty, 356diagnostics: ImmutableArray<Diagnostic>.Empty); 470referenceDirectives: isForScript ? GetReferenceDirectives(compilationUnit) : ImmutableArray<ReferenceDirective>.Empty, 517diagnostics: ImmutableArray<Diagnostic>.Empty); 794return ImmutableArray<SingleTypeDeclaration>.Empty; 833children: ImmutableArray<SingleTypeDeclaration>.Empty, 871children: ImmutableArray<SingleTypeDeclaration>.Empty,

DocumentationComments\SourceDocumentationCommentUtils.cs (2)

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

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (2)

414var otherParameterTypes = ImmutableArray<TypeWithAnnotations>.Empty; 930var 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)

188return 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 (20)

Emitter\Model\PEModuleBuilder.cs (2)

151public sealed override ImmutableArray<Cci.UsedNamespaceOrType> GetImports() => ImmutableArray<Cci.UsedNamespaceOrType>.Empty; 1821attribute = 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)

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

Emitter\NoPia\EmbeddedTypesManager.cs (2)

179ImmutableArray<KeyValuePair<string, TypedConstant>>.Empty); 188ImmutableArray<KeyValuePair<string, TypedConstant>>.Empty);

Errors\CSDiagnosticInfo.cs (5)

24: this(code, Array.Empty<object>(), ImmutableArray<Symbol>.Empty, ImmutableArray<Location>.Empty) 29: this(code, args, ImmutableArray<Symbol>.Empty, ImmutableArray<Location>.Empty) 34: 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)

470return (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 }; 179return body.Update(body.Locals, ImmutableArray<MethodSymbol>.Empty, body.HasUnsafeModifier, body.Instrumentation, builder.ToImmutableAndFree());

FlowAnalysis\NullableWalker.cs (9)

693: ImmutableArray<string>.Empty; 718checkMemberStateOnConstructorExit(method, member, state, thisSlot, exitLocation, membersWithStateEnforcedByRequiredMembers: ImmutableArray<string>.Empty, forcePropertyAnalysis: true); 826var info = new CSDiagnosticInfo(errorCode, new object[] { symbol.Kind.Localize(), symbol.Name }, ImmutableArray<Symbol>.Empty, additionalLocations: symbol.Locations); 902return ImmutableArray<Symbol>.Empty; 947=> ImmutableArray<Symbol>.Empty, 6009_ => ImmutableArray<NamedTypeSymbol>.Empty, 7934return ImmutableArray<VisitResult>.Empty; 9669_ => (null, ImmutableArray<ParameterSymbol>.Empty), 13178VisitArguments(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)

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

Lowering\AsyncRewriter\AsyncIteratorMethodToStateMachineRewriter.cs (1)

161ImmutableArray<BoundExpression>.Empty));

Lowering\AsyncRewriter\AsyncMethodToStateMachineRewriter.cs (6)

158F.Block(ImmutableArray<LocalSymbol>.Empty, 266: ImmutableArray<BoundExpression>.Empty)); 441typeArgumentsWithAnnotations: ImmutableArray<TypeWithAnnotations>.Empty, 442loweredArguments: ImmutableArray<BoundExpression>.Empty, 443argumentNames: ImmutableArray<string>.Empty, 444refKinds: ImmutableArray<RefKind>.Empty,

Lowering\AsyncRewriter\AsyncRewriter.cs (1)

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

Lowering\ClosureConversion\ClosureConversion.cs (2)

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

Lowering\ClosureConversion\ExpressionLambdaRewriter.cs (5)

358return new BoundBadExpression(node.Syntax, default(LookupResultKind), ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundExpression>(node), ExpressionType); 389return new BoundBadExpression(node.Syntax, 0, ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundExpression>(node), ExpressionType); 1141return new BoundBadExpression(node.Syntax, default(LookupResultKind), ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundExpression>(node), node.Type); 1148return new BoundBadExpression(node.Syntax, default(LookupResultKind), ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundExpression>(node), node.Type); 1180return new BoundBadExpression(node.Syntax, default(LookupResultKind), ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundExpression>(node), node.Type);

Lowering\ClosureConversion\LambdaCapturedVariable.cs (1)

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

Lowering\Instrumentation\CodeCoverageInstrumenter.cs (1)

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

Lowering\Instrumentation\LocalStateTracingInstrumenter.cs (1)

630return _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)

287ImmutableArray<BoundCatchBlock>.Empty, 417ImmutableArray<LocalSymbol>.Empty,

Lowering\LocalRewriter\LocalRewriter.cs (4)

169codeCoverageSpans = codeCoverageInstrumenter?.DynamicAnalysisSpans ?? ImmutableArray<SourceSpan>.Empty; 176codeCoverageSpans = ImmutableArray<SourceSpan>.Empty; 602return new BoundBadExpression(syntax, LookupResultKind.NotReferencable, ImmutableArray<Symbol?>.Empty, children, resultType); 792rewrittenStatements = ImmutableArray<BoundStatement>.Empty;

Lowering\LocalRewriter\LocalRewriter_AsOperator.cs (1)

73locals: ImmutableArray<LocalSymbol>.Empty,

Lowering\LocalRewriter\LocalRewriter_AssignmentOperator.cs (1)

200ImmutableArray<BoundExpression>.Empty,

Lowering\LocalRewriter\LocalRewriter_BinaryOperator.cs (3)

871locals: ImmutableArray<LocalSymbol>.Empty, 1415locals: ImmutableArray<LocalSymbol>.Empty, 1983locals: 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)

532sideEffects: ImmutableArray<BoundExpression>.Empty, 825ImmutableArray<LocalSymbol>.Empty, 903visitedArgumentsBuilder[argIndex] = _factory.Sequence(ImmutableArray<LocalSymbol>.Empty, ImmutableArray.Create<BoundExpression>(store), local); 922return ImmutableArray<BoundInterpolatedStringArgumentPlaceholder>.Empty; 1524ImmutableArray<BoundExpression>.Empty, 1663ImmutableArray<LocalSymbol>.Empty, 1727locals: ImmutableArray<LocalSymbol>.Empty,

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (4)

712locals: ImmutableArray<LocalSymbol>.Empty, 1224rewrittenReceiver = _factory.New(constructor, ImmutableArray<BoundExpression>.Empty); 1429new BoundBlock(iteratorBody.Syntax, locals: ImmutableArray<LocalSymbol>.Empty, statements); 1586ImmutableArray<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, 380locals: ImmutableArray<LocalSymbol>.Empty, 484helperCall = new BoundBadExpression(fixedInitializer.Syntax, LookupResultKind.NotInvocable, ImmutableArray<Symbol?>.Empty, ImmutableArray<BoundExpression>.Empty, ErrorTypeSymbol.UnknownResultType); 545lengthCall = new BoundBadExpression(fixedInitializer.Syntax, LookupResultKind.NotInvocable, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create<BoundExpression>(factory.Local(pinnedTemp)), ErrorTypeSymbol.UnknownResultType);

Lowering\LocalRewriter\LocalRewriter_ForEachStatement.cs (3)

264tryBlock: new BoundBlock(forEachSyntax, locals: ImmutableArray<LocalSymbol>.Empty, statements: ImmutableArray.Create(whileLoop)), 265catchBlocks: ImmutableArray<BoundCatchBlock>.Empty, 415locals: ImmutableArray<LocalSymbol>.Empty,

Lowering\LocalRewriter\LocalRewriter_FunctionPointerInvocation.cs (1)

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

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)

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

Lowering\LocalRewriter\LocalRewriter_ObjectCreationExpression.cs (8)

107ImmutableArray<BoundExpression>.Empty, 355ImmutableArray<BoundExpression>.Empty, 394newGuid = new BoundBadExpression(node.Syntax, LookupResultKind.NotCreatable, ImmutableArray<Symbol?>.Empty, ImmutableArray<BoundExpression>.Empty, ErrorTypeSymbol.UnknownResultType); 412callGetTypeFromCLSID = new BoundBadExpression(node.Syntax, LookupResultKind.OverloadResolutionFailure, ImmutableArray<Symbol?>.Empty, ImmutableArray<BoundExpression>.Empty, ErrorTypeSymbol.UnknownResultType); 428rewrittenObjectCreation = new BoundBadExpression(node.Syntax, LookupResultKind.OverloadResolutionFailure, ImmutableArray<Symbol?>.Empty, ImmutableArray<BoundExpression>.Empty, node.Type);

Lowering\LocalRewriter\LocalRewriter_ObjectOrCollectionInitializerExpression.cs (1)

168ImmutableArray<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)

228: 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)

85tuple.Syntax, sourceTuple: null, wasTargetTyped: true, newArguments, ImmutableArray<string?>.Empty, 86ImmutableArray<bool>.Empty, conversion.Type, conversion.HasErrors); 129syntax, sourceTuple: null, wasTargetTyped: true, fieldAccessorsBuilder.ToImmutableAndFree(), ImmutableArray<string?>.Empty, 130ImmutableArray<bool>.Empty, expr.Type, expr.HasErrors); 165tuple.Syntax, sourceTuple: null, wasTargetTyped: false, newArguments, ImmutableArray<string?>.Empty, 166ImmutableArray<bool>.Empty, tuple.Type, tuple.HasErrors); 313BoundExpression innerSequence = _factory.Sequence(locals: ImmutableArray<LocalSymbol>.Empty, innerEffects.ToImmutableAndFree(), logicalExpression); 327return _factory.Sequence(ImmutableArray<LocalSymbol>.Empty, outerEffects.ToImmutableAndFree(), 335return _factory.Sequence(ImmutableArray<LocalSymbol>.Empty, outerEffects.ToImmutableAndFree(), 344_factory.Sequence(ImmutableArray<LocalSymbol>.Empty, outerEffects.ToImmutableAndFree(), 464argumentNamesOpt: ImmutableArray<string?>.Empty, 465inferredNamesOpt: 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)

708ImmutableArray<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)

271var loweredArguments = ImmutableArray<BoundExpression>.Empty; 373var loweredArguments = ImmutableArray<BoundExpression>.Empty; 415var loweredArguments = ImmutableArray<BoundExpression>.Empty; 517return MakeDynamicOperation(binderConstruction, loweredReceiver, RefKind.None, ImmutableArray<BoundExpression>.Empty, default(ImmutableArray<RefKind>), null, resultType); 677return ImmutableArray<LocalSymbol>.Empty;

Lowering\MethodToClassRewriter.cs (1)

400typeParameters = ImmutableArray<TypeParameterSymbol>.Empty;

Lowering\SpillSequenceSpiller.cs (2)

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

Lowering\StateMachineRewriter\MethodToStateMachineRewriter.cs (1)

430hoistedLocals = ImmutableArray<StateMachineFieldSymbol>.Empty;

Lowering\StateMachineRewriter\RefInitializationHoister.cs (1)

110return _factory.Sequence(ImmutableArray<LocalSymbol>.Empty, sideEffects.ToImmutableAndFree(), last);

Lowering\StateMachineRewriter\StateMachineFieldSymbol.cs (1)

66public 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)

82=> ImmutableArray<ImmutableArray<TypeWithAnnotations>>.Empty; 85=> ImmutableArray<TypeParameterConstraintKind>.Empty; 158: ImmutableArray<CSharpAttributeData>.Empty; 164return InheritsBaseMethodAttributes ? BaseMethod.GetReturnTypeAttributes() : ImmutableArray<CSharpAttributeData>.Empty;

Lowering\SyntheticBoundNodeFactory.cs (15)

241return new BoundBadExpression(Syntax, LookupResultKind.Empty, ImmutableArray<Symbol?>.Empty, ImmutableArray<BoundExpression>.Empty, type, hasErrors: true); 453return Block(ImmutableArray<BoundStatement>.Empty); 458return Block(ImmutableArray<LocalSymbol>.Empty, statements); 498return StatementList(ImmutableArray<BoundStatement>.Empty); 546statements.Add(Try(Block(statement), ImmutableArray<BoundCatchBlock>.Empty, Block(instrumentation.Epilogue))); 818return new BoundBadExpression(Syntax, default(LookupResultKind), ImmutableArray<Symbol?>.Empty, args.AsImmutable(), receiver); 855return Call(receiver, method, ImmutableArray<BoundExpression>.Empty); 924argsToParamsOpt: ImmutableArray<int>.Empty, defaultArguments: default(BitVector), resultKind: LookupResultKind.Viable, type: method.ReturnType) 950return If(condition, ImmutableArray<LocalSymbol>.Empty, thenClause, elseClauseOpt); 1026return MakeSequence(ImmutableArray<LocalSymbol>.Empty, parts); 1055return new BoundSequence(Syntax, ImmutableArray<LocalSymbol>.Empty, sideEffects.AsImmutableOrNull(), result, resultType) { WasCompilerGenerated = true }; 1616return new BoundCatchBlock(Syntax, ImmutableArray<LocalSymbol>.Empty, source, source.Type, exceptionFilterPrologueOpt: null, exceptionFilterOpt: null, body: block, isSynthesizedAsyncCatchAll: false); 1621return new BoundTryStatement(Syntax, tryBlock, ImmutableArray<BoundCatchBlock>.Empty, faultBlock, finallyLabelOpt: null, preferFaultHandler: true); 1858locals: ImmutableArray<LocalSymbol>.Empty,

Operations\CSharpOperationFactory.cs (24)

348return ImmutableArray<TOperation>.Empty; 385return ImmutableArray<IOperation>.Empty; 550dimensions = ImmutableArray<BoundExpression>.Empty; 622var arguments = ImmutableArray<IArgumentOperation>.Empty; 730declarations: ImmutableArray<BoundAnonymousPropertyDeclaration>.Empty, 779return CreateBoundDynamicMemberAccessOperation(implicitReceiver, typeArgumentsOpt: ImmutableArray<TypeSymbol>.Empty, memberName: "Add", 912arguments = ImmutableArray<IArgumentOperation>.Empty; 929ImmutableArray<ITypeSymbol> typeArguments = ImmutableArray<ITypeSymbol>.Empty; 979ImmutableArray<ITypeSymbol> typeArguments = ImmutableArray<ITypeSymbol>.Empty; 996return new DynamicInvocationOperation(operation, arguments, argumentNames: ImmutableArray<string?>.Empty, argumentRefKinds: ImmutableArray<RefKind>.Empty, _semanticModel, syntax, type, isImplicit); 1981return ImmutableArray<IArgumentOperation>.Empty; 2010return new VariableDeclaratorOperation(local.GetPublicSymbol(), initializer: null, ignoredArguments: ImmutableArray<IOperation>.Empty, semanticModel: _semanticModel, syntax: declaratorSyntax, isImplicit: false); 2022var nextVariables = ImmutableArray<IOperation>.Empty; 2530return new InvalidOperation(ImmutableArray<IOperation>.Empty, _semanticModel, syntax, type, placeholder.ConstantValueOpt, isImplicit); 2599: ImmutableArray<IPatternOperation>.Empty; 2602: ImmutableArray<IPropertySubpatternOperation>.Empty; 2620: ImmutableArray<IPatternOperation>.Empty; 2626propertySubpatterns: ImmutableArray<IPropertySubpatternOperation>.Empty, 2902var reference = OperationFactory.CreateInvalidOperation(_semanticModel, subpatternSyntax, ImmutableArray<IOperation>.Empty, isImplicit: true); 2924matchedType: previousType, deconstructSymbol: null, deconstructionSubpatterns: ImmutableArray<IPatternOperation>.Empty, 2948reference = new PropertyReferenceOperation(property.GetPublicSymbol(), constrainedToType: null, ImmutableArray<IArgumentOperation>.Empty, 2956reference = OperationFactory.CreateInvalidOperation(_semanticModel, nameSyntax, ImmutableArray<IOperation>.Empty, isImplicit: false); 2988return 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)

92builder.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)

368typeParameters = ImmutableArray<TypeParameterSymbol>.Empty;

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

101get { return ImmutableArray<TypeParameterSymbol>.Empty; } 106get { return ImmutableArray<TypeWithAnnotations>.Empty; } 143return ImmutableArray<NamedTypeSymbol>.Empty; 148return ImmutableArray<NamedTypeSymbol>.Empty; 153return ImmutableArray<NamedTypeSymbol>.Empty; 163return ImmutableArray<NamedTypeSymbol>.Empty; 257return ImmutableArray<string>.Empty; 272return 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)

172TypeParameters = ImmutableArray<TypeParameterSymbol>.Empty; 239internal override ImmutableArray<NamedTypeSymbol> GetInterfacesToEmit() => ImmutableArray<NamedTypeSymbol>.Empty; 241internal 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)

196return ImmutableArray<NamedTypeSymbol>.Empty; 201return ImmutableArray<NamedTypeSymbol>.Empty; 206return ImmutableArray<NamedTypeSymbol>.Empty; 221get { return ImmutableArray<Location>.Empty; } 226get { return ImmutableArray<SyntaxReference>.Empty; } 248return ImmutableArray<NamedTypeSymbol>.Empty; 316return 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)

154return ImmutableArray<int>.Empty; 264return ImmutableArray<Symbol>.Empty; 269return ImmutableArray<Symbol>.Empty; 274return ImmutableArray<NamedTypeSymbol>.Empty; 279return ImmutableArray<NamedTypeSymbol>.Empty; 284return ImmutableArray<NamedTypeSymbol>.Empty; 315return ImmutableArray<Location>.Empty; 323return ImmutableArray<SyntaxReference>.Empty; 598return ImmutableArray<NamedTypeSymbol>.Empty;

Symbols\AssemblySymbol.cs (1)

290return 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)

28return ImmutableArray<MetadataReference>.Empty;

Symbols\Compilation_WellKnownMembers.cs (4)

411arguments = ImmutableArray<TypedConstant>.Empty; 417namedStringArguments = ImmutableArray<KeyValuePair<string, TypedConstant>>.Empty; 458arguments: ImmutableArray<TypedConstant>.Empty, 459namedArguments: 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)

75return ImmutableArray<Location>.Empty; 83return ImmutableArray<SyntaxReference>.Empty; 91return ImmutableArray<NamedTypeSymbol>.Empty; 135return ImmutableArray<Symbol>.Empty; 140return ImmutableArray<Symbol>.Empty; 145return ImmutableArray<NamedTypeSymbol>.Empty; 150return ImmutableArray<NamedTypeSymbol>.Empty;

Symbols\ErrorMethodSymbol.cs (8)

95get { return ImmutableArray<Location>.Empty; } 102return ImmutableArray<SyntaxReference>.Empty; 123get { return ImmutableArray<CustomModifier>.Empty; } 133get { return ImmutableArray<MethodSymbol>.Empty; } 147get { return ImmutableArray<ParameterSymbol>.Empty; } 152get { return ImmutableArray<TypeParameterSymbol>.Empty; } 157get { return ImmutableArray<TypeWithAnnotations>.Empty; } 256return 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)

119ImmutableArray<CSharpAttributeData>.Empty :

Symbols\ExtendedErrorTypeSymbol.cs (2)

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

Symbols\Extensions\RewrittenMethodSymbol.cs (1)

74public sealed override ImmutableArray<MethodSymbol> ExplicitInterfaceImplementations => ImmutableArray<MethodSymbol>.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)

73public override ImmutableArray<Location> Locations => ImmutableArray<Location>.Empty; 74public override ImmutableArray<SyntaxReference> DeclaringSyntaxReferences => ImmutableArray<SyntaxReference>.Empty; 93internal override ImmutableArray<int> InterpolatedStringHandlerArgumentIndexes => ImmutableArray<int>.Empty;

Symbols\FunctionPointers\FunctionPointerTypeSymbol.cs (7)

81public override ImmutableArray<Location> Locations => ImmutableArray<Location>.Empty; 82public override ImmutableArray<SyntaxReference> DeclaringSyntaxReferences => ImmutableArray<SyntaxReference>.Empty; 93public override ImmutableArray<Symbol> GetMembers() => ImmutableArray<Symbol>.Empty; 94public override ImmutableArray<Symbol> GetMembers(string name) => ImmutableArray<Symbol>.Empty; 95public override ImmutableArray<NamedTypeSymbol> GetTypeMembers() => ImmutableArray<NamedTypeSymbol>.Empty; 96public override ImmutableArray<NamedTypeSymbol> GetTypeMembers(ReadOnlyMemory<char> name) => ImmutableArray<NamedTypeSymbol>.Empty; 98internal 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)

44return ImmutableArray<ParameterSymbol>.Empty; 62return ImmutableArray<TypeWithAnnotations>.Empty; 574return ImmutableArray<TypeParameterSymbol>.Empty; 592return ImmutableArray<TypeSymbol>.Empty; 878return 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)

815return ImmutableArray<NamedTypeSymbol>.Empty; 929return ImmutableArray<CSharpAttributeData>.Empty; 1740m = ImmutableArray<Symbol>.Empty; 1753m = ImmutableArray<Symbol>.Empty; 1849return ImmutableArray<NamedTypeSymbol>.Empty; 1869return ImmutableArray<SyntaxReference>.Empty; 1907return ImmutableArray<TypeWithAnnotations>.Empty; 1915return ImmutableArray<TypeParameterSymbol>.Empty; 2797return ImmutableArray<string>.Empty; 3061_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; 879return ImmutableArray<int>.Empty; 895return ImmutableArray<int>.Empty; 964return ImmutableArray<CustomModifier>.Empty; 1078return ImmutableArray<SyntaxReference>.Empty; 1163ImmutableInterlocked.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; 763return ImmutableArray<CSharpAttributeData>.Empty; 770result = ImmutableArray<CSharpAttributeData>.Empty; 801return ImmutableArray<PropertySymbol>.Empty; 901return ImmutableArray<ParameterSymbol>.Empty;

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

230declaredConstraintTypes = ImmutableArray<TypeWithAnnotations>.Empty; 443return ImmutableArray<SyntaxReference>.Empty; 619return (bounds != null) ? bounds.ConstraintTypes : ImmutableArray<TypeWithAnnotations>.Empty; 625return (bounds != null) ? bounds.Interfaces : ImmutableArray<NamedTypeSymbol>.Empty;

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

211var parameterTypes = ImmutableArray<TypeWithAnnotations>.Empty;

Symbols\MethodSymbol.cs (5)

106internal virtual ImmutableArray<string> NotNullMembers => ImmutableArray<string>.Empty; 108internal virtual ImmutableArray<string> NotNullWhenTrueMembers => ImmutableArray<string>.Empty; 110internal virtual ImmutableArray<string> NotNullWhenFalseMembers => ImmutableArray<string>.Empty; 402return ImmutableArray<CSharpAttributeData>.Empty; 935internal virtual ImmutableArray<NamedTypeSymbol> UnmanagedCallingConventionTypes => ImmutableArray<NamedTypeSymbol>.Empty;

Symbols\MissingAssemblySymbol.cs (3)

121return ImmutableArray<Location>.Empty; 132return ImmutableArray<AssemblySymbol>.Empty; 142return ImmutableArray<AssemblySymbol>.Empty;

Symbols\MissingModuleSymbol.cs (3)

127return ImmutableArray<Location>.Empty; 156return ImmutableArray<AssemblyIdentity>.Empty; 161return 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 (4)

279: ImmutableArray<Symbol>.Empty; 282: ImmutableArray<Symbol>.Empty; 286return ImmutableArray<MethodSymbol>.Empty; 323return 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)

91return ImmutableArray<NamedTypeSymbol>.Empty; 135return ImmutableArray<Symbol>.Empty; 140return ImmutableArray<Symbol>.Empty; 145return ImmutableArray<NamedTypeSymbol>.Empty; 150return ImmutableArray<NamedTypeSymbol>.Empty; 155return ImmutableArray<NamedTypeSymbol>.Empty; 186return ImmutableArray<Location>.Empty; 194return 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)

546get { return ImmutableArray<MethodSymbol>.Empty; } 567return ImmutableArray<ParameterSymbol>.Empty;

Symbols\ReferenceManager.cs (1)

148return 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)

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

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

Symbols\Source\LambdaSymbol.cs (5)

185get { return ImmutableArray<MethodSymbol>.Empty; } 195get { return ImmutableArray<TypeWithAnnotations>.Empty; } 200get { return ImmutableArray<TypeParameterSymbol>.Empty; } 419public override ImmutableArray<ImmutableArray<TypeWithAnnotations>> GetTypeParameterConstraintTypes() => ImmutableArray<ImmutableArray<TypeWithAnnotations>>.Empty; 421public override ImmutableArray<TypeParameterConstraintKind> GetTypeParameterConstraintKinds() => ImmutableArray<TypeParameterConstraintKind>.Empty;

Symbols\Source\LocalFunctionSymbol.cs (2)

72_typeParameters = ImmutableArray<SourceMethodTypeParameterSymbol>.Empty; 342public override ImmutableArray<MethodSymbol> ExplicitInterfaceImplementations => ImmutableArray<MethodSymbol>.Empty;

Symbols\Source\ParameterHelpers.cs (2)

147_ => ImmutableArray<CustomModifier>.Empty 1217return ImmutableArray<CustomModifier>.Empty;

Symbols\Source\SourceAssemblySymbol.cs (3)

1305netModuleNames = ImmutableArray<string>.Empty; 1306return ImmutableArray<CSharpAttributeData>.Empty; 1996ImmutableArray<TypedConstant>.Empty,

Symbols\Source\SourceClonedParameterSymbol.cs (1)

43return ImmutableArray<SyntaxReference>.Empty;

Symbols\Source\SourceComplexParameterSymbol.cs (2)

353ImmutableArray<LocalSymbol>.Empty, 1777public override ImmutableArray<CustomModifier> RefCustomModifiers => ImmutableArray<CustomModifier>.Empty;

Symbols\Source\SourceConstructorSymbolBase.cs (3)

142get { return ImmutableArray<TypeParameterSymbol>.Empty; } 146=> ImmutableArray<ImmutableArray<TypeWithAnnotations>>.Empty; 149=> ImmutableArray<TypeParameterConstraintKind>.Empty;

Symbols\Source\SourceCustomEventSymbol.cs (1)

169ImmutableArray<EventSymbol>.Empty :

Symbols\Source\SourceDelegateMethodSymbol.cs (4)

149return ImmutableArray<TypeParameterSymbol>.Empty; 154=> ImmutableArray<ImmutableArray<TypeWithAnnotations>>.Empty; 157=> ImmutableArray<TypeParameterConstraintKind>.Empty; 290_refCustomModifiers = ImmutableArray<CustomModifier>.Empty;

Symbols\Source\SourceDestructorSymbol.cs (4)

107get { return ImmutableArray<ParameterSymbol>.Empty; } 112get { return ImmutableArray<TypeParameterSymbol>.Empty; } 116=> ImmutableArray<ImmutableArray<TypeWithAnnotations>>.Empty; 119=> 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)

201get { 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 (1)

229ImmutableArray<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 (1)

856return ImmutableArray<MethodSymbol>.Empty;

Symbols\Source\SourceMethodSymbolWithAttributes.cs (5)

104return (this.syntaxReferenceOpt == null) ? ImmutableArray<SyntaxReference>.Empty : ImmutableArray.Create(this.syntaxReferenceOpt); 506return data != null ? data.ConditionalSymbols : ImmutableArray<string>.Empty; 675GetDecodedWellKnownAttributeData()?.NotNullMembers ?? ImmutableArray<string>.Empty; 678GetDecodedWellKnownAttributeData()?.NotNullWhenTrueMembers ?? ImmutableArray<string>.Empty; 681GetDecodedWellKnownAttributeData()?.NotNullWhenFalseMembers ?? ImmutableArray<string>.Empty;

Symbols\Source\SourceNamedTypeSymbol.cs (7)

146return ImmutableArray<TypeParameterSymbol>.Empty; 273return (constraintTypes.Length > 0) ? constraintTypes[ordinal] : ImmutableArray<TypeWithAnnotations>.Empty; 321var results = ImmutableArray<TypeParameterConstraintClause>.Empty; 377results = ImmutableArray<TypeParameterConstraintClause>.Empty; 402var results = ImmutableArray<TypeParameterConstraintClause>.Empty; 460results = ImmutableArray<TypeParameterConstraintClause>.Empty; 1607return 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); 679return 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)

985=> ImmutableArray<TypeParameterSymbol>.Empty; 988=> ImmutableArray<ImmutableArray<TypeWithAnnotations>>.Empty; 991=> ImmutableArray<TypeParameterConstraintKind>.Empty; 1141return 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)

266_lazyRefCustomModifiers = ImmutableArray<CustomModifier>.Empty; 337get { return ImmutableArray<TypeParameterSymbol>.Empty; } 341=> ImmutableArray<ImmutableArray<TypeWithAnnotations>>.Empty; 344=> ImmutableArray<TypeParameterConstraintKind>.Empty; 618explicitInterfaceImplementations = ImmutableArray<MethodSymbol>.Empty; 627? ImmutableArray<MethodSymbol>.Empty 776return ImmutableArray<ParameterSymbol>.Empty;

Symbols\Source\SourcePropertySymbol.cs (1)

623return ImmutableArray<ParameterSymbol>.Empty;

Symbols\Source\SourcePropertySymbolBase.cs (7)

122_lazyExplicitInterfaceImplementations = ImmutableArray<PropertySymbol>.Empty; 206_lazyRefCustomModifiers = ImmutableArray<CustomModifier>.Empty; 251_lazyRefCustomModifiers = _refKind != RefKind.None ? overriddenOrImplementedProperty.RefCustomModifiers : ImmutableArray<CustomModifier>.Empty; 280ImmutableArray<PropertySymbol>.Empty : 289GetDecodedWellKnownAttributeData()?.NotNullMembers ?? ImmutableArray<string>.Empty; 292GetDecodedWellKnownAttributeData()?.NotNullWhenTrueMembers ?? ImmutableArray<string>.Empty; 295GetDecodedWellKnownAttributeData()?.NotNullWhenFalseMembers ?? ImmutableArray<string>.Empty;

Symbols\Source\SourceSimpleParameterSymbol.cs (2)

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

Symbols\Source\SourceTypeParameterSymbol.cs (3)

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

Symbols\Source\SourceUserDefinedOperatorSymbolBase.cs (3)

1000get { return ImmutableArray<TypeParameterSymbol>.Empty; } 1004=> ImmutableArray<ImmutableArray<TypeWithAnnotations>>.Empty; 1007=> ImmutableArray<TypeParameterConstraintKind>.Empty;

Symbols\Source\SynthesizedSourceOrdinaryMethodSymbol.cs (3)

42public sealed override ImmutableArray<TypeParameterSymbol> TypeParameters => ImmutableArray<TypeParameterSymbol>.Empty; 44public sealed override ImmutableArray<ImmutableArray<TypeWithAnnotations>> GetTypeParameterConstraintTypes() => ImmutableArray<ImmutableArray<TypeWithAnnotations>>.Empty; 46public sealed override ImmutableArray<TypeParameterConstraintKind> GetTypeParameterConstraintKinds() => ImmutableArray<TypeParameterConstraintKind>.Empty;

Symbols\Source\ThisParameterSymbol.cs (4)

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

Symbols\Source\TypeParameterConstraintClause.cs (2)

75ImmutableArray<TypeWithAnnotations>.Empty); 79ImmutableArray<TypeWithAnnotations>.Empty);

Symbols\Source\TypeParameterInfo.cs (3)

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

Symbols\SubstitutedMethodSymbol.cs (2)

276return ImmutableArray<MethodSymbol>.Empty; 349return ImmutableArray<ParameterSymbol>.Empty;

Symbols\SubstitutedNamedTypeSymbol.cs (2)

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

Symbols\Symbol.cs (1)

498return ImmutableArray<SyntaxReference>.Empty;

Symbols\Symbol_Attributes.cs (4)

35return ImmutableArray<CSharpAttributeData>.Empty; 397boundAttributes = ImmutableArray<CSharpAttributeData>.Empty; 662binders = ImmutableArray<Binder>.Empty; 663return ImmutableArray<AttributeSyntax>.Empty;

Symbols\SymbolExtensions.cs (4)

484refCustomModifiers = ImmutableArray<CustomModifier>.Empty; 502refCustomModifiers = ImmutableArray<CustomModifier>.Empty; 508refCustomModifiers = ImmutableArray<CustomModifier>.Empty; 519refCustomModifiers = ImmutableArray<CustomModifier>.Empty;

Symbols\Synthesized\GeneratedLabelSymbol.cs (1)

51return ImmutableArray<SyntaxReference>.Empty;

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

131public override ImmutableArray<TypeParameterSymbol> TypeParameters => ImmutableArray<TypeParameterSymbol>.Empty; 163public override ImmutableArray<Location> Locations => ImmutableArray<Location>.Empty; 165public override ImmutableArray<SyntaxReference> DeclaringSyntaxReferences => ImmutableArray<SyntaxReference>.Empty; 221public override ImmutableArray<NamedTypeSymbol> GetTypeMembers() => ImmutableArray<NamedTypeSymbol>.Empty; 223public override ImmutableArray<NamedTypeSymbol> GetTypeMembers(ReadOnlyMemory<char> name, int arity) => ImmutableArray<NamedTypeSymbol>.Empty; 225public override ImmutableArray<NamedTypeSymbol> GetTypeMembers(ReadOnlyMemory<char> name) => ImmutableArray<NamedTypeSymbol>.Empty; 231internal 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)

876public override ImmutableArray<Location> Locations => ImmutableArray<Location>.Empty; 878public override ImmutableArray<SyntaxReference> DeclaringSyntaxReferences => ImmutableArray<SyntaxReference>.Empty; 937: ImmutableArray<NamedTypeSymbol>.Empty; 949internal override ImmutableArray<string> GetAppliedConditionalSymbols() => ImmutableArray<string>.Empty;

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

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

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

101Parameters: ImmutableArray<ParameterSymbol>.Empty);

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

52public override ImmutableArray<SyntaxReference> DeclaringSyntaxReferences => ImmutableArray<SyntaxReference>.Empty; 83ImmutableArray<ParameterSymbol>.Empty); 168public override ImmutableArray<SyntaxReference> DeclaringSyntaxReferences => ImmutableArray<SyntaxReference>.Empty;

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

35Parameters: ImmutableArray<ParameterSymbol>.Empty);

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

97ImmutableArray<ParameterSymbol>.Empty);

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

44Parameters: ImmutableArray<ParameterSymbol>.Empty);

Symbols\Synthesized\SynthesizedAccessorValueParameterSymbol.cs (1)

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

Symbols\Synthesized\SynthesizedBackingFieldSymbol.cs (1)

67=> ImmutableArray<SyntaxReference>.Empty;

Symbols\Synthesized\SynthesizedContainer.cs (10)

40_typeParameters = ImmutableArray<TypeParameterSymbol>.Empty; 84public override ImmutableArray<Location> Locations => ImmutableArray<Location>.Empty; 86public 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 (5)

178get { return ImmutableArray<TypeWithAnnotations>.Empty; } 183get { return ImmutableArray<TypeParameterSymbol>.Empty; } 190get { return ImmutableArray<MethodSymbol>.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; } 222get { return ImmutableArray<MethodSymbol>.Empty; } 279return ImmutableArray<string>.Empty; 300ImmutableArray<BoundExpression>.Empty, 438locals: ImmutableArray<LocalSymbol>.Empty, 461locals: ImmutableArray<LocalSymbol>.Empty, 492public override ImmutableArray<ParameterSymbol> Parameters => ImmutableArray<ParameterSymbol>.Empty; 533locals: ImmutableArray<LocalSymbol>.Empty, 534statements: 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)

162get { return ImmutableArray<Location>.Empty; } 169return ImmutableArray<SyntaxReference>.Empty;

Symbols\Synthesized\SynthesizedGlobalMethodSymbol.cs (9)

43_typeParameters = ImmutableArray<TypeParameterSymbol>.Empty; 152return ImmutableArray<string>.Empty; 167return ImmutableArray<TypeParameterSymbol>.Empty; 181return ImmutableArray<ParameterSymbol>.Empty; 195get { return ImmutableArray<Location>.Empty; } 202return ImmutableArray<SyntaxReference>.Empty; 223get { return ImmutableArray<CustomModifier>.Empty; } 228get { return ImmutableArray<TypeWithAnnotations>.Empty; } 334get { 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\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)

243return ImmutableArray<TypeWithAnnotations>.Empty; 251return ImmutableArray<TypeParameterSymbol>.Empty; 267return ImmutableArray<MethodSymbol>.Empty; 280return ImmutableArray<CustomModifier>.Empty; 294return ImmutableArray<string>.Empty; 333return ImmutableArray<Location>.Empty; 341return ImmutableArray<SyntaxReference>.Empty; 507get { 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\SynthesizedMethodSymbol.cs (1)

25return ImmutableArray<SyntaxReference>.Empty;

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)

135get { return ImmutableArray<Location>.Empty; } 142return ImmutableArray<SyntaxReference>.Empty; 221internal override ImmutableArray<int> InterpolatedStringHandlerArgumentIndexes => ImmutableArray<int>.Empty; 325get { return ImmutableArray<CustomModifier>.Empty; } 383return _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)

140return ImmutableArray<TypeParameterSymbol>.Empty; 178return ImmutableArray<CustomModifier>.Empty; 208=> ImmutableArray<ImmutableArray<TypeWithAnnotations>>.Empty; 211=> 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; 374return ImmutableArray<string>.Empty;

Symbols\Synthesized\SynthesizedTypeParameterSymbol.cs (1)

79return 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)

60var locations = locationOpt is null ? ImmutableArray<Location>.Empty : ImmutableArray.Create(locationOpt); 845return ImmutableArray<Location>.Empty; 849return elementLocation == null ? ImmutableArray<Location>.Empty : ImmutableArray.Create(elementLocation); 926Locations = ImmutableArray<Location>.Empty;

Symbols\TypeMap.cs (1)

106newTypeParameters = ImmutableArray<TypeParameterSymbol>.Empty;

Symbols\TypeParameterSymbol.cs (7)

146return ImmutableArray<Symbol>.Empty; 152return ImmutableArray<Symbol>.Empty; 158return ImmutableArray<NamedTypeSymbol>.Empty; 164return ImmutableArray<NamedTypeSymbol>.Empty; 170return ImmutableArray<NamedTypeSymbol>.Empty; 245return ImmutableArray<NamedTypeSymbol>.Empty; 250return ImmutableArray<NamedTypeSymbol>.Empty;

Symbols\TypeSymbol.cs (1)

322return ImmutableArray<NamedTypeSymbol>.Empty;

Symbols\TypeSymbolExtensions.cs (2)

454return ImmutableArray<NamedTypeSymbol>.Empty; 2076var 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);