private static CSharpCodeGenerator Create(
InsertionPoint insertionPoint,
SelectionResult selectionResult,
AnalyzerResult analyzerResult,
CSharpCodeGenerationOptions options,
NamingStylePreferencesProvider namingPreferences,
bool localFunction)
{
if (ExpressionCodeGenerator.IsExtractMethodOnExpression(selectionResult))
{
return(new ExpressionCodeGenerator(insertionPoint, selectionResult, analyzerResult, options, namingPreferences, localFunction));
}
if (SingleStatementCodeGenerator.IsExtractMethodOnSingleStatement(selectionResult))
{
return(new SingleStatementCodeGenerator(insertionPoint, selectionResult, analyzerResult, options, namingPreferences, localFunction));
}
if (MultipleStatementsCodeGenerator.IsExtractMethodOnMultipleStatements(selectionResult))
{
return(new MultipleStatementsCodeGenerator(insertionPoint, selectionResult, analyzerResult, options, namingPreferences, localFunction));
}
throw ExceptionUtilities.UnexpectedValue(selectionResult);
}
private async Task <bool> TryInitializeAsync(
AbstractGenerateConstructorFromMembersCodeRefactoringProvider service,
Document document,
TextSpan textSpan,
INamedTypeSymbol containingType,
Accessibility?desiredAccessibility,
ImmutableArray <ISymbol> selectedMembers,
NamingStylePreferencesProvider fallbackOptions,
CancellationToken cancellationToken)
{
if (!selectedMembers.All(IsWritableInstanceFieldOrProperty))
{
return(false);
}
SelectedMembers = selectedMembers;
ContainingType = containingType;
Accessibility = desiredAccessibility ?? (ContainingType.IsAbstractClass() ? Accessibility.Protected : Accessibility.Public);
TextSpan = textSpan;
if (ContainingType == null || ContainingType.TypeKind == TypeKind.Interface)
{
return(false);
}
IsContainedInUnsafeType = service.ContainingTypesOrSelfHasUnsafeKeyword(containingType);
var rules = await document.GetNamingRulesAsync(fallbackOptions, cancellationToken).ConfigureAwait(false);
Parameters = DetermineParameters(selectedMembers, rules);
MatchingConstructor = GetMatchingConstructorBasedOnParameterTypes(ContainingType, Parameters);
// We are going to create a new contructor and pass part of the parameters into DelegatedConstructor,
// so parameters should be compared based on types since we don't want get a type mismatch error after the new constructor is genreated.
DelegatedConstructor = GetDelegatedConstructorBasedOnParameterTypes(ContainingType, Parameters);
return(true);
}
private async Task <bool> TryInitializeAsync(
ImmutableArray <ISymbol> selectedMembers,
Document document,
NamingStylePreferencesProvider fallbackOptions,
CancellationToken cancellationToken)
{
ContainingType = selectedMembers[0].ContainingType;
var rules = await document.GetNamingRulesAsync(fallbackOptions, cancellationToken).ConfigureAwait(false);
var parametersForSelectedMembers = DetermineParameters(selectedMembers, rules);
if (!selectedMembers.All(IsWritableInstanceFieldOrProperty) ||
ContainingType == null ||
ContainingType.TypeKind == TypeKind.Interface ||
parametersForSelectedMembers.IsEmpty)
{
return(false);
}
ConstructorCandidates = await GetConstructorCandidatesInfoAsync(
ContainingType, selectedMembers, document, parametersForSelectedMembers, cancellationToken).ConfigureAwait(false);
return(!ConstructorCandidates.IsEmpty);
}
/// <summary>
/// Gets the set of naming rules the user has set for this document. Will include a set of default naming rules
/// that match if the user hasn't specified any for a particular symbol type. The are added at the end so they
/// will only be used if the user hasn't specified a preference.
/// </summary>
public static async Task <ImmutableArray <NamingRule> > GetNamingRulesAsync(
this Document document, NamingStylePreferencesProvider fallbackOptions, CancellationToken cancellationToken)
{
var options = await document.GetNamingStylePreferencesAsync(fallbackOptions, cancellationToken).ConfigureAwait(false);
return(options.CreateRules().NamingRules.AddRange(FallbackNamingRules.Default));
}
public MultipleStatementsCodeGenerator(
InsertionPoint insertionPoint,
SelectionResult selectionResult,
AnalyzerResult analyzerResult,
CSharpCodeGenerationOptions options,
NamingStylePreferencesProvider namingPreferences,
bool localFunction)
: base(insertionPoint, selectionResult, analyzerResult, options, namingPreferences, localFunction)
{
}
public static Task <GeneratedCode> GenerateAsync(
InsertionPoint insertionPoint,
SelectionResult selectionResult,
AnalyzerResult analyzerResult,
CSharpCodeGenerationOptions options,
NamingStylePreferencesProvider namingPreferences,
bool localFunction,
CancellationToken cancellationToken)
{
var codeGenerator = Create(insertionPoint, selectionResult, analyzerResult, options, namingPreferences, localFunction);
return(codeGenerator.GenerateAsync(cancellationToken));
}
protected CSharpCodeGenerator(
InsertionPoint insertionPoint,
SelectionResult selectionResult,
AnalyzerResult analyzerResult,
CSharpCodeGenerationOptions options,
NamingStylePreferencesProvider namingPreferences,
bool localFunction)
: base(insertionPoint, selectionResult, analyzerResult, options, namingPreferences, localFunction)
{
Contract.ThrowIfFalse(SemanticDocument == selectionResult.SemanticDocument);
var nameToken = CreateMethodName();
_methodName = nameToken.WithAdditionalAnnotations(MethodNameAnnotation);
}
public static async Task <State?> GenerateAsync(
ImmutableArray <ISymbol> selectedMembers,
Document document,
NamingStylePreferencesProvider fallbackOptions,
CancellationToken cancellationToken)
{
var state = new State();
if (!await state.TryInitializeAsync(
selectedMembers, document, fallbackOptions, cancellationToken).ConfigureAwait(false))
{
return(null);
}
return(state);
}
protected CodeGenerator(InsertionPoint insertionPoint, SelectionResult selectionResult, AnalyzerResult analyzerResult, TCodeGenerationOptions options, NamingStylePreferencesProvider namingPreferences, bool localFunction)
{
Contract.ThrowIfFalse(insertionPoint.SemanticDocument == analyzerResult.SemanticDocument);
InsertionPoint = insertionPoint;
SemanticDocument = insertionPoint.SemanticDocument;
SelectionResult = selectionResult;
AnalyzerResult = analyzerResult;
Options = options;
NamingPreferences = namingPreferences;
LocalFunction = localFunction;
MethodNameAnnotation = new SyntaxAnnotation();
CallSiteAnnotation = new SyntaxAnnotation();
MethodDefinitionAnnotation = new SyntaxAnnotation();
}
public static async Task <State?> TryGenerateAsync(
AbstractGenerateConstructorFromMembersCodeRefactoringProvider service,
Document document,
TextSpan textSpan,
INamedTypeSymbol containingType,
Accessibility?desiredAccessibility,
ImmutableArray <ISymbol> selectedMembers,
NamingStylePreferencesProvider fallbackOptions,
CancellationToken cancellationToken)
{
var state = new State();
if (!await state.TryInitializeAsync(service, document, textSpan, containingType, desiredAccessibility, selectedMembers, fallbackOptions, cancellationToken).ConfigureAwait(false))
{
return(null);
}
return(state);
}
public static async ValueTask <ExtractMethodGenerationOptions> GetExtractMethodGenerationOptionsAsync(this Document document, ExtractMethodGenerationOptions?fallbackOptions, CancellationToken cancellationToken)
{
fallbackOptions ??= ExtractMethodGenerationOptions.GetDefault(document.Project.LanguageServices);
var extractOptions = fallbackOptions.Value.ExtractOptions;
var codeGenerationOptions = await document.GetCodeGenerationOptionsAsync(fallbackOptions.Value.CodeGenerationOptions, cancellationToken).ConfigureAwait(false);
var addImportOptions = await document.GetAddImportPlacementOptionsAsync(fallbackOptions.Value.AddImportOptions, cancellationToken).ConfigureAwait(false);
var documentOptions = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
var namingPreferences = documentOptions.GetOption(NamingStyleOptions.NamingPreferences, document.Project.Language);
var namingPreferencesProvider = new NamingStylePreferencesProvider(language => namingPreferences);
return(new ExtractMethodGenerationOptions(
extractOptions,
codeGenerationOptions,
addImportOptions,
namingPreferencesProvider));
}
internal abstract Task <string> GetFieldNameAsync(Document document, IPropertySymbol propertySymbol, NamingStylePreferencesProvider fallbackOptions, CancellationToken cancellationToken);
public static async Task <NamingRule> GetApplicableNamingRuleAsync(this Document document, ISymbol symbol, NamingStylePreferencesProvider fallbackOptions, CancellationToken cancellationToken)
{
var rules = await document.GetNamingRulesAsync(fallbackOptions, cancellationToken).ConfigureAwait(false);
foreach (var rule in rules)
{
if (rule.SymbolSpecification.AppliesTo(symbol))
{
return(rule);
}
}
throw ExceptionUtilities.Unreachable;
}
public static async Task <NamingRule> GetApplicableNamingRuleAsync(
this Document document, SymbolKindOrTypeKind kind, DeclarationModifiers modifiers, Accessibility?accessibility, NamingStylePreferencesProvider fallbackOptions, CancellationToken cancellationToken)
{
var rules = await document.GetNamingRulesAsync(fallbackOptions, cancellationToken).ConfigureAwait(false);
foreach (var rule in rules)
{
if (rule.SymbolSpecification.AppliesTo(kind, modifiers, accessibility))
{
return(rule);
}
}
throw ExceptionUtilities.Unreachable;
}
protected abstract Task <GeneratedCode> GenerateCodeAsync(InsertionPoint insertionPoint, SelectionResult selectionResult, AnalyzerResult analyzeResult, CodeGenerationOptions options, NamingStylePreferencesProvider namingPreferences, CancellationToken cancellationToken);
public static async ValueTask <NamingStylePreferences> GetNamingStylePreferencesAsync(this Document document, NamingStylePreferencesProvider fallbackOptionsProvider, CancellationToken cancellationToken)
{
var configOptions = await document.GetAnalyzerConfigOptionsAsync(cancellationToken).ConfigureAwait(false);
if (configOptions.TryGetEditorConfigOption <NamingStylePreferences>(NamingStyleOptions.NamingPreferences, out var value))
{
return(value);
}
return(await fallbackOptionsProvider.GetOptionsAsync(document.Project.LanguageServices, cancellationToken).ConfigureAwait(false));
}
protected override Task <GeneratedCode> GenerateCodeAsync(InsertionPoint insertionPoint, SelectionResult selectionResult, AnalyzerResult analyzeResult, CodeGenerationOptions options, NamingStylePreferencesProvider namingPreferences, CancellationToken cancellationToken) => CSharpCodeGenerator.GenerateAsync(insertionPoint, selectionResult, analyzeResult, (CSharpCodeGenerationOptions)options, namingPreferences, LocalFunction, cancellationToken);
private static async Task <bool> NameIsHighlyUnlikelyToWarrantSymbolAsync(
Document document, State state, SymbolKind kind, Accessibility accessibility, NamingStylePreferencesProvider fallbackOptions, CancellationToken cancellationToken)
{
// Check If the user explicitly used _ as the start of the name they're generating. Don't offer to generate
// a non-field symbol unless that's genuinely the naming style they have setup.
if (state.IdentifierToken.ValueText.StartsWith("_"))
{
var namingStyle = await document.GetApplicableNamingRuleAsync(kind, accessibility, fallbackOptions, cancellationToken).ConfigureAwait(false);
if (namingStyle.NamingStyle.Prefix != "_")
{
return(true);
}
}
return(false);
}
internal override async Task <string> GetFieldNameAsync(Document document, IPropertySymbol property, NamingStylePreferencesProvider fallbackOptions, CancellationToken cancellationToken)
{
var rule = await document.GetApplicableNamingRuleAsync(
new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Field),
property.IsStatic?DeclarationModifiers.Static : DeclarationModifiers.None,
Accessibility.Private,
fallbackOptions,
cancellationToken).ConfigureAwait(false);
var fieldName = rule.NamingStyle.MakeCompliant(property.Name).First();
return(NameGenerator.GenerateUniqueName(fieldName, n => !property.ContainingType.GetMembers(n).Any()));
}
