static ErrorFacts()
{
ImmutableHashSet <string> .Builder builder = ImmutableHashSet.CreateBuilder <string>();
builder.Add(getId(ErrorCode.WRN_NullReferenceAssignment));
builder.Add(getId(ErrorCode.WRN_NullReferenceReceiver));
builder.Add(getId(ErrorCode.WRN_NullReferenceReturn));
builder.Add(getId(ErrorCode.WRN_NullReferenceArgument));
builder.Add(getId(ErrorCode.WRN_UninitializedNonNullableField));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInAssignment));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInArgument));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInArgumentForOutput));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInReturnTypeOfTargetDelegate));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInParameterTypeOfTargetDelegate));
builder.Add(getId(ErrorCode.WRN_NullAsNonNullable));
builder.Add(getId(ErrorCode.WRN_NullableValueTypeMayBeNull));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInTypeParameterConstraint));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInTypeParameterReferenceTypeConstraint));
builder.Add(getId(ErrorCode.WRN_PossibleNull));
NullableFlowAnalysisSafetyWarnings = builder.ToImmutable();
builder.Clear();
builder.Add(getId(ErrorCode.WRN_ConvertingNullableToNonNullable));
builder.Add(getId(ErrorCode.HDN_NullCheckIsProbablyAlwaysFalse));
builder.Add(getId(ErrorCode.HDN_NullCheckIsProbablyAlwaysTrue));
builder.Add(getId(ErrorCode.HDN_ExpressionIsProbablyNeverNull));
NullableFlowAnalysisNonSafetyWarnings = builder.ToImmutable();
string getId(ErrorCode errorCode)
{
return(MessageProvider.Instance.GetIdForErrorCode((int)errorCode));
}
}
static ErrorFacts()
{
ImmutableHashSet <string> .Builder builder = ImmutableHashSet.CreateBuilder <string>();
builder.Add(getId(ErrorCode.WRN_NullReferenceAssignment));
builder.Add(getId(ErrorCode.WRN_NullReferenceReceiver));
builder.Add(getId(ErrorCode.WRN_NullReferenceReturn));
builder.Add(getId(ErrorCode.WRN_NullReferenceArgument));
builder.Add(getId(ErrorCode.WRN_UninitializedNonNullableField));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInAssignment));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInArgument));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInArgumentForOutput));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInReturnTypeOfTargetDelegate));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInParameterTypeOfTargetDelegate));
builder.Add(getId(ErrorCode.WRN_NullAsNonNullable));
builder.Add(getId(ErrorCode.WRN_NullableValueTypeMayBeNull));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInTypeParameterConstraint));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInTypeParameterReferenceTypeConstraint));
builder.Add(getId(ErrorCode.WRN_PossibleNull));
builder.Add(getId(ErrorCode.WRN_DefaultExpressionMayIntroduceNullT));
builder.Add(getId(ErrorCode.WRN_NullLiteralMayIntroduceNullT));
builder.Add(getId(ErrorCode.WRN_ConditionalAccessMayReturnNull));
builder.Add(getId(ErrorCode.WRN_AsOperatorMayReturnNull));
NullableFlowAnalysisSafetyWarnings = builder.ToImmutable();
builder.Clear();
builder.Add(getId(ErrorCode.WRN_ConvertingNullableToNonNullable));
NullableFlowAnalysisNonSafetyWarnings = builder.ToImmutable();
string getId(ErrorCode errorCode)
{
return(MessageProvider.Instance.GetIdForErrorCode((int)errorCode));
}
}
public ImageLayers Build()
{
if (!_removeDuplicates)
{
return(new ImageLayers(ImmutableArray.CreateRange(layers), layerDigestsBuilder.ToImmutable()));
}
// LinkedHashSet maintains the order but keeps the first occurrence. Keep last occurrence by
// adding elements in reverse, and then reversing the result
ISet <ILayer> dedupedButReversed = new LinkedHashSet <ILayer>(layers.Reverse());
ImmutableArray <ILayer> deduped = ImmutableArray.CreateRange(dedupedButReversed.Reverse());
return(new ImageLayers(deduped, layerDigestsBuilder.ToImmutable()));
}
public ImmutableHashSet <string> GetAllTargetImageTags()
{
ImmutableHashSet <string> .Builder allTargetImageTags = ImmutableHashSet.CreateBuilder <string>();
allTargetImageTags.Add(targetImageConfiguration.GetImageTag());
allTargetImageTags.UnionWith(additionalTargetImageTags);
return(allTargetImageTags.ToImmutable());
}
static ErrorFacts()
{
ImmutableHashSet <string> .Builder builder = ImmutableHashSet.CreateBuilder <string>();
builder.Add(getId(ErrorCode.WRN_ConvertingNullableToNonNullable));
builder.Add(getId(ErrorCode.WRN_NullReferenceAssignment));
builder.Add(getId(ErrorCode.WRN_NullReferenceReceiver));
builder.Add(getId(ErrorCode.WRN_NullReferenceReturn));
builder.Add(getId(ErrorCode.WRN_NullReferenceArgument));
builder.Add(getId(ErrorCode.WRN_UninitializedNonNullableField));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInAssignment));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInArgument));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInReturnTypeOfTargetDelegate));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInParameterTypeOfTargetDelegate));
builder.Add(getId(ErrorCode.WRN_NullAsNonNullable));
builder.Add(getId(ErrorCode.WRN_NoBestNullabilityConditionalExpression));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInTypeParameterConstraint));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInTypeParameterReferenceTypeConstraint));
builder.Add(getId(ErrorCode.WRN_CantInferNullabilityOfMethodTypeArgs));
builder.Add(getId(ErrorCode.WRN_NoBestNullabilityArrayElements));
builder.Add(getId(ErrorCode.HDN_NullCheckIsProbablyAlwaysFalse));
builder.Add(getId(ErrorCode.HDN_NullCheckIsProbablyAlwaysTrue));
builder.Add(getId(ErrorCode.HDN_ExpressionIsProbablyNeverNull));
NullableFlowAnalysisWarnings = builder.ToImmutable();
string getId(ErrorCode errorCode)
{
return(MessageProvider.Instance.GetIdForErrorCode((int)errorCode));
}
}
static ErrorFacts()
{
ImmutableHashSet <string> .Builder nullableWarnings = ImmutableHashSet.CreateBuilder <string>();
nullableWarnings.Add(getId(ErrorCode.WRN_NullReferenceAssignment));
nullableWarnings.Add(getId(ErrorCode.WRN_NullReferenceReceiver));
nullableWarnings.Add(getId(ErrorCode.WRN_NullReferenceReturn));
nullableWarnings.Add(getId(ErrorCode.WRN_NullReferenceArgument));
nullableWarnings.Add(getId(ErrorCode.WRN_UninitializedNonNullableField));
nullableWarnings.Add(getId(ErrorCode.WRN_NullabilityMismatchInAssignment));
nullableWarnings.Add(getId(ErrorCode.WRN_NullabilityMismatchInArgument));
nullableWarnings.Add(getId(ErrorCode.WRN_NullabilityMismatchInArgumentForOutput));
nullableWarnings.Add(getId(ErrorCode.WRN_NullabilityMismatchInReturnTypeOfTargetDelegate));
nullableWarnings.Add(getId(ErrorCode.WRN_NullabilityMismatchInParameterTypeOfTargetDelegate));
nullableWarnings.Add(getId(ErrorCode.WRN_NullAsNonNullable));
nullableWarnings.Add(getId(ErrorCode.WRN_NullableValueTypeMayBeNull));
nullableWarnings.Add(getId(ErrorCode.WRN_NullabilityMismatchInTypeParameterConstraint));
nullableWarnings.Add(getId(ErrorCode.WRN_NullabilityMismatchInTypeParameterReferenceTypeConstraint));
nullableWarnings.Add(getId(ErrorCode.WRN_NullabilityMismatchInTypeParameterNotNullConstraint));
nullableWarnings.Add(getId(ErrorCode.WRN_ThrowPossibleNull));
nullableWarnings.Add(getId(ErrorCode.WRN_UnboxPossibleNull));
nullableWarnings.Add(getId(ErrorCode.WRN_SwitchExpressionNotExhaustiveForNull));
nullableWarnings.Add(getId(ErrorCode.WRN_SwitchExpressionNotExhaustiveForNullWithWhen));
nullableWarnings.Add(getId(ErrorCode.WRN_ConvertingNullableToNonNullable));
nullableWarnings.Add(getId(ErrorCode.WRN_DisallowNullAttributeForbidsMaybeNullAssignment));
nullableWarnings.Add(getId(ErrorCode.WRN_ParameterConditionallyDisallowsNull));
nullableWarnings.Add(getId(ErrorCode.WRN_ShouldNotReturn));
nullableWarnings.Add(getId(ErrorCode.WRN_NullabilityMismatchInTypeOnOverride));
nullableWarnings.Add(getId(ErrorCode.WRN_NullabilityMismatchInReturnTypeOnOverride));
nullableWarnings.Add(getId(ErrorCode.WRN_NullabilityMismatchInReturnTypeOnPartial));
nullableWarnings.Add(getId(ErrorCode.WRN_NullabilityMismatchInParameterTypeOnOverride));
nullableWarnings.Add(getId(ErrorCode.WRN_NullabilityMismatchInParameterTypeOnPartial));
nullableWarnings.Add(getId(ErrorCode.WRN_NullabilityMismatchInTypeOnImplicitImplementation));
nullableWarnings.Add(getId(ErrorCode.WRN_NullabilityMismatchInReturnTypeOnImplicitImplementation));
nullableWarnings.Add(getId(ErrorCode.WRN_NullabilityMismatchInParameterTypeOnImplicitImplementation));
nullableWarnings.Add(getId(ErrorCode.WRN_NullabilityMismatchInTypeOnExplicitImplementation));
nullableWarnings.Add(getId(ErrorCode.WRN_NullabilityMismatchInReturnTypeOnExplicitImplementation));
nullableWarnings.Add(getId(ErrorCode.WRN_NullabilityMismatchInParameterTypeOnExplicitImplementation));
nullableWarnings.Add(getId(ErrorCode.WRN_NullabilityMismatchInConstraintsOnImplicitImplementation));
nullableWarnings.Add(getId(ErrorCode.WRN_NullabilityMismatchInExplicitlyImplementedInterface));
nullableWarnings.Add(getId(ErrorCode.WRN_NullabilityMismatchInInterfaceImplementedByBase));
nullableWarnings.Add(getId(ErrorCode.WRN_DuplicateInterfaceWithNullabilityMismatchInBaseList));
nullableWarnings.Add(getId(ErrorCode.WRN_NullabilityMismatchInConstraintsOnPartialImplementation));
nullableWarnings.Add(getId(ErrorCode.WRN_NullReferenceInitializer));
nullableWarnings.Add(getId(ErrorCode.WRN_ShouldNotReturn));
nullableWarnings.Add(getId(ErrorCode.WRN_DoesNotReturnMismatch));
nullableWarnings.Add(getId(ErrorCode.WRN_TopLevelNullabilityMismatchInParameterTypeOnExplicitImplementation));
nullableWarnings.Add(getId(ErrorCode.WRN_TopLevelNullabilityMismatchInParameterTypeOnImplicitImplementation));
nullableWarnings.Add(getId(ErrorCode.WRN_TopLevelNullabilityMismatchInParameterTypeOnOverride));
nullableWarnings.Add(getId(ErrorCode.WRN_TopLevelNullabilityMismatchInReturnTypeOnExplicitImplementation));
nullableWarnings.Add(getId(ErrorCode.WRN_TopLevelNullabilityMismatchInReturnTypeOnImplicitImplementation));
nullableWarnings.Add(getId(ErrorCode.WRN_TopLevelNullabilityMismatchInReturnTypeOnOverride));
nullableWarnings.Add(getId(ErrorCode.WRN_MemberNotNull));
nullableWarnings.Add(getId(ErrorCode.WRN_MemberNotNullBadMember));
nullableWarnings.Add(getId(ErrorCode.WRN_MemberNotNullWhen));
nullableWarnings.Add(getId(ErrorCode.WRN_ParameterDisallowsNull));
NullableWarnings = nullableWarnings.ToImmutable();
private static ImmutableHashSet <string> ToImmutableAndFree(ImmutableHashSet <string> .Builder builder)
{
var result = builder.ToImmutable();
builder.Clear();
s_memberNameBuilderPool.Free(builder);
return(result);
}
static ErrorFacts()
{
ImmutableHashSet <string> .Builder builder = ImmutableHashSet.CreateBuilder <string>();
builder.Add(getId(ErrorCode.WRN_NullReferenceAssignment));
builder.Add(getId(ErrorCode.WRN_NullReferenceReceiver));
builder.Add(getId(ErrorCode.WRN_NullReferenceReturn));
builder.Add(getId(ErrorCode.WRN_NullReferenceArgument));
builder.Add(getId(ErrorCode.WRN_NullReferenceIterationVariable));
builder.Add(getId(ErrorCode.WRN_UninitializedNonNullableField));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInAssignment));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInArgument));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInArgumentForOutput));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInReturnTypeOfTargetDelegate));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInParameterTypeOfTargetDelegate));
builder.Add(getId(ErrorCode.WRN_NullAsNonNullable));
builder.Add(getId(ErrorCode.WRN_NullableValueTypeMayBeNull));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInTypeParameterConstraint));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInTypeParameterReferenceTypeConstraint));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInTypeParameterNotNullConstraint));
builder.Add(getId(ErrorCode.WRN_ThrowPossibleNull));
builder.Add(getId(ErrorCode.WRN_UnboxPossibleNull));
builder.Add(getId(ErrorCode.WRN_DefaultExpressionMayIntroduceNullT));
builder.Add(getId(ErrorCode.WRN_NullLiteralMayIntroduceNullT));
builder.Add(getId(ErrorCode.WRN_ConditionalAccessMayReturnNull));
builder.Add(getId(ErrorCode.WRN_AsOperatorMayReturnNull));
builder.Add(getId(ErrorCode.WRN_SwitchExpressionNotExhaustiveForNull));
builder.Add(getId(ErrorCode.WRN_ConvertingNullableToNonNullable));
builder.Add(getId(ErrorCode.WRN_DisallowNullAttributeForbidsMaybeNullAssignment));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInTypeOnOverride));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInReturnTypeOnOverride));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInParameterTypeOnOverride));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInParameterTypeOnPartial));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInTypeOnImplicitImplementation));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInReturnTypeOnImplicitImplementation));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInParameterTypeOnImplicitImplementation));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInTypeOnExplicitImplementation));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInReturnTypeOnExplicitImplementation));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInParameterTypeOnExplicitImplementation));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInConstraintsOnImplicitImplementation));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInExplicitlyImplementedInterface));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInInterfaceImplementedByBase));
builder.Add(getId(ErrorCode.WRN_DuplicateInterfaceWithNullabilityMismatchInBaseList));
builder.Add(getId(ErrorCode.WRN_NullabilityMismatchInConstraintsOnPartialImplementation));
builder.Add(getId(ErrorCode.WRN_NullReferenceInitializer));
builder.Add(getId(ErrorCode.WRN_ExpressionMayIntroduceNullT));
NullableWarnings = builder.ToImmutable();
string getId(ErrorCode errorCode)
{
return(MessageProvider.Instance.GetIdForErrorCode((int)errorCode));
}
}
public override void Initialize(AnalysisContext context)
{
base.Initialize(context);
context.RegisterCompilationStartAction(startContext =>
{
if (_syntaxKindNames == null)
{
Compilation compilation = startContext.Compilation;
INamedTypeSymbol csharpSyntaxNodeSymbol = compilation.GetTypeByMetadataName("Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode");
if (csharpSyntaxNodeSymbol == null)
{
return;
}
Dictionary <string, string> kindsToNames = compilation
.GetTypeByMetadataName("Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax")
.ContainingNamespace
.GetTypeMembers()
.Where(f => f.TypeKind == TypeKind.Class &&
!f.IsAbstract &&
f.InheritsFrom(csharpSyntaxNodeSymbol) &&
f.Name.EndsWith("Syntax", StringComparison.Ordinal))
.ToDictionary(f => f.Name.Remove(f.Name.Length - 6), f => f.Name);
ImmutableHashSet <string> .Builder syntaxKindNames = ImmutableHashSet.CreateBuilder <string>();
ImmutableHashSet <string> .Builder syntaxTypeNames = ImmutableHashSet.CreateBuilder <string>();
ImmutableDictionary <ushort, string> .Builder syntaxKindValuesToNames = ImmutableDictionary.CreateBuilder <ushort, string>();
foreach (SyntaxKind syntaxKind in Enum.GetValues(typeof(SyntaxKind))
.Cast <SyntaxKind>()
.Select(f => f))
{
string name = syntaxKind.ToString();
if (kindsToNames.TryGetValue(name, out string symbolName))
{
syntaxKindNames.Add(name);
syntaxTypeNames.Add(symbolName);
}
syntaxKindValuesToNames.Add((ushort)syntaxKind, name);
}
Interlocked.CompareExchange(ref _syntaxKindNames, syntaxKindNames.ToImmutable(), null);
Interlocked.CompareExchange(ref _syntaxTypeNames, syntaxTypeNames.ToImmutable(), null);
Interlocked.CompareExchange(ref _syntaxKindValuesToNames, syntaxKindValuesToNames.ToImmutable(), null);
}
startContext.RegisterSyntaxNodeAction(f => AnalyzeSwitchStatement(f), SyntaxKind.SwitchStatement);
startContext.RegisterSyntaxNodeAction(f => AnalyzeIfStatement(f), SyntaxKind.IfStatement);
});
}
private IImmutableSet <string> GetDimensionNames()
{
ImmutableHashSet <string> .Builder builder = ImmutableHashSet.CreateBuilder(StringComparers.ConfigurationDimensionNames);
foreach (Lazy <IActiveConfiguredProjectsDimensionProvider> dimensionProvider in DimensionProviders)
{
builder.Add(dimensionProvider.Value.DimensionName);
}
return(builder.ToImmutable());
}
internal LambdaAndLocalFunctionAnalysisInfo(
ImmutableHashSet <IMethodSymbol> .Builder escapedLocalFunctions,
ImmutableHashSet <IMethodSymbol> .Builder analyzedLocalFunctions,
ImmutableHashSet <IFlowAnonymousFunctionOperation> .Builder escapedLambdas,
ImmutableHashSet <IFlowAnonymousFunctionOperation> .Builder analyzedLambdas)
{
EscapedLocalFunctions = escapedLocalFunctions.ToImmutable();
AnalyzedLocalFunctions = analyzedLocalFunctions.ToImmutable();
EscapedLambdas = escapedLambdas.ToImmutable();
AnalyzedLambdas = analyzedLambdas.ToImmutable();
}
private MutabilityInspectionResult InspectClassOrStruct(
ITypeSymbol type,
HashSet <ITypeSymbol> typeStack
)
{
if (typeStack.Contains(type))
{
// We have a cycle. If we're here, it means that either some read-only member causes the cycle (via IsMemberMutableRecursive),
// or a generic parameter to a type causes the cycle (via IsTypeMutableRecursive). This is safe if the checks above have
// passed and the remaining members are read-only immutable. So we can skip the current check, and allow the type to continue
// to be evaluated.
return(MutabilityInspectionResult.NotMutable());
}
// We have a type that is not marked immutable, is not an interface, is not an immutable container, etc..
// If it is defined in a different assembly, we might not have the metadata to correctly analyze it; so we fail.
if (TypeIsFromOtherAssembly(type))
{
return(MutabilityInspectionResult.MutableType(type, MutabilityCause.IsAnExternalUnmarkedType));
}
ImmutableHashSet <string> .Builder seenUnauditedReasonsBuilder = ImmutableHashSet.CreateBuilder <string>();
typeStack.Add(type);
try {
foreach (ISymbol member in type.GetExplicitNonStaticMembers())
{
var result = InspectMemberRecursive(member, typeStack);
if (result.IsMutable)
{
return(result);
}
seenUnauditedReasonsBuilder.UnionWith(result.SeenUnauditedReasons);
}
// We descend into the base class last
if (type.BaseType != null)
{
var baseResult = InspectConcreteType(type.BaseType, typeStack);
if (baseResult.IsMutable)
{
return(baseResult);
}
seenUnauditedReasonsBuilder.UnionWith(baseResult.SeenUnauditedReasons);
}
} finally {
typeStack.Remove(type);
}
return(MutabilityInspectionResult.NotMutable(seenUnauditedReasonsBuilder.ToImmutable()));
}
private void UpdateDependenciesSnapshot(
ImmutableDictionary <ITargetFramework, IDependenciesChanges> changes,
IProjectCatalogSnapshot catalogs,
ITargetFramework activeTargetFramework,
CancellationToken token)
{
IImmutableSet <string> projectItemSpecs = GetProjectItemSpecsFromSnapshot();
TryUpdateSnapshot(
snapshot => DependenciesSnapshot.FromChanges(
_commonServices.Project.FullPath,
snapshot,
changes,
catalogs,
activeTargetFramework,
_snapshotFilters.ToImmutableValueArray(),
_subTreeProviders.ToValueDictionary(p => p.ProviderType),
projectItemSpecs),
token);
return;
// Gets the set of items defined directly the project, and not included by imports.
IImmutableSet <string> GetProjectItemSpecsFromSnapshot()
{
// We don't have catalog snapshot, we're likely updating because one of our project
// dependencies changed. Just return 'no data'
if (catalogs == null)
{
return(null);
}
ImmutableHashSet <string> .Builder itemSpecs = ImmutableHashSet.CreateBuilder(StringComparer.OrdinalIgnoreCase);
foreach (ProjectItemInstance item in catalogs.Project.ProjectInstance.Items)
{
if (item.IsImported())
{
continue;
}
// Returns unescaped evaluated include
string itemSpec = item.EvaluatedInclude;
if (itemSpec.Length != 0)
{
itemSpecs.Add(itemSpec);
}
}
return(itemSpecs.ToImmutable());
}
}
/**
* Converts/validates a list of strings representing port ranges to an expanded list of {@link
* Port}s.
*
* <p>For example: ["1000", "2000-2002"] will expand to a list of {@link Port}s with the port
* numbers [1000, 2000, 2001, 2002]
*
* @param ports the list of port numbers/ranges, with an optional protocol separated by a '/'
* (defaults to TCP if missing).
* @return the ports as a list of {@link Port}
* @throws NumberFormatException if any of the ports are in an invalid format or out of range
*/
public static ImmutableHashSet <Port> Parse(IEnumerable <string> ports)
{
ports = ports ?? throw new ArgumentNullException(nameof(ports));
ImmutableHashSet <Port> .Builder result = ImmutableHashSet.CreateBuilder <Port>();
foreach (string port in ports)
{
Match matcher = PortPattern.Match(port);
if (!matcher.Success)
{
throw new FormatException(
"Invalid port configuration: '"
+ port
+ "'. Make sure the port is a single number or a range of two numbers separated "
+ "with a '-', with or without protocol specified (e.g. '<portNum>/tcp' or "
+ "'<portNum>/udp').");
}
// Parse protocol
int min = int.Parse(matcher.Groups[1].Value, CultureInfo.InvariantCulture);
int max = min;
if (!string.IsNullOrEmpty(matcher.Groups[2].Value))
{
max = int.Parse(matcher.Groups[2].Value, CultureInfo.InvariantCulture);
}
string protocol = matcher.Groups[3].Value;
// Error if configured as 'max-min' instead of 'min-max'
if (min > max)
{
throw new FormatException(
"Invalid port range '" + port + "'; smaller number must come first.");
}
// Warn for possibly invalid port numbers
if (min < 1 || max > 65535)
{
throw new FormatException(
"Port number '" + port + "' is out of usual range (1-65535).");
}
for (int portNumber = min; portNumber <= max; portNumber++)
{
result.Add(Port.ParseProtocol(portNumber, protocol));
}
}
return(result.ToImmutable());
}
static void Main(string[] args)
{
ImmutableHashSet <int> il = ImmutableHashSet.Create <int>();
il = il.Add(1);
il = il.Add(2);
il = il.Remove(2);
ImmutableHashSet <int> .Builder issBuilder = il.ToBuilder();
issBuilder.Add(10); //adds to original Hashset. returns void.
ImmutableHashSet <int> .Builder builder = ImmutableHashSet.CreateBuilder <int>();
builder.Add(1);
il = builder.ToImmutable();
}
// Internal, for test use -- normal code should use the factory methods
internal TargetedDependenciesSnapshot(
string projectPath,
ITargetFramework targetFramework,
IProjectCatalogSnapshot catalogs,
ImmutableDictionary <string, IDependency> dependenciesWorld)
{
Requires.NotNullOrEmpty(projectPath, nameof(projectPath));
Requires.NotNull(targetFramework, nameof(targetFramework));
// catalogs can be null
Requires.NotNull(dependenciesWorld, nameof(dependenciesWorld));
ProjectPath = projectPath;
TargetFramework = targetFramework;
Catalogs = catalogs;
DependenciesWorld = dependenciesWorld;
bool hasUnresolvedDependency = false;
ImmutableHashSet <IDependency> .Builder topLevelDependencies = ImmutableHashSet.CreateBuilder <IDependency>();
foreach ((string id, IDependency dependency) in dependenciesWorld)
{
System.Diagnostics.Debug.Assert(
string.Equals(id, dependency.Id),
"dependenciesWorld dictionary entry keys must match their value's ids.");
if (!dependency.Resolved)
{
hasUnresolvedDependency = true;
}
if (dependency.TopLevel)
{
bool added = topLevelDependencies.Add(dependency);
System.Diagnostics.Debug.Assert(added, "Duplicate top level dependency found.");
if (!string.IsNullOrEmpty(dependency.Path))
{
_topLevelDependenciesByPathMap.Add(
Dependency.GetID(TargetFramework, dependency.ProviderType, dependency.Path),
dependency);
}
}
}
HasUnresolvedDependency = hasUnresolvedDependency;
TopLevelDependencies = topLevelDependencies.ToImmutable();
}
/// <summary>
/// Initializes a new alternation set.
/// </summary>
/// <param name="setElements">The elements of this set.</param>
public NegatedSet(params SetElement[] setElements)
{
if (setElements is null)
{
throw new ArgumentNullException(nameof(setElements));
}
if (setElements.Length < 1)
{
throw new ArgumentException("At least 1 set element is required.", nameof(setElements));
}
ImmutableHashSet <Char> .Builder characters = ImmutableHashSet.CreateBuilder <Char>();
ImmutableHashSet <Range <Char> > .Builder ranges = ImmutableHashSet.CreateBuilder <Range <Char> >();
ImmutableHashSet <UnicodeCategory> .Builder categories = ImmutableHashSet.CreateBuilder <UnicodeCategory>();
ImmutableHashSet <GrammarNode <Char> > .Builder nodes = ImmutableHashSet.CreateBuilder <GrammarNode <Char> >();
for (var elementIdx = 0; elementIdx < setElements.Length; elementIdx++)
{
SetElement setElement = setElements[elementIdx];
switch (setElement.Type)
{
case SetElementType.Character:
characters.Add(setElement.Character);
break;
case SetElementType.Range:
ranges.Add(setElement.Range);
break;
case SetElementType.UnicodeCategory:
categories.Add(setElement.UnicodeCategory);
break;
case SetElementType.Node:
nodes.Add(setElement.Node);
break;
case SetElementType.Invalid:
default:
throw new InvalidOperationException($"Invalid set element provided at index {elementIdx}.");
}
}
this.Characters = characters.ToImmutable();
this.Ranges = ranges.ToImmutable();
this.UnicodeCategories = categories.ToImmutable();
this.Nodes = nodes.ToImmutable();
}
public ImmutableHashSet <FindSymbolResult> FindPropertyOrFieldSymbols(SemanticModel model, SyntaxList <StatementSyntax> statements, CancellationToken token)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
ImmutableHashSet <FindSymbolResult> symbolResults = ImmutableHashSet <FindSymbolResult> .Empty;
ImmutableHashSet <FindSymbolResult> .Builder builder = symbolResults.ToBuilder();
foreach (var syntax in statements)
{
token.ThrowIfCancellationRequested();
EnumerateNodes(ref builder, model, syntax.DescendantNodesAndSelf(), token);
}
return(builder.ToImmutable());
}
private MutabilityInspectionResult InspectImmutableContainerType(
ITypeSymbol type,
HashSet <ITypeSymbol> typeStack
)
{
var namedType = type as INamedTypeSymbol;
ImmutableHashSet <string> .Builder unauditedReasonsBuilder = ImmutableHashSet.CreateBuilder <string>();
for (int i = 0; i < namedType.TypeArguments.Length; i++)
{
var arg = namedType.TypeArguments[i];
var result = InspectType(
arg,
MutabilityInspectionFlags.Default,
typeStack
);
if (result.IsMutable)
{
if (result.Target == MutabilityTarget.Member)
{
// modify the result to prefix with container member.
var prefix = ImmutableContainerTypes[type.GetFullTypeName()];
result = result.WithPrefixedMember(prefix[i]);
}
else
{
// modify the result to target the type argument if the
// target is not a member
result = result.WithTarget(
MutabilityTarget.TypeArgument
);
}
return(result);
}
unauditedReasonsBuilder.UnionWith(result.SeenUnauditedReasons);
}
return(MutabilityInspectionResult.NotMutable(unauditedReasonsBuilder.ToImmutable()));
}
public ImmutableHashSet <FindSymbolResult> FindPropertyOrFieldSymbols(SemanticModel model, ExpressionSyntax expression, CancellationToken token)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
ImmutableHashSet <FindSymbolResult> symbolResults = ImmutableHashSet <FindSymbolResult> .Empty;
ImmutableHashSet <FindSymbolResult> .Builder builder = symbolResults.ToBuilder();
token.ThrowIfCancellationRequested();
EnumerateNodes(ref builder, model, expression.DescendantNodesAndSelf(), token);
return(builder.ToImmutable());
}
/// <summary>
/// Gets the set of assemblies that a generated assembly must be granted the ability to skip visiblity checks for
/// in order to access the specified type.
/// </summary>
/// <param name="typeInfo">The type which may be internal.</param>
/// <returns>The set of names of assemblies to skip visibility checks for.</returns>
internal static ImmutableHashSet <AssemblyName> GetSkipVisibilityChecksRequirements(TypeInfo typeInfo)
{
Requires.NotNull(typeInfo, nameof(typeInfo));
var visitedTypes = new HashSet <TypeInfo>();
ImmutableHashSet <AssemblyName> .Builder assembliesDeclaringInternalTypes = ImmutableHashSet.CreateBuilder <AssemblyName>(AssemblyNameEqualityComparer.Instance);
CheckForNonPublicTypes(typeInfo, assembliesDeclaringInternalTypes, visitedTypes);
// Enumerate members on the interface that we're going to need to implement.
foreach (MethodInfo methodInfo in typeInfo.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.FlattenHierarchy))
{
CheckForNonPublicTypes(methodInfo.ReturnType.GetTypeInfo(), assembliesDeclaringInternalTypes, visitedTypes);
foreach (ParameterInfo parameter in methodInfo.GetParameters())
{
CheckForNonPublicTypes(parameter.ParameterType.GetTypeInfo(), assembliesDeclaringInternalTypes, visitedTypes);
}
}
return(assembliesDeclaringInternalTypes.ToImmutable());
}
/**
* Converts a map of volumes strings to a set of {@link AbsoluteUnixPath}s (e.g. {@code {@code
* {"/var/log/my-app-logs":{}}} => AbsoluteUnixPath().get("/var/log/my-app-logs")}).
*
* @param volumeMap the map to convert
* @return a set of {@link AbsoluteUnixPath}s
*/
public static ImmutableHashSet <AbsoluteUnixPath> VolumeMapToSet(IDictionary <string, IDictionary <object, object> > volumeMap)
{
if (volumeMap == null)
{
return(ImmutableHashSet.Create <AbsoluteUnixPath>());
}
ImmutableHashSet <AbsoluteUnixPath> .Builder volumeList = ImmutableHashSet.CreateBuilder <AbsoluteUnixPath>();
foreach (string volume in volumeMap.Keys)
{
try
{
volumeList.Add(AbsoluteUnixPath.Get(volume));
}
catch (ArgumentException)
{
throw new BadContainerConfigurationFormatException("Invalid volume path: " + volume);
}
}
return(volumeList.ToImmutable());
}
/**
* Converts a map of exposed ports as strings to a set of {@link Port}s (e.g. {@code
* {"1000/tcp":{}}} => {@code Port(1000, Protocol.TCP)}).
*
* @param portMap the map to convert
* @return a set of {@link Port}s
*/
public static ImmutableHashSet <Port> PortMapToSet(IDictionary <string, IDictionary <object, object> > portMap)
{
if (portMap == null)
{
return(ImmutableHashSet.Create <Port>());
}
ImmutableHashSet <Port> .Builder ports = ImmutableHashSet.CreateBuilder <Port>();
foreach (KeyValuePair <string, IDictionary <object, object> > entry in portMap)
{
string port = entry.Key;
Match matcher = PORT_PATTERN.Match(port);
if (!matcher.Success)
{
throw new BadContainerConfigurationFormatException(
"Invalid port configuration: '" + port + "'.");
}
int portNumber = int.Parse(matcher.Groups["portNum"].Value, CultureInfo.InvariantCulture);
string protocol = matcher.Groups["protocol"].Value;
ports.Add(Port.ParseProtocol(portNumber, protocol));
}
return(ports.ToImmutable());
}
private static void OnCompilationStart(CompilationStartAnalysisContext context)
{
ImmutableHashSet <IMethodSymbol> .Builder syncMethods = ImmutableHashSet.CreateBuilder <IMethodSymbol>();
ImmutableHashSet <IMethodSymbol> .Builder asyncMethods = ImmutableHashSet.CreateBuilder <IMethodSymbol>();
INamedTypeSymbol? namedType = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemLinqEnumerable);
IEnumerable <IMethodSymbol>?methods = namedType?.GetMembers(Count).OfType <IMethodSymbol>().Where(m => m.Parameters.Length <= 2);
AddIfNotNull(syncMethods, methods);
methods = namedType?.GetMembers(LongCount).OfType <IMethodSymbol>().Where(m => m.Parameters.Length <= 2);
AddIfNotNull(syncMethods, methods);
namedType = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemLinqQueryable);
methods = namedType?.GetMembers(Count).OfType <IMethodSymbol>().Where(m => m.Parameters.Length <= 2);
AddIfNotNull(syncMethods, methods);
methods = namedType?.GetMembers(LongCount).OfType <IMethodSymbol>().Where(m => m.Parameters.Length <= 2);
AddIfNotNull(syncMethods, methods);
namedType = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.MicrosoftEntityFrameworkCoreEntityFrameworkQueryableExtensions);
methods = namedType?.GetMembers(CountAsync).OfType <IMethodSymbol>().Where(m => m.Parameters.Length <= 2);
AddIfNotNull(asyncMethods, methods);
methods = namedType?.GetMembers(LongCountAsync).OfType <IMethodSymbol>().Where(m => m.Parameters.Length <= 2);
AddIfNotNull(asyncMethods, methods);
namedType = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemDataEntityQueryableExtensions);
methods = namedType?.GetMembers(CountAsync).OfType <IMethodSymbol>().Where(m => m.Parameters.Length <= 2);
AddIfNotNull(asyncMethods, methods);
methods = namedType?.GetMembers(LongCountAsync).OfType <IMethodSymbol>().Where(m => m.Parameters.Length <= 2);
AddIfNotNull(asyncMethods, methods);
// Allowed types that should report a CA1836 diagnosis given that there is proven benefit on doing so.
ImmutableHashSet <ITypeSymbol> .Builder allowedTypesBuilder = ImmutableHashSet.CreateBuilder <ITypeSymbol>();
namedType = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemCollectionsConcurrentConcurrentBag1);
allowedTypesBuilder.AddIfNotNull(namedType);
namedType = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemCollectionsConcurrentConcurrentDictionary2);
allowedTypesBuilder.AddIfNotNull(namedType);
namedType = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemCollectionsConcurrentConcurrentQueue1);
allowedTypesBuilder.AddIfNotNull(namedType);
namedType = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemCollectionsConcurrentConcurrentStack1);
allowedTypesBuilder.AddIfNotNull(namedType);
ImmutableHashSet <ITypeSymbol> allowedTypesForCA1836 = allowedTypesBuilder.ToImmutable();
if (syncMethods.Count > 0 || asyncMethods.Count > 0)
{
context.RegisterOperationAction(operationContext => AnalyzeInvocationOperation(
operationContext, syncMethods.ToImmutable(), asyncMethods.ToImmutable(), allowedTypesForCA1836),
OperationKind.Invocation);
}
if (!allowedTypesForCA1836.IsEmpty)
{
context.RegisterOperationAction(operationContext => AnalyzePropertyReference(
operationContext, allowedTypesForCA1836),
OperationKind.PropertyReference);
}
public static ComputationalComplexityMetrics Compute(IOperation operationBlock)
{
bool hasSymbolInitializer = false;
long executableLinesOfCode = 0;
long operatorUsageCounts = 0;
long symbolUsageCounts = 0;
long constantUsageCounts = 0;
ImmutableHashSet <OperationKind> .Builder? distinctOperatorKindsBuilder = null;
ImmutableHashSet <BinaryOperatorKind> .Builder?distinctBinaryOperatorKindsBuilder = null;
ImmutableHashSet <UnaryOperatorKind> .Builder? distinctUnaryOperatorKindsBuilder = null;
ImmutableHashSet <CaseKind> .Builder? distinctCaseKindsBuilder = null;
ImmutableHashSet <ISymbol> .Builder? distinctReferencedSymbolsBuilder = null;
ImmutableHashSet <object> .Builder? distinctReferencedConstantsBuilder = null;
// Explicit user applied attribute.
if (operationBlock.Kind == OperationKind.None &&
hasAnyExplicitExpression(operationBlock))
{
executableLinesOfCode += 1;
}
foreach (var operation in operationBlock.Descendants())
{
executableLinesOfCode += getExecutableLinesOfCode(operation, ref hasSymbolInitializer);
if (operation.IsImplicit)
{
continue;
}
#if LEGACY_CODE_METRICS_MODE
// Legacy mode does not account for code within lambdas/local functions for code metrics.
if (operation.IsWithinLambdaOrLocalFunction(out _))
{
continue;
}
#endif
if (operation.ConstantValue.HasValue)
{
constantUsageCounts++;
distinctReferencedConstantsBuilder ??= ImmutableHashSet.CreateBuilder <object>();
distinctReferencedConstantsBuilder.Add(operation.ConstantValue.Value ?? s_nullConstantPlaceholder);
continue;
}
switch (operation.Kind)
{
// Symbol references.
case OperationKind.LocalReference:
countOperand(((ILocalReferenceOperation)operation).Local);
continue;
case OperationKind.ParameterReference:
countOperand(((IParameterReferenceOperation)operation).Parameter);
continue;
case OperationKind.FieldReference:
case OperationKind.MethodReference:
case OperationKind.PropertyReference:
case OperationKind.EventReference:
countOperator(operation);
countOperand(((IMemberReferenceOperation)operation).Member);
continue;
// Symbol initializers.
case OperationKind.FieldInitializer:
foreach (var field in ((IFieldInitializerOperation)operation).InitializedFields)
{
countOperator(operation);
countOperand(field);
}
continue;
case OperationKind.PropertyInitializer:
foreach (var property in ((IPropertyInitializerOperation)operation).InitializedProperties)
{
countOperator(operation);
countOperand(property);
}
continue;
case OperationKind.ParameterInitializer:
countOperator(operation);
countOperand(((IParameterInitializerOperation)operation).Parameter);
continue;
case OperationKind.VariableInitializer:
countOperator(operation);
// We count the operand in the variable declarator.
continue;
case OperationKind.VariableDeclarator:
var variableDeclarator = (IVariableDeclaratorOperation)operation;
if (variableDeclarator.GetVariableInitializer() != null)
{
countOperand(variableDeclarator.Symbol);
}
continue;
// Invocations and Object creations.
case OperationKind.Invocation:
countOperator(operation);
var invocation = (IInvocationOperation)operation;
if (!invocation.TargetMethod.ReturnsVoid)
{
countOperand(invocation.TargetMethod);
}
continue;
case OperationKind.ObjectCreation:
countOperator(operation);
countOperand(((IObjectCreationOperation)operation).Constructor);
continue;
case OperationKind.DelegateCreation:
case OperationKind.AnonymousObjectCreation:
case OperationKind.TypeParameterObjectCreation:
case OperationKind.DynamicObjectCreation:
case OperationKind.DynamicInvocation:
countOperator(operation);
continue;
// Operators with special operator kinds.
case OperationKind.BinaryOperator:
countBinaryOperator(operation, ((IBinaryOperation)operation).OperatorKind);
continue;
case OperationKind.CompoundAssignment:
countBinaryOperator(operation, ((ICompoundAssignmentOperation)operation).OperatorKind);
continue;
case OperationKind.TupleBinaryOperator:
countBinaryOperator(operation, ((ITupleBinaryOperation)operation).OperatorKind);
continue;
case OperationKind.UnaryOperator:
countUnaryOperator(operation, ((IUnaryOperation)operation).OperatorKind);
continue;
case OperationKind.CaseClause:
var caseClauseOperation = (ICaseClauseOperation)operation;
distinctCaseKindsBuilder ??= ImmutableHashSet.CreateBuilder <CaseKind>();
distinctCaseKindsBuilder.Add(caseClauseOperation.CaseKind);
if (caseClauseOperation.CaseKind == CaseKind.Relational)
{
countBinaryOperator(operation, ((IRelationalCaseClauseOperation)operation).Relation);
}
else
{
countOperator(operation);
}
continue;
// Other common operators.
case OperationKind.Increment:
case OperationKind.Decrement:
case OperationKind.SimpleAssignment:
case OperationKind.DeconstructionAssignment:
case OperationKind.EventAssignment:
case OperationKind.Coalesce:
case OperationKind.ConditionalAccess:
case OperationKind.Conversion:
case OperationKind.ArrayElementReference:
case OperationKind.Await:
case OperationKind.NameOf:
case OperationKind.SizeOf:
case OperationKind.TypeOf:
case OperationKind.AddressOf:
case OperationKind.MemberInitializer:
case OperationKind.IsType:
case OperationKind.IsPattern:
case OperationKind.Parenthesized:
countOperator(operation);
continue;
// Following are considered operators for now, but we may want to revisit.
case OperationKind.ArrayCreation:
case OperationKind.ArrayInitializer:
case OperationKind.DynamicMemberReference:
case OperationKind.DynamicIndexerAccess:
case OperationKind.Tuple:
case OperationKind.Lock:
case OperationKind.Using:
case OperationKind.Throw:
case OperationKind.RaiseEvent:
case OperationKind.InterpolatedString:
countOperator(operation);
continue;
// Return value.
case OperationKind.Return:
case OperationKind.YieldBreak:
case OperationKind.YieldReturn:
if (((IReturnOperation)operation).ReturnedValue != null)
{
countOperator(operation);
}
continue;
}
}
return(Create(
executableLinesOfCode,
operatorUsageCounts,
symbolUsageCounts,
constantUsageCounts,
hasSymbolInitializer,
distinctOperatorKindsBuilder != null ? distinctOperatorKindsBuilder.ToImmutable() : ImmutableHashSet <OperationKind> .Empty,
distinctBinaryOperatorKindsBuilder != null ? distinctBinaryOperatorKindsBuilder.ToImmutable() : ImmutableHashSet <BinaryOperatorKind> .Empty,
distinctUnaryOperatorKindsBuilder != null ? distinctUnaryOperatorKindsBuilder.ToImmutable() : ImmutableHashSet <UnaryOperatorKind> .Empty,
distinctCaseKindsBuilder != null ? distinctCaseKindsBuilder.ToImmutable() : ImmutableHashSet <CaseKind> .Empty,
distinctReferencedSymbolsBuilder != null ? distinctReferencedSymbolsBuilder.ToImmutable() : ImmutableHashSet <ISymbol> .Empty,
distinctReferencedConstantsBuilder != null ? distinctReferencedConstantsBuilder.ToImmutable() : ImmutableHashSet <object> .Empty));
internal static async Task <NamedTypeMetricData> ComputeAsync(INamedTypeSymbol namedType, SemanticModelProvider semanticModelProvider, CancellationToken cancellationToken)
{
var coupledTypesBuilder = ImmutableHashSet.CreateBuilder <INamedTypeSymbol>();
ImmutableArray <SyntaxReference> declarations = namedType.DeclaringSyntaxReferences;
(int cyclomaticComplexity, ComputationalComplexityMetrics computationalComplexityMetrics) =
await MetricsHelper.ComputeCoupledTypesAndComplexityExcludingMemberDeclsAsync(declarations, namedType, coupledTypesBuilder, semanticModelProvider, cancellationToken).ConfigureAwait(false);
// Compat: Filter out nested types as they are children of most closest containing namespace.
var members = namedType.GetMembers().Where(m => m.Kind != SymbolKind.NamedType);
#if LEGACY_CODE_METRICS_MODE
// Legacy mode skips metrics for field/property/event symbols, and explicitly includes accessors as methods.
members = members.Where(m => m.Kind != SymbolKind.Field && m.Kind != SymbolKind.Property && m.Kind != SymbolKind.Event);
#else
// Filter out accessors as they are children of their associated symbols, for which we generate a separate node.
members = members.Where(m => m.Kind != SymbolKind.Method || ((IMethodSymbol)m).AssociatedSymbol == null);
#endif
ImmutableArray <CodeAnalysisMetricData> children = await ComputeAsync(members, semanticModelProvider, cancellationToken).ConfigureAwait(false);
// Heuristic to prevent simple fields (no initializer or simple initializer) from skewing the complexity.
ImmutableHashSet <IFieldSymbol> filteredFieldsForComplexity = getFilteredFieldsForComplexity();
int effectiveChildrenCountForComplexity = 0;
int singleEffectiveChildMaintainabilityIndex = -1;
foreach (CodeAnalysisMetricData child in children)
{
MetricsHelper.AddCoupledNamedTypes(coupledTypesBuilder, child.CoupledNamedTypes);
if (child.Symbol.Kind != SymbolKind.Field ||
filteredFieldsForComplexity.Contains((IFieldSymbol)child.Symbol))
{
singleEffectiveChildMaintainabilityIndex = effectiveChildrenCountForComplexity == 0 && computationalComplexityMetrics.IsDefault ?
child.MaintainabilityIndex :
-1;
effectiveChildrenCountForComplexity++;
cyclomaticComplexity += child.CyclomaticComplexity;
computationalComplexityMetrics = computationalComplexityMetrics.Union(child.ComputationalComplexityMetrics);
}
}
if (cyclomaticComplexity == 0 && !namedType.IsStatic)
{
// Empty named type, account for implicit constructor.
cyclomaticComplexity = 1;
}
int depthOfInheritance = CalculateDepthOfInheritance(namedType);
long linesOfCode = await MetricsHelper.GetLinesOfCodeAsync(declarations, namedType, semanticModelProvider, cancellationToken).ConfigureAwait(false);
int maintainabilityIndex = singleEffectiveChildMaintainabilityIndex != -1 ?
singleEffectiveChildMaintainabilityIndex :
CalculateMaintainabilityIndex(computationalComplexityMetrics, cyclomaticComplexity, effectiveChildrenCountForComplexity);
MetricsHelper.RemoveContainingTypes(namedType, coupledTypesBuilder);
return(new NamedTypeMetricData(namedType, maintainabilityIndex, computationalComplexityMetrics,
coupledTypesBuilder.ToImmutable(), linesOfCode, cyclomaticComplexity, depthOfInheritance, children));
ImmutableHashSet <IFieldSymbol> getFilteredFieldsForComplexity()
{
ImmutableHashSet <IFieldSymbol> .Builder?builderOpt = null;
var orderedFieldDatas = children.Where(c => c.Symbol.Kind == SymbolKind.Field).OrderBy(c => c.MaintainabilityIndex);
var indexThreshold = 99;
foreach (CodeAnalysisMetricData fieldData in orderedFieldDatas)
{
if (fieldData.MaintainabilityIndex > indexThreshold)
{
break;
}
builderOpt ??= ImmutableHashSet.CreateBuilder <IFieldSymbol>();
builderOpt.Add((IFieldSymbol)fieldData.Symbol);
indexThreshold -= 4;
}
return(builderOpt?.ToImmutable() ?? ImmutableHashSet <IFieldSymbol> .Empty);
}
}
private ImmutableHashSet <ProjectReference> GetProjectReferences() => _projectReferences.ToImmutable();
protected override IImmutableSet <T> Complete(ImmutableHashSet <T> .Builder intermediateCollection)
{
return(intermediateCollection.ToImmutable());
}
protected override void Finalize(ImmutableHashSet <TItem> .Builder builder, ref ImmutableHashSet <TItem> collection) => collection = builder.ToImmutable();
public static ComputationalComplexityMetrics Compute(IOperation operationBlock)
{
Debug.Assert(operationBlock != null);
long effectiveLinesOfCode = 0;
long operatorUsageCounts = 0;
long symbolUsageCounts = 0;
long constantUsageCounts = 0;
ImmutableHashSet <OperationKind> .Builder distinctOperatorKindsBuilder = null;
ImmutableHashSet <BinaryOperatorKind> .Builder distinctBinaryOperatorKindsBuilder = null;
ImmutableHashSet <UnaryOperatorKind> .Builder distinctUnaryOperatorKindsBuilder = null;
ImmutableHashSet <CaseKind> .Builder distinctCaseKindsBuilder = null;
ImmutableHashSet <ISymbol> .Builder distinctReferencedSymbolsBuilder = null;
ImmutableHashSet <object> .Builder distinctReferencedConstantsBuilder = null;
foreach (var operation in operationBlock.Descendants())
{
effectiveLinesOfCode += getEffectiveLinesOfCode(operation);
if (operation.IsImplicit)
{
continue;
}
#if LEGACY_CODE_METRICS_MODE
// Legacy mode does not account for code within lambdas/local functions for code metrics.
if (operation.IsWithinLambdaOrLocalFunction())
{
continue;
}
#endif
if (operation.ConstantValue.HasValue)
{
constantUsageCounts++;
distinctReferencedConstantsBuilder = distinctReferencedConstantsBuilder ?? ImmutableHashSet.CreateBuilder <object>();
distinctReferencedConstantsBuilder.Add(operation.ConstantValue.Value ?? s_nullConstantPlaceholder);
continue;
}
switch (operation.Kind)
{
// Symbol references.
case OperationKind.LocalReference:
countOperand(((ILocalReferenceOperation)operation).Local);
continue;
case OperationKind.ParameterReference:
countOperand(((IParameterReferenceOperation)operation).Parameter);
continue;
case OperationKind.FieldReference:
case OperationKind.MethodReference:
case OperationKind.PropertyReference:
case OperationKind.EventReference:
countOperator(operation);
countOperand(((IMemberReferenceOperation)operation).Member);
continue;
// Symbol initializers.
case OperationKind.FieldInitializer:
foreach (var field in ((IFieldInitializerOperation)operation).InitializedFields)
{
countOperator(operation);
countOperand(field);
}
continue;
case OperationKind.PropertyInitializer:
foreach (var property in ((IPropertyInitializerOperation)operation).InitializedProperties)
{
countOperator(operation);
countOperand(property);
}
continue;
case OperationKind.ParameterInitializer:
countOperator(operation);
countOperand(((IParameterInitializerOperation)operation).Parameter);
continue;
case OperationKind.VariableInitializer:
countOperator(operation);
// We count the operand in the variable declarator.
continue;
case OperationKind.VariableDeclarator:
var variableDeclarator = (IVariableDeclaratorOperation)operation;
if (variableDeclarator.GetVariableInitializer() != null)
{
countOperand(variableDeclarator.Symbol);
}
continue;
// Invocations and Object creations.
case OperationKind.Invocation:
countOperator(operation);
var invocation = (IInvocationOperation)operation;
if (!invocation.TargetMethod.ReturnsVoid)
{
countOperand(invocation.TargetMethod);
}
continue;
case OperationKind.ObjectCreation:
countOperator(operation);
countOperand(((IObjectCreationOperation)operation).Constructor);
continue;
case OperationKind.DelegateCreation:
case OperationKind.AnonymousObjectCreation:
case OperationKind.TypeParameterObjectCreation:
case OperationKind.DynamicObjectCreation:
case OperationKind.DynamicInvocation:
countOperator(operation);
continue;
// Operators with special operator kinds.
case OperationKind.BinaryOperator:
countBinaryOperator(operation, ((IBinaryOperation)operation).OperatorKind);
continue;
case OperationKind.CompoundAssignment:
countBinaryOperator(operation, ((ICompoundAssignmentOperation)operation).OperatorKind);
continue;
// https://github.com/dotnet/roslyn-analyzers/issues/1742
//case OperationKind.TupleBinaryOperator:
// countBinaryOperator(operation, ((ITupleBinaryOperation)operation).OperatorKind);
// continue;
case OperationKind.UnaryOperator:
countUnaryOperator(operation, ((IUnaryOperation)operation).OperatorKind);
continue;
case OperationKind.CaseClause:
var caseClauseOperation = (ICaseClauseOperation)operation;
distinctCaseKindsBuilder = distinctCaseKindsBuilder ?? ImmutableHashSet.CreateBuilder <CaseKind>();
distinctCaseKindsBuilder.Add(caseClauseOperation.CaseKind);
if (caseClauseOperation.CaseKind == CaseKind.Relational)
{
countBinaryOperator(operation, ((IRelationalCaseClauseOperation)operation).Relation);
}
else
{
countOperator(operation);
}
continue;
// Other common operators.
case OperationKind.Increment:
case OperationKind.Decrement:
case OperationKind.SimpleAssignment:
case OperationKind.DeconstructionAssignment:
case OperationKind.EventAssignment:
case OperationKind.Coalesce:
case OperationKind.ConditionalAccess:
case OperationKind.Conversion:
case OperationKind.ArrayElementReference:
case OperationKind.Await:
case OperationKind.NameOf:
case OperationKind.SizeOf:
case OperationKind.TypeOf:
case OperationKind.AddressOf:
case OperationKind.MemberInitializer:
case OperationKind.IsType:
case OperationKind.IsPattern:
case OperationKind.Parenthesized:
countOperator(operation);
continue;
// Following are considered operators for now, but we may want to revisit.
case OperationKind.ArrayCreation:
case OperationKind.ArrayInitializer:
case OperationKind.DynamicMemberReference:
case OperationKind.DynamicIndexerAccess:
case OperationKind.Tuple:
case OperationKind.Lock:
case OperationKind.Using:
case OperationKind.Throw:
case OperationKind.RaiseEvent:
case OperationKind.InterpolatedString:
countOperator(operation);
continue;
// Return value.
case OperationKind.Return:
case OperationKind.YieldBreak:
case OperationKind.YieldReturn:
if (((IReturnOperation)operation).ReturnedValue != null)
{
countOperator(operation);
}
continue;
}
}
return(Create(
effectiveLinesOfCode,
operatorUsageCounts,
symbolUsageCounts,
constantUsageCounts,
distinctOperatorKindsBuilder != null ? distinctOperatorKindsBuilder.ToImmutable() : ImmutableHashSet <OperationKind> .Empty,
distinctBinaryOperatorKindsBuilder != null ? distinctBinaryOperatorKindsBuilder.ToImmutable() : ImmutableHashSet <BinaryOperatorKind> .Empty,
distinctUnaryOperatorKindsBuilder != null ? distinctUnaryOperatorKindsBuilder.ToImmutable() : ImmutableHashSet <UnaryOperatorKind> .Empty,
distinctCaseKindsBuilder != null ? distinctCaseKindsBuilder.ToImmutable() : ImmutableHashSet <CaseKind> .Empty,
distinctReferencedSymbolsBuilder != null ? distinctReferencedSymbolsBuilder.ToImmutable() : ImmutableHashSet <ISymbol> .Empty,
distinctReferencedConstantsBuilder != null ? distinctReferencedConstantsBuilder.ToImmutable() : ImmutableHashSet <object> .Empty));
int getEffectiveLinesOfCode(IOperation operation)
{
if (operation.Parent != null)
{
switch (operation.Parent.Kind)
{
case OperationKind.Block:
return(hasAnyExplicitExpression(operation) ? 1 : 0);
case OperationKind.FieldInitializer:
case OperationKind.PropertyInitializer:
case OperationKind.ParameterInitializer:
// Count declaration and initialization.
return(hasAnyExplicitExpression(operation) ? 2 : 0);
}
}
return(0);
}
bool hasAnyExplicitExpression(IOperation operation)
{
// Check if all descendants are either implicit or are explicit with no constant value or type, indicating it is not user written code.
return(!operation.DescendantsAndSelf().All(o => o.IsImplicit || (!o.ConstantValue.HasValue && o.Type == null)));
}
void countOperator(IOperation operation)
{
operatorUsageCounts++;
distinctOperatorKindsBuilder = distinctOperatorKindsBuilder ?? ImmutableHashSet.CreateBuilder <OperationKind>();
distinctOperatorKindsBuilder.Add(operation.Kind);
}
void countOperand(ISymbol symbol)
{
symbolUsageCounts++;
distinctReferencedSymbolsBuilder = distinctReferencedSymbolsBuilder ?? ImmutableHashSet.CreateBuilder <ISymbol>();
distinctReferencedSymbolsBuilder.Add(symbol);
}
void countBinaryOperator(IOperation operation, BinaryOperatorKind operatorKind)
{
countOperator(operation);
distinctBinaryOperatorKindsBuilder = distinctBinaryOperatorKindsBuilder ?? ImmutableHashSet.CreateBuilder <BinaryOperatorKind>();
distinctBinaryOperatorKindsBuilder.Add(operatorKind);
}
void countUnaryOperator(IOperation operation, UnaryOperatorKind operatorKind)
{
countOperator(operation);
distinctUnaryOperatorKindsBuilder = distinctUnaryOperatorKindsBuilder ?? ImmutableHashSet.CreateBuilder <UnaryOperatorKind>();
distinctUnaryOperatorKindsBuilder.Add(operatorKind);
}
}
