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