|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System.Collections.Immutable;
using System.Linq;
using System.Threading;
using Microsoft.CodeAnalysis.LanguageService;
using Microsoft.CodeAnalysis.Shared.Extensions;
using Microsoft.CodeAnalysis.Shared.Utilities;
using Microsoft.CodeAnalysis.Text;
namespace Microsoft.CodeAnalysis.GenerateDefaultConstructors;
internal abstract partial class AbstractGenerateDefaultConstructorsService<TService>
{
private sealed class State
{
public INamedTypeSymbol? ClassType { get; private set; }
public ImmutableArray<IMethodSymbol> UnimplementedConstructors { get; private set; }
private State()
{
}
public static State? Generate(
TService service,
SemanticDocument document,
TextSpan textSpan,
bool forRefactoring,
CancellationToken cancellationToken)
{
var state = new State();
if (!state.TryInitialize(service, document, textSpan, forRefactoring, cancellationToken))
{
return null;
}
return state;
}
private bool TryInitialize(
TService service,
SemanticDocument semanticDocument,
TextSpan textSpan,
bool forRefactoring,
CancellationToken cancellationToken)
{
if (!service.TryInitializeState(semanticDocument, textSpan, cancellationToken, out var classType))
return false;
ClassType = classType;
var baseType = ClassType.BaseType;
if (ClassType.IsStatic ||
baseType == null ||
baseType.TypeKind == TypeKind.Error)
{
return false;
}
// if this is for the refactoring, then don't offer this if the compiler is reporting an
// error here. We'll let the code fix take care of that.
//
// Similarly if this is for the codefix only offer if we do see that there's an error.
var syntaxFacts = semanticDocument.Document.GetRequiredLanguageService<ISyntaxFactsService>();
var headerFacts = semanticDocument.Document.GetRequiredLanguageService<IHeaderFactsService>();
if (headerFacts.IsOnTypeHeader(semanticDocument.Root, textSpan.Start, fullHeader: true, out _))
{
var fixesError = FixesError(classType, baseType);
if (forRefactoring == fixesError)
return false;
}
var semanticFacts = semanticDocument.Document.GetLanguageService<ISemanticFactsService>();
var classConstructors = ClassType.InstanceConstructors;
var destinationProvider = semanticDocument.Project.Solution.Services.GetLanguageServices(ClassType.Language);
var isCaseSensitive = syntaxFacts.IsCaseSensitive;
UnimplementedConstructors = baseType
.InstanceConstructors
.WhereAsArray(c => c.IsAccessibleWithin(ClassType) && IsMissing(c, classConstructors, isCaseSensitive));
return UnimplementedConstructors.Length > 0;
}
private static bool FixesError(INamedTypeSymbol classType, INamedTypeSymbol baseType)
{
// See if the user didn't supply a constructor, and thus the compiler automatically generated
// one for them. If so, also see if there's an accessible no-arg contructor in the base.
// If not, then the compiler will error and we want the code-fix to take over solving this problem.
if (classType.Constructors.Any(static c => c.Parameters.Length == 0 && c.IsImplicitlyDeclared))
{
var baseNoArgConstructor = baseType.Constructors.FirstOrDefault(c => c.Parameters.Length == 0);
if (baseNoArgConstructor == null ||
!baseNoArgConstructor.IsAccessibleWithin(classType))
{
// this code is in error, but we're the refactoring codepath. Offer nothing
// and let the code fix provider handle it instead.
return true;
}
// If this is a struct that has initializers, but is missing a parameterless constructor then we are fixing
// an error (CS8983) but since this is the only scenario where we support structs we don't need to actually
// check for anything else.
if (classType.TypeKind == TypeKind.Struct)
{
return true;
}
}
return false;
}
private static bool IsMissing(
IMethodSymbol constructor,
ImmutableArray<IMethodSymbol> classConstructors,
bool isCaseSensitive)
{
var matchingConstructor = classConstructors.FirstOrDefault(
c => SignatureComparer.Instance.HaveSameSignature(
constructor.Parameters, c.Parameters, compareParameterName: true, isCaseSensitive: isCaseSensitive));
if (matchingConstructor == null)
{
return true;
}
// We have a matching constructor in this type. But we'll still offer to create the
// constructor if the constructor that we have is implicit.
return matchingConstructor.IsImplicitlyDeclared;
}
}
}
|