// Note: we do not mark nodes when looking up arities or names. This is because these two
// types of lookup are only around to make the public
// SemanticModel.LookupNames/LookupSymbols work and do not count as usages of the directives
// when the actual code is bound.
internal void AddLookupSymbolsInfoInAliases(Binder binder, LookupSymbolsInfo result, LookupOptions options)
{
if (this.UsingAliases != null)
{
foreach (var usingAlias in this.UsingAliases.Values)
{
var usingAliasSymbol = usingAlias.Alias;
var usingAliasTargetSymbol = usingAliasSymbol.GetAliasTarget(basesBeingResolved: null);
if (binder.CanAddLookupSymbolInfo(usingAliasTargetSymbol, options, null))
{
result.AddSymbol(usingAliasSymbol, usingAliasSymbol.Name, 0);
}
}
}
if (this.ExternAliases != null)
{
foreach (var externAlias in this.ExternAliases)
{
var externAliasSymbol = externAlias.Alias;
var externAliasTargetSymbol = externAliasSymbol.GetAliasTarget(basesBeingResolved: null);
if (binder.CanAddLookupSymbolInfo(externAliasTargetSymbol, options, null))
{
result.AddSymbol(externAliasSymbol, externAliasSymbol.Name, 0);
}
}
}
}
protected override void AddLookupSymbolsInfoInSingleBinder(LookupSymbolsInfo result, LookupOptions options, Binder originalBinder)
{
Debug.Assert(options.AreValid());
if ((options & LookupOptions.LabelsOnly) != 0)
{
if (this.LabelsMap != null)
{
foreach (var label in this.LabelsMap)
{
result.AddSymbol(label.Value, label.Key, 0);
}
}
}
else if (this.LocalsMap != null && options.CanConsiderLocals())
{
foreach (var local in this.LocalsMap)
{
if (originalBinder.CanAddLookupSymbolInfo(local.Value, options, null))
{
result.AddSymbol(local.Value, local.Key, 0);
}
}
}
}
private static void AddLookupSymbolsInfoInUsings(
ImmutableArray <NamespaceOrTypeAndUsingDirective> usings,
LookupSymbolsInfo result,
LookupOptions options,
Binder originalBinder
)
{
if (originalBinder.Flags.Includes(BinderFlags.InScriptUsing))
{
return;
}
Debug.Assert(!options.CanConsiderNamespaces());
// look in all using namespaces
foreach (var namespaceSymbol in usings)
{
foreach (var member in namespaceSymbol.NamespaceOrType.GetMembersUnordered())
{
if (
IsValidLookupCandidateInUsings(member) &&
originalBinder.CanAddLookupSymbolInfo(member, options, result, null)
)
{
result.AddSymbol(member, member.Name, member.GetArity());
}
}
}
}
protected override void AddLookupSymbolsInfoInSingleBinder(
LookupSymbolsInfo result,
LookupOptions options,
Binder originalBinder
)
{
if (CanConsiderTypeParameters(options))
{
foreach (var kvp in TypeParameterMap)
{
foreach (TypeParameterSymbol typeParameter in kvp.Value)
{
// In any context where this binder applies, the type parameters are always viable/speakable.
Debug.Assert(
!result.CanBeAdded(typeParameter.Name) ||
originalBinder.CanAddLookupSymbolInfo(
typeParameter,
options,
result,
null
)
);
result.AddSymbol(typeParameter, kvp.Key, 0);
}
}
}
}
protected override void AddLookupSymbolsInfoInSingleBinder(
LookupSymbolsInfo result, LookupOptions options, Binder originalBinder)
{
// Add types within namespaces imported through usings, but don't add nested namespaces.
LookupOptions usingOptions = (options & ~(LookupOptions.NamespaceAliasesOnly | LookupOptions.NamespacesOrTypesOnly)) | LookupOptions.MustNotBeNamespace;
Imports.AddLookupSymbolsInfoInUsings(ConsolidatedUsings, this, result, usingOptions);
}
// Note: we do not mark nodes when looking up arities or names. This is because these two
// types of lookup are only around to make the public
// SemanticModel.LookupNames/LookupSymbols work and do not count as usages of the directives
// when the actual code is bound.
internal void AddLookupSymbolsInfo(LookupSymbolsInfo result, LookupOptions options, Binder originalBinder)
{
AddLookupSymbolsInfoInAliases(result, options, originalBinder);
// Add types within namespaces imported through usings, but don't add nested namespaces.
LookupOptions usingOptions = (options & ~(LookupOptions.NamespaceAliasesOnly | LookupOptions.NamespacesOrTypesOnly)) | LookupOptions.MustNotBeNamespace;
AddLookupSymbolsInfoInUsings(this.Usings, result, usingOptions, originalBinder);
}
private static void AddAliasSymbolToResult(LookupSymbolsInfo result, AliasSymbol aliasSymbol, LookupOptions options, Binder originalBinder)
{
var targetSymbol = aliasSymbol.GetAliasTarget(basesBeingResolved: null);
if (originalBinder.CanAddLookupSymbolInfo(targetSymbol, options, result, accessThroughType: null, aliasSymbol: aliasSymbol))
{
result.AddSymbol(aliasSymbol, aliasSymbol.Name, 0);
}
}
protected override void AddLookupSymbolsInfoInSingleBinder(LookupSymbolsInfo result, LookupOptions options, Binder originalBinder)
{
var hostObjectType = GetHostObjectType();
if (hostObjectType.Kind != SymbolKind.ErrorType)
{
AddMemberLookupSymbolsInfo(result, hostObjectType, options, originalBinder);
}
}
internal override void AddLookupSymbolsInfoInSingleBinder(LookupSymbolsInfo result, LookupOptions options, Binder originalBinder)
{
if (options.CanConsiderMembers())
{
foreach (var kvp in _parameterMap)
{
result.AddSymbol(null, kvp.Key, 0);
}
}
}
protected override void AddLookupSymbolsInfoInSingleBinder(LookupSymbolsInfo result, LookupOptions options, Binder originalBinder)
{
if (options.CanConsiderMembers())
{
foreach (var rangeVariableName in parameterMap.Keys)
{
result.AddSymbol(null, rangeVariableName, 0);
}
}
}
internal override void AddLookupSymbolsInfoInSingleBinder(LookupSymbolsInfo info, LookupOptions options, Binder originalBinder)
{
if (_withParametersBinder is not null && IsNameofOperator)
{
_withParametersBinder.AddLookupSymbolsInfoInSingleBinder(info, options, originalBinder);
}
if (_withTypeParametersBinder is not null && IsNameofOperator)
{
_withTypeParametersBinder.AddLookupSymbolsInfoInSingleBinder(info, options, originalBinder);
}
}
internal override void AddLookupSymbolsInfoInSingleBinder(LookupSymbolsInfo result, LookupOptions options, Binder originalBinder)
{
// If we are looking only for labels we do not need to search through the imports.
if ((options & LookupOptions.LabelsOnly) == 0)
{
AddLookupSymbolsInfoInAliases(
ImmutableDictionary <string, AliasAndUsingDirective> .Empty,
this.ExternAliases,
result, options, originalBinder);
}
}
protected override void AddLookupSymbolsInfoInSingleBinder(LookupSymbolsInfo result, LookupOptions options, Binder originalBinder)
{
// If we are looking only for labels we do not need to search through the imports.
if ((options & LookupOptions.LabelsOnly) == 0)
{
AddLookupSymbolsInfoInAliases(
this.GetUsingAliasesMap(basesBeingResolved: null),
this.ExternAliases,
result, options, originalBinder);
}
}
internal void AddLookupSymbolsInfoInAliases(LookupSymbolsInfo result, LookupOptions options, Binder originalBinder)
{
foreach (var(_, usingAlias) in this.UsingAliases)
{
AddAliasSymbolToResult(result, usingAlias.Alias, options, originalBinder);
}
foreach (var externAlias in this.ExternAliases)
{
AddAliasSymbolToResult(result, externAlias.Alias, options, originalBinder);
}
}
internal override void AddLookupSymbolsInfoInSingleBinder(LookupSymbolsInfo result, LookupOptions options, Binder originalBinder)
{
if (options.CanConsiderLocals())
{
foreach (var parameter in _parameters)
{
if (originalBinder.CanAddLookupSymbolInfo(parameter, options, result, null))
{
result.AddSymbol(parameter, parameter.Name, 0);
}
}
}
}
protected override void AddLookupSymbolsInfoInSingleBinder(LookupSymbolsInfo result, LookupOptions options, Binder originalBinder)
{
if (CanConsiderTypeParameters(options))
{
foreach (var parameter in this.methodSymbol.TypeParameters)
{
if (originalBinder.CanAddLookupSymbolInfo(parameter, options, null))
{
result.AddSymbol(parameter, parameter.Name, 0);
}
}
}
}
protected override void AddLookupSymbolsInfoInSingleBinder(LookupSymbolsInfo result, LookupOptions options, Binder originalBinder)
{
if (options.CanConsiderMembers())
{
foreach (var parameter in lambdaSymbol.Parameters)
{
if (originalBinder.CanAddLookupSymbolInfo(parameter, options, null))
{
result.AddSymbol(parameter, parameter.Name, 0);
}
}
}
}
protected override void AddLookupSymbolsInfoInSingleBinder(LookupSymbolsInfo result, LookupOptions options, Binder originalBinder)
{
if (_container != null)
{
this.AddMemberLookupSymbolsInfo(result, _container, options, originalBinder);
}
// If we are looking only for labels we do not need to search through the imports.
// Submission imports are handled by AddMemberLookupSymbolsInfo (above).
if (!IsSubmissionClass && ((options & LookupOptions.LabelsOnly) == 0))
{
var imports = GetImports(basesBeingResolved: null);
imports.AddLookupSymbolsInfo(result, options, originalBinder);
}
}
protected override void AddLookupSymbolsInfoInSingleBinder(LookupSymbolsInfo result, LookupOptions options, Binder originalBinder)
{
if (options.CanConsiderTypeParameters())
{
foreach (string name in TypeParameterMap.Keys)
{
foreach (TypeParameterSymbol typeParameter in TypeParameterMap[name])
{
// In any context where this binder applies, the type parameters are always viable/speakable.
Debug.Assert(originalBinder.CanAddLookupSymbolInfo(typeParameter, options, null));
result.AddSymbol(typeParameter, name, 0);
}
}
}
}
protected override void AddLookupSymbolsInfoInSingleBinder(LookupSymbolsInfo result, LookupOptions options, Binder originalBinder)
{
this.AddMemberLookupSymbolsInfo(result, _container, options, originalBinder);
// if we are looking only for labels we do not need to search through the imports
if (!_container.IsSubmissionClass && ((options & LookupOptions.LabelsOnly) == 0))
{
var imports = GetImports(basesBeingResolved: null);
imports.AddLookupSymbolsInfoInAliases(this, result, options);
// Add types within namespaces imported through usings, but don't add nested namespaces.
LookupOptions usingOptions = (options & ~(LookupOptions.NamespaceAliasesOnly | LookupOptions.NamespacesOrTypesOnly)) | LookupOptions.MustNotBeNamespace;
Imports.AddLookupSymbolsInfoInUsings(imports.Usings, this, result, usingOptions);
}
}
internal static void AddLookupSymbolsInfoInUsings(
ImmutableArray <NamespaceOrTypeAndUsingDirective> usings, Binder binder, LookupSymbolsInfo result, LookupOptions options)
{
Debug.Assert(!options.CanConsiderNamespaces());
// look in all using namespaces
foreach (var namespaceSymbol in usings)
{
foreach (var member in namespaceSymbol.NamespaceOrType.GetMembersUnordered())
{
if (binder.CanAddLookupSymbolInfo(member, options, null))
{
result.AddSymbol(member, member.Name, member.GetArity());
}
}
}
}
protected override void AddLookupSymbolsInfoInSingleBinder(LookupSymbolsInfo result, LookupOptions options, Binder originalBinder)
{
// If we are looking only for labels we do not need to search through the imports.
if ((options & LookupOptions.LabelsOnly) == 0)
{
// Add types within namespaces imported through usings, but don't add nested namespaces.
options = (options & ~(LookupOptions.NamespaceAliasesOnly | LookupOptions.NamespacesOrTypesOnly)) | LookupOptions.MustNotBeNamespace;
// look in all using namespaces
foreach (var namespaceSymbol in this.GetUsings(basesBeingResolved: null))
{
foreach (var member in namespaceSymbol.NamespaceOrType.GetMembersUnordered())
{
if (IsValidLookupCandidateInUsings(member) && originalBinder.CanAddLookupSymbolInfo(member, options, result, null))
{
result.AddSymbol(member, member.Name, member.GetArity());
}
}
}
}
}
protected override void AddLookupSymbolsInfoInSingleBinder(LookupSymbolsInfo result, LookupOptions options, Binder originalBinder)
{
this.AddMemberLookupSymbolsInfoInSubmissions(result, (NamedTypeSymbol)Container, _inUsings, options, originalBinder);
}
protected override void AddLookupSymbolsInfoInSingleBinder(LookupSymbolsInfo result, LookupOptions options, Binder originalBinder)
{
this.AddMemberLookupSymbolsInfo(result, _container, options, originalBinder);
}
