public bool IsApplicable(SyntaxContext syntaxContext, Options.Options options) { return(options.SuggestUnimportedExtensionMethods && syntaxContext.IsMemberAccessContext && syntaxContext.AccessedSymbolType != null && syntaxContext.AccessedSymbol?.Kind != SymbolKind.NamedType); }
public bool IsApplicable(SyntaxContext syntaxContext, Options.Options options) { return(options.SuggestLocalVariablesFirst && syntaxContext.InferredType != null && (syntaxContext.TypeInferredFrom == TypeInferredFrom.MethodArgument || syntaxContext.TypeInferredFrom == TypeInferredFrom.ReturnValue || syntaxContext.TypeInferredFrom == TypeInferredFrom.Assignment)); }
public bool IsApplicable(SyntaxContext syntaxContext, Options.Options options) { return(options.SuggestTypesOnObjectCreation && syntaxContext.InferredType != null // do not support enums and nullable enums && syntaxContext.InferredType.TypeKind != TypeKind.Enum && !(syntaxContext.InferredType is INamedTypeSymbol namedType && namedType.Name == "Nullable" && namedType.TypeArguments.FirstOrDefault()?.TypeKind == TypeKind.Enum)); }
public static void Serialize(University university, Options.Options options) { switch (options.Format) { case "xml": XmlSerialize(university); break; case "json": JsonSerialize(university); break; default: throw new ArgumentException("Nieznany format danych"); } }
public bool IsApplicable(SyntaxContext syntaxContext, Options.Options options) { return(options.SuggestTypesOnObjectCreation && syntaxContext.InferredInfo.Type != null // do not suggest for comparisons && syntaxContext.InferredInfo.From != TypeInferredFrom.BinaryExpression // do not suggest for object && syntaxContext.InferredInfo.Type.SpecialType != SpecialType.System_Object // do not support enums and nullable enums && syntaxContext.InferredInfo.Type.TypeKind != TypeKind.Enum && !(syntaxContext.InferredInfo.Type is INamedTypeSymbol namedType && namedType.Name == nameof(Nullable) && namedType.TypeArguments.FirstOrDefault()?.TypeKind == TypeKind.Enum) // do not suggest for ref/out parameters && (syntaxContext.InferredInfo.ParameterSymbol == null || syntaxContext.InferredInfo.ParameterSymbol.RefKind == RefKind.None)); }
public IEnumerable <CompletionItem> GetCompletionItems(SyntaxContext syntaxContext, Options.Options options) { var typeSymbol = syntaxContext.InferredType; var locals = GetLocalVariables(syntaxContext); var suitableLocals = GetAssignableSymbols(syntaxContext, locals, s => s.Type, typeSymbol); var lambdaParameters = GetLambdaParameters(syntaxContext); var suitableLambdaParameters = GetAssignableSymbols(syntaxContext, lambdaParameters, s => s.Type, typeSymbol); var typeMembers = GetTypeMembers(syntaxContext); ITypeSymbol getMemberType(ISymbol s) => (s as IFieldSymbol)?.Type ?? ((IPropertySymbol)s).Type; var suitableTypeMembers = GetAssignableSymbols(syntaxContext, typeMembers, getMemberType, typeSymbol); var methodParameters = GetMethodParameters(syntaxContext); var suitableMethodParameters = GetAssignableSymbols(syntaxContext, methodParameters, s => s.Type, typeSymbol); var localCompletions = suitableLocals .Select(symbol => CreateCompletion(syntaxContext, symbol, Sorting.Suitable_Locals)); var lambdaParamsCompletions = suitableLambdaParameters .Select(symbol => CreateCompletion(syntaxContext, symbol, Sorting.Suitable_LambdaParameters)); var typeMemberCompletions = suitableTypeMembers .Select(symbol => CreateCompletion(syntaxContext, symbol, Sorting.Suitable_TypeMembers)); var methodParametersCompletions = suitableMethodParameters .Select(l => CreateCompletion(syntaxContext, l, Sorting.Suitable_MethodParameters)); return(localCompletions .Concat(lambdaParamsCompletions) .Concat(typeMemberCompletions) .Concat(methodParametersCompletions)); }
public bool ShouldTriggerCompletion(SourceText text, int caretPosition, CompletionTrigger trigger, Options.Options options) { if (options.SuggestLocalVariablesFirst) { var currentLine = text.Lines.GetLineFromPosition(caretPosition); var textBeforeCaret = currentLine.ToString().Substring(0, caretPosition - currentLine.Start); if (trigger.Kind == CompletionTriggerKind.Insertion && (BracketRegex.IsMatch(textBeforeCaret) || textBeforeCaret.EndsWith(", ") || textBeforeCaret.EndsWith("return ")) && !AttributeArgumentRegex.IsMatch(textBeforeCaret)) { return(true); } } return(false); }
public Task <IEnumerable <CompletionItem> > GetCompletionItemsAsync(SyntaxContext syntaxContext, Options.Options options) { return(Task.FromResult(GetCompletionItems(syntaxContext))); }
public bool IsApplicable(SyntaxContext syntaxContext, Options.Options options) { return(options.SuggestNestedTypes && syntaxContext.IsTypeContext && !syntaxContext.IsAttributeContext); }
public bool IsApplicable(SyntaxContext syntaxContext, Options.Options options) { return(syntaxContext.IsTypeContext); }
public Task <IEnumerable <CompletionItem> > GetCompletionItemsAsync(SyntaxContext syntaxContext, Options.Options options) { var typeSymbol = syntaxContext.InferredInfo.Type; // Unwrap nullable enum if (typeSymbol is INamedTypeSymbol namedType && namedType.Name == nameof(Nullable) && namedType.TypeArguments.FirstOrDefault()?.TypeKind == TypeKind.Enum) { typeSymbol = namedType.TypeArguments[0]; } if (typeSymbol?.TypeKind == TypeKind.Enum) { return(Task.FromResult(new[] { CompletionItemHelper.CreateCompletionItem(typeSymbol, syntaxContext, unimported: !syntaxContext.IsNamespaceImported(typeSymbol.ContainingNamespace), matchPriority: MatchPriority.Preselect, sortingPriority: Sorting.Suitable_Enum) }.AsEnumerable())); } return(Task.FromResult(Enumerable.Empty <CompletionItem>())); }
public bool ShouldTriggerCompletion(SourceText text, int caretPosition, CompletionTrigger trigger, Options.Options options) { if (options.SuggestTypesOnObjectCreation || options.SuggestFactoryMethodsOnObjectCreation) { var currentLine = text.Lines.GetLineFromPosition(caretPosition); //trigger completion automatically when assigning values var textBeforeCaret = currentLine.ToString().Substring(0, caretPosition - currentLine.Start); if (trigger.Kind == CompletionTriggerKind.Insertion && (textBeforeCaret.EndsWith(" = ") || textBeforeCaret.EndsWith(": ") || textBeforeCaret.EndsWith(" = new ") || textBeforeCaret.EndsWith("return ") || BracketRegex.IsMatch(textBeforeCaret))) { return(true); } } return(false); }
public bool IsApplicable(SyntaxContext syntaxContext, Options.Options options) { return(syntaxContext.IsMemberAccessContext && syntaxContext.AccessedSymbolType != null && syntaxContext.AccessedSymbol?.Kind != SymbolKind.NamedType); }
public IEnumerable <CompletionItem> GetCompletionItems(SyntaxContext syntaxContext, Options.Options options) { var isNewKeywordPresent = syntaxContext.CurrentToken.Parent is ObjectCreationExpressionSyntax; if (!isNewKeywordPresent && syntaxContext.InferredInfo.Type != null) { var completions = GetSpecialCasesCompletions(syntaxContext.InferredInfo.Type, syntaxContext); if (options.SuggestFactoryMethodsOnObjectCreation) { completions = completions.Concat(GetStaticMethodsAndPropertiesCompletions(syntaxContext, syntaxContext.InferredInfo.Type)); } return(completions); } return(null); }
public IEnumerable <CompletionItem> GetCompletionItemsForType(INamedTypeSymbol typeSymbol, SyntaxContext syntaxContext, Options.Options options) { if (typeSymbol.IsBuiltInType() || (typeSymbol.TypeKind != TypeKind.Class && typeSymbol.TypeKind != TypeKind.Struct) || typeSymbol.IsAbstract || !typeSymbol.InstanceConstructors.Any(con => con.DeclaredAccessibility == Accessibility.Public)) { return(null); } bool newKeywordRequired = true; var currentSyntaxNode = syntaxContext.CurrentToken.Parent; if (currentSyntaxNode is ObjectCreationExpressionSyntax) { //if we already have new keyword - we don't need that newKeywordRequired = false; } var applicableCompletion = GetApplicableTypeCompletion(typeSymbol, syntaxContext, newKeywordRequired, options); return(applicableCompletion == null ? null : new[] { applicableCompletion }); }
private CompletionItem GetApplicableTypeCompletion(ITypeSymbol suggestedType, SyntaxContext syntaxContext, bool newKeywordRequired, Options.Options options) { var assignableSymbol = syntaxContext.SemanticModel.Compilation.GetAssignableSymbol(suggestedType, syntaxContext.InferredInfo.Type); if (assignableSymbol == null || assignableSymbol.Name == nameof(Nullable)) { return(null); } var symbolName = assignableSymbol.Name; var inferredTypeName = syntaxContext.InferredInfo.Type.Name; bool unimported = !syntaxContext.IsNamespaceImported(assignableSymbol.ContainingNamespace); int priority; if (symbolName == inferredTypeName || "I" + symbolName == inferredTypeName) { priority = Sorting.NewSuggestion_MatchingName; } else if (!unimported) { priority = Sorting.NewSuggestion_Default; } else { priority = Sorting.NewSuggestion_Unimported; } return(CompletionItemHelper.CreateCompletionItem(assignableSymbol, syntaxContext, priority, MatchPriority.Preselect, newPositionOffset: 0, unimported: unimported, newCreationSyntax: newKeywordRequired, showParenthesisForNewCreations: options.AddParethesisForNewSuggestions)); }
private async Task <IEnumerable <CompletionItem> > GetTypeCompletionsAsync(SyntaxContext syntaxContext, ITypeSymbol type, bool isNewKeywordPresent, Options.Options options) { var solution = syntaxContext.Document.Project.Solution; IEnumerable <INamedTypeSymbol> implementations = Array.Empty <INamedTypeSymbol>(); if (type is INamedTypeSymbol namedType) { implementations = namedType.TypeKind switch { TypeKind.Class => await SymbolFinder.FindDerivedClassesAsync(namedType, solution, cancellationToken : syntaxContext.CancellationToken), TypeKind.Interface => (await SymbolFinder.FindImplementationsAsync(namedType, solution, cancellationToken: syntaxContext.CancellationToken)).OfType <INamedTypeSymbol>(), _ => Array.Empty <INamedTypeSymbol>() }; } if (type is INamedTypeSymbol namedTypeSymbol && (type.TypeKind == TypeKind.Class || type.TypeKind == TypeKind.Struct)) { if (namedTypeSymbol.OriginalDefinition.SpecialType == SpecialType.System_Nullable_T) { if (namedTypeSymbol.TypeArguments[0] is INamedTypeSymbol typeArgumentNamedType) { implementations = implementations.Append(typeArgumentNamedType); } } else { implementations = implementations.Append(namedTypeSymbol); } } return(FromAssignableTypes(implementations)); IEnumerable <CompletionItem> FromAssignableTypes(IEnumerable <INamedTypeSymbol> assignableTypes) { foreach (var assignableType in assignableTypes) { if (assignableType.IsBuiltInType() || (assignableType.TypeKind != TypeKind.Class && assignableType.TypeKind != TypeKind.Struct) || assignableType.IsAbstract || !assignableType.InstanceConstructors.Any(con => con.DeclaredAccessibility == Accessibility.Public)) { continue; } var completion = GetApplicableTypeCompletion(assignableType, syntaxContext, !isNewKeywordPresent, options); if (completion != null) { yield return(completion); } } } }
public IEnumerable <CompletionItem> GetCompletionItems(SyntaxContext syntaxContext, Options.Options options) { if (syntaxContext.InferredType != null) { var completions = GetSpecialCasesCompletions(syntaxContext.InferredType, syntaxContext); if (options.SuggestFactoryMethodsOnObjectCreation) { completions = completions.Concat(GetStaticMethodsAndPropertiesCompletions(syntaxContext, syntaxContext.InferredType)); } return(completions); } return(null); }
public static bool SwitchToMo( this Table self, Database inMemDatabase, Database traditional, Configuration.Configuration cnf, Options.Options o, ref string error, ILog logger, SqlServerMoFeatures enumFeatures) { var schemaName = self.Schema; if (inMemDatabase.Schemas.Contains(schemaName) == false) { var hr = new Schema(inMemDatabase, schemaName); inMemDatabase.Schemas.Add(hr); inMemDatabase.Schemas[schemaName].Create(); } if (inMemDatabase.Tables.Contains(self.Name, schemaName)) { logger.Log("\t" + "Already exists", self.FName()); return(true); } var hasIdentities = false; var newTable = new Table(inMemDatabase, self.Name, schemaName) { // default true IsMemoryOptimized = true, // default schema and data Durability = DurabilityType.SchemaAndData }; // Add columns foreach (Column c in self.Columns) { var newColumn = new Column(newTable, c.Name); newColumn.CopyPropertiesFrom(c); SupportUnsupported(newColumn, c, traditional, logger, ref error, ref hasIdentities, true); newTable.Columns.Add(newColumn); } //Add indexes var hasPrimaryKey = false; foreach (Index i in self.Indexes) { if (i.IndexKeyType == IndexKeyType.DriPrimaryKey) { hasPrimaryKey = true; var idx = new Index(newTable, i.Name); if (o.UseHashIndexes == IndexDecision.Hash) { idx.IndexType = IndexType.NonClusteredHashIndex; idx.BucketCount = self.RowCount != 0 ? (int)self.RowCount * 2 : 64; } else if (o.UseHashIndexes == IndexDecision.Range) { idx.IndexType = IndexType.NonClusteredIndex; } else { if (self.ExtendedProperties[cnf.EpName] != null) { var value = self.ExtendedProperties[cnf.EpName].Value.ToString().ToUpper(); if (value == "HASH") { idx.IndexType = IndexType.NonClusteredHashIndex; idx.BucketCount = self.RowCount == 0 ? 64 : (int)self.RowCount; } else { idx.IndexType = IndexType.NonClusteredIndex; } } else { idx.IndexType = IndexType.NonClusteredIndex; } } idx.IndexKeyType = IndexKeyType.DriPrimaryKey; foreach (IndexedColumn ic in i.IndexedColumns) { idx.IndexedColumns.Add(new IndexedColumn(idx, ic.Name)); } newTable.Indexes.Add(idx); } } var noIndexes = hasPrimaryKey ? 1 : 0; foreach (Index i in self.Indexes) { if (i.IndexKeyType == IndexKeyType.DriPrimaryKey) { continue; } if (i.IndexType == IndexType.NonClusteredIndex) { // Limit the total number of indexes to 8 for SQLServer2016 if (enumFeatures == SqlServerMoFeatures.SqlServer2016 && noIndexes == 8) { logger.LogWarErr("Error:Create index failed", $"Could not create in-memory index {i.Name} because it exceeds the maximum of 8 allowed per table or view."); continue; } Index idx = new Index(newTable, i.Name) { IndexType = IndexType.NonClusteredIndex, IndexKeyType = IndexKeyType.None }; idx.IsUnique = i.IsUnique; bool hasColumns = false; foreach (IndexedColumn ic in i.IndexedColumns) { if (ic.IsIncluded) { continue; } // nvarchar(max) is not allowed if (newTable.Columns[ic.Name].DataType.MaximumLength == -1) { logger.LogWarErr("Warning:Create index", $"Could not include {ic.Name} in index {idx.Name} The column has nvarchar(max) type which is not allowed!"); continue; } idx.IndexedColumns.Add(new IndexedColumn(idx, ic.Name)); hasColumns = true; } if (hasColumns) { newTable.Indexes.Add(idx); noIndexes++; } } } if (hasPrimaryKey == false) { error = $"Error:Table :{self.FName()} has no primary key"; //logger.LogWarErr(error, self.FName()); return(false); } //if (inMemDatabase.Tables.Contains(newTable.Name, schemaName)) // inMemDatabase.Tables[newTable.Name, schemaName].Drop(); // Add checks foreach (Check ch in self.Checks) { var newch = new Check(newTable, ch.Name); newch.CopyPropertiesFrom(ch); if (newch.Text.ToLower().Contains("upper") || newch.Text.ToLower().Contains("like") || newch.Text.ToLower().Contains("charindex")) { logger.LogWarErr($"Warning {newch.Name}", $" can not apply constraint on table {self.FName()} because it contains forbidden functions "); continue; } newTable.Checks.Add(newch); } // Skip triggers foreach (Trigger tr in self.Triggers) { logger.LogWarErr($"Warning {tr.Name}", $" can not create trigger on table {self.FName()}.Please, create trigger manually! "); } try { logger.Log("Create table ", newTable.FName()); newTable.Create(); } catch (Exception ex) { error = string.Join($"{Environment.NewLine}\t", ex.CollectThemAll(ex1 => ex1.InnerException) .Select(ex1 => ex1.Message)); if (Debugger.IsAttached) { Debugger.Break(); } return(false); } // if copy data is checked if (o.CopyData) { if (inMemDatabase.Tables.Contains(cnf.HelperTableName, cnf.HelperSchema)) { inMemDatabase.Tables[cnf.HelperTableName, cnf.HelperSchema].Drop(); } try { logger.Log("Insert data ", newTable.FName()); //Insert into traditional.ExecuteNonQuery(self.InsertIntoStm(inMemDatabase.Name, cnf.FullName)); //Insert statement var test = inMemDatabase.Tables[cnf.HelperTableName, cnf.HelperSchema]; inMemDatabase.ExecuteNonQuery(newTable.FullInsertStm(test.SelectStm(), hasIdentities, cnf.FullName)); logger.Log("OK ", newTable.FName()); // } catch (Exception ex) { if (inMemDatabase.Tables.Contains(newTable.Name, schemaName)) { inMemDatabase.Tables[newTable.Name, schemaName].Drop(); } logger.Log("Error", self.FName()); error = string.Join($"{Environment.NewLine}\t", ex.CollectThemAll(ex1 => ex1.InnerException) .Select(ex1 => ex1.Message)); if (Debugger.IsAttached) { Debugger.Break(); } } } newTable = null; return(error == ""); }
public IEnumerable <CompletionItem> GetCompletionItems(SyntaxContext syntaxContext, Options.Options options) { if (syntaxContext.InferredType is INamedTypeSymbol namedType && namedType.EnumUnderlyingType != null) { return(new[] { CompletionItemHelper.CreateCompletionItem(namedType, syntaxContext, unimported: !syntaxContext.ImportedNamespaces.Contains(namedType.GetNamespace()), matchPriority: MatchPriority.Preselect, sortingPriority: Sorting.Suitable_Enum) }); } return(null); }
public IEnumerable <CompletionItem> GetCompletionItemsForType(INamedTypeSymbol typeSymbol, SyntaxContext syntaxContext, Options.Options options) { if (syntaxContext.IsNamespaceImported(typeSymbol.ContainingNamespace) || !typeSymbol.MightContainExtensionMethods) { return(null); } var extMethodSymbols = typeSymbol .GetMembers() .OfType <IMethodSymbol>() .Where(methodSymbol => syntaxContext.IsAccessible(methodSymbol) && !(options.FilterOutObsoleteSymbols && methodSymbol.IsObsolete())) .Select(m => m.ReduceExtensionMethod(syntaxContext.AccessedSymbolType)) .Where(m => m != null); return(extMethodSymbols.Select(s => CreateCompletionItemForSymbol(s, syntaxContext, options))); }
private bool FilterType(INamedTypeSymbol type, SyntaxContext syntaxContext, bool forStatics, Options.Options options) { return((type.DeclaredAccessibility == Accessibility.Public || (type.DeclaredAccessibility == Accessibility.Internal && type.ContainingAssembly == syntaxContext.SemanticModel.Compilation.Assembly)) && type.CanBeReferencedByName && ((!forStatics && !syntaxContext.ImportedNamespaces.Contains(type.GetNamespace())) || (forStatics && !syntaxContext.ImportedStatics.Contains(type.ToDisplayString()) && (!options.StaticSuggestionsOnlyForImportedNamespaces || (syntaxContext.ImportedNamespaces.Contains(type.GetNamespace()))) //limit to types from imported namespaces )) ); }
public IEnumerable <CompletionItem> GetCompletionItemsForType(INamedTypeSymbol typeSymbol, SyntaxContext syntaxContext, Options.Options options) { if (!syntaxContext.IsAttributeContext || (typeSymbol.IsAttribute() && !typeSymbol.IsAbstract)) { if (!syntaxContext.IsNamespaceImported(typeSymbol)) { return(new[] { CreateCompletionItemForSymbol(typeSymbol, syntaxContext, options) }); } // If nested types suggestions are enabled, we should return imported suggestions as well else if (options.SuggestNestedTypes && typeSymbol.ContainingType != null) { return(new[] { CompletionItemHelper.CreateCompletionItem(typeSymbol, syntaxContext, unimported: false) }); } } return(null); }
public async Task <IEnumerable <CompletionItem> > GetCompletionItemsAsync(SyntaxContext syntaxContext, Options.Options options) { var type = syntaxContext.InferredInfo.Type; if (type == null) { return(Enumerable.Empty <CompletionItem>()); } var isNewKeywordPresent = syntaxContext.CurrentToken.Parent is ObjectCreationExpressionSyntax; var completions = await GetTypeCompletionsAsync(syntaxContext, type, isNewKeywordPresent, options).ConfigureAwait(false); if (!isNewKeywordPresent) { completions = completions.Concat(GetSpecialCasesCompletions(type, syntaxContext)); if (options.SuggestFactoryMethodsOnObjectCreation) { completions = completions.Concat(GetStaticMethodsAndPropertiesCompletions(syntaxContext, type)); } } return(completions); }
private CompletionItem CreateCompletionItemForSymbol(ISymbol typeSymbol, SyntaxContext context, Options.Options options) { int sorting = options.SortCompletionsAfterImported ? Sorting.Last : Sorting.Default; return(CompletionItemHelper.CreateCompletionItem(typeSymbol, context, sorting)); }
public Task <IEnumerable <CompletionItem> > GetCompletionItemsAsync(SyntaxContext syntaxContext, Options.Options options) { var lookedUpSymbols = syntaxContext.SemanticModel.LookupSymbols(syntaxContext.Position); var typeSymbol = syntaxContext.InferredInfo.Type !; var locals = GetLocalVariables(lookedUpSymbols, syntaxContext); var suitableLocals = GetAssignableSymbols(syntaxContext, locals, s => s.Type, typeSymbol); var lambdaParameters = GetLambdaParameters(lookedUpSymbols, syntaxContext); var suitableLambdaParameters = GetAssignableSymbols(syntaxContext, lambdaParameters, s => s.Type, typeSymbol); var typeMembers = GetTypeMembers(lookedUpSymbols, syntaxContext); ITypeSymbol getMemberType(ISymbol s) => (s as IFieldSymbol)?.Type ?? ((IPropertySymbol)s).Type; var suitableTypeMembers = GetAssignableSymbols(syntaxContext, typeMembers, getMemberType, typeSymbol); var methodParameters = GetMethodParameters(lookedUpSymbols, syntaxContext); var suitableMethodParameters = GetAssignableSymbols(syntaxContext, methodParameters, s => s.Type, typeSymbol); var localCompletions = suitableLocals .Select(symbol => CreateCompletion(syntaxContext, symbol, Sorting.Suitable_Locals)); var lambdaParamsCompletions = suitableLambdaParameters .Select(symbol => CreateCompletion(syntaxContext, symbol, Sorting.Suitable_LambdaParameters)); var typeMemberCompletions = suitableTypeMembers .Select(symbol => CreateCompletion(syntaxContext, symbol, Sorting.Suitable_TypeMembers)); var methodParametersCompletions = suitableMethodParameters .Select(l => CreateCompletion(syntaxContext, l, Sorting.Suitable_MethodParameters)); var thisCompletion = GetThisCompletionIfApplicable(syntaxContext); return(Task.FromResult(localCompletions .Concat(lambdaParamsCompletions) .Concat(typeMemberCompletions) .Concat(methodParametersCompletions) .Concat(thisCompletion))); }
public bool IsApplicable(SyntaxContext syntaxContext, Options.Options options) { return(true); }
public DataReader(Options.Options options) { this.options = options; }
public OptionsProvider(Options.Options options) { _options = options; }
private IEnumerable <INamedTypeSymbol> GetAllTypes(SyntaxContext syntaxContext, Options.Options options) { var symbolsToTraverse = new Queue <INamespaceOrTypeSymbol>(); var globalNamespace = syntaxContext.SemanticModel.Compilation.GlobalNamespace; symbolsToTraverse.Enqueue(globalNamespace); while (symbolsToTraverse.Count > 0) { var current = symbolsToTraverse.Dequeue(); foreach (var member in current.GetMembers()) { if (member is INamedTypeSymbol namedTypeSymbol) { if (syntaxContext.IsAccessible(namedTypeSymbol) && !(options.FilterOutObsoleteSymbols && namedTypeSymbol.IsObsolete())) { yield return(namedTypeSymbol); if (options.SuggestNestedTypes) { symbolsToTraverse.Enqueue(namedTypeSymbol); } } } else if (member is INamespaceSymbol ns) { symbolsToTraverse.Enqueue(ns); } } } }