public async Task<ITypeMetric> CalculateFrom(TypeDeclarationSyntaxInfo typeNode, IEnumerable<IMemberMetric> metrics)
{
var memberMetrics = metrics.AsArray();
var type = typeNode.Syntax;
var symbol = Model.GetDeclaredSymbol(type);
var documentation = await _documentationFactory.Create(symbol, CancellationToken.None);
var metricKind = GetMetricKind(type);
var source = CalculateClassCoupling(type, memberMetrics);
var depthOfInheritance = CalculateDepthOfInheritance(type);
var cyclomaticComplexity = memberMetrics.Sum(x => x.CyclomaticComplexity);
var linesOfCode = memberMetrics.Sum(x => x.LinesOfCode);
var maintainabilityIndex = CalculateAveMaintainabilityIndex(memberMetrics);
var afferentCoupling = await CalculateAfferentCoupling(type);
var efferentCoupling = GetEfferentCoupling(type, symbol);
var instability = (double)efferentCoupling / (efferentCoupling + afferentCoupling);
var modifier = GetAccessModifier(type.Modifiers);
return new TypeMetric(
symbol.IsAbstract,
metricKind,
modifier,
memberMetrics,
linesOfCode,
cyclomaticComplexity,
maintainabilityIndex,
depthOfInheritance,
source,
type.GetName(),
afferentCoupling,
efferentCoupling,
instability,
documentation);
}
public async Task <ITypeMetric> CalculateFrom(TypeDeclarationSyntaxInfo typeNode, IEnumerable <IMemberMetric> metrics)
{
var memberMetrics = metrics.AsArray();
var type = typeNode.Syntax;
var symbol = Model.GetDeclaredSymbol(type);
var documentation = await _documentationFactory.Create(symbol, CancellationToken.None);
var metricKind = GetMetricKind(type);
var source = CalculateClassCoupling(type, memberMetrics);
var depthOfInheritance = CalculateDepthOfInheritance(type);
var cyclomaticComplexity = memberMetrics.Sum(x => x.CyclomaticComplexity);
var linesOfCode = memberMetrics.Sum(x => x.LinesOfCode);
var maintainabilityIndex = CalculateAveMaintainabilityIndex(memberMetrics);
var afferentCoupling = await CalculateAfferentCoupling(type);
var efferentCoupling = GetEfferentCoupling(type, symbol);
var instability = (double)efferentCoupling / (efferentCoupling + afferentCoupling);
var modifier = GetAccessModifier(type.Modifiers);
return(new TypeMetric(
symbol.IsAbstract,
metricKind,
modifier,
memberMetrics,
linesOfCode,
cyclomaticComplexity,
maintainabilityIndex,
depthOfInheritance,
source,
type.GetName(),
afferentCoupling,
efferentCoupling,
instability,
documentation));
}
private TypeMetric CalculateTypeMetrics(Compilation compilation, TypeDeclaration typeNodes, MemberMetrics memberMetrics)
{
if (!typeNodes.SyntaxNodes.Any <TypeDeclarationSyntaxInfo>())
{
return(null);
}
TypeDeclarationSyntaxInfo typeDeclarationSyntaxInfo = typeNodes.SyntaxNodes.FirstOrDefault <TypeDeclarationSyntaxInfo>();
SemanticModel semanticModel = compilation.GetSemanticModel(typeDeclarationSyntaxInfo.Syntax.SyntaxTree);
return((new TypeMetricsCalculator(semanticModel)).CalculateFrom(typeDeclarationSyntaxInfo, memberMetrics));
}
public MemberMetrics Calculate(TypeDeclarationSyntaxInfo typeNode)
{
SyntaxNode root = base.Context.Root;
MemberCollectorSyntaxWalker memberCollectorSyntaxWalker = new MemberCollectorSyntaxWalker();
IEnumerable <MemberNode> members = memberCollectorSyntaxWalker.GetMembers(base.Context.Model, typeNode);
MemberMetrics memberMetric = new MemberMetrics()
{
Results = this.CalculateMemberMetrics(members).ToList <MemberMetric>().AsReadOnly()
};
return(memberMetric);
}
public IEnumerable <MemberNode> GetMembers(SemanticModel semanticModel, TypeDeclarationSyntaxInfo type)
{
this.Visit(type.Syntax);
MemberNameResolver memberNameResolver = new MemberNameResolver(semanticModel);
this.members.ForEach <MemberNode>((MemberNode x) => {
string str;
memberNameResolver.TryResolveMemberSignatureString(x, out str);
x.DisplayName = str;
x.CodeFile = type.CodeFile;
x.LineNumber = x.SyntaxNode.GetLineNumber();
});
return(this.members.ToList <MemberNode>().AsReadOnly());
}
public async Task<IEnumerable<IMemberMetric>> Calculate(TypeDeclarationSyntaxInfo typeNode)
{
var walker = new MemberCollector();
var members = walker.GetMembers(typeNode).AsArray();
if ((typeNode.Syntax is ClassDeclarationSyntax
|| typeNode.Syntax is StructDeclarationSyntax)
&& members.All(m => m.Kind() != SyntaxKind.ConstructorDeclaration))
{
var defaultConstructor = SyntaxFactory.ConstructorDeclaration(typeNode.Name)
.WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword)))
.WithBody(SyntaxFactory.Block());
members = members.Concat(new[] { defaultConstructor }).AsArray();
}
var metrics = await CalculateMemberMetrics(members).ConfigureAwait(false);
return metrics.AsArray();
}
public async Task <IEnumerable <IMemberMetric> > Calculate(TypeDeclarationSyntaxInfo typeNode)
{
var walker = new MemberCollector();
var members = walker.GetMembers(typeNode).AsArray();
if ((typeNode.Syntax is ClassDeclarationSyntax ||
typeNode.Syntax is StructDeclarationSyntax) &&
members.All(m => m.Kind() != SyntaxKind.ConstructorDeclaration))
{
var defaultConstructor = SyntaxFactory.ConstructorDeclaration(typeNode.Name)
.WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword)))
.WithBody(SyntaxFactory.Block());
members = members.Concat(new[] { defaultConstructor }).AsArray();
}
var metrics = await CalculateMemberMetrics(members).ConfigureAwait(false);
return(metrics.AsArray());
}
public TypeMetric CalculateFrom(TypeDeclarationSyntaxInfo typeNode, MemberMetrics memberMetrics)
{
TypeDeclarationSyntax syntax = (TypeDeclarationSyntax)typeNode.Syntax;
TypeMetricKind metricKind = TypeMetricsCalculator.GetMetricKind(syntax);
LcomMetrics lcomMetric = this.CalculateLackOfCohesion(syntax);
TypeMetric typeMetric = new TypeMetric()
{
Name = TypeMetricsCalculator.GetDisplayName(syntax),
Kind = metricKind,
MemberMetrics = memberMetrics
};
List <MetricResult> metricResults = new List <MetricResult>();
foreach (MetricCalculator calculator in calculators)
{
typeMetric.AddMetricResult(calculator.Calculate <MemberMetrics, MemberMetric>(memberMetrics));
}
typeMetric.AddMetricResult(new MetricResult()
{
Name = MetricNames.LackOfCohesionOfMethods,
Value = lcomMetric.Lcom
});
typeMetric.AddMetricResult(new MetricResult()
{
Name = MetricNames.LackOfCohesionOfMethodsHendersonSellers,
Value = lcomMetric.LcomHendersonSellers
});
typeMetric.AddMetricResult(new MetricResult()
{
Name = MetricNames.NumberOfFields,
Value = lcomMetric.NumFields
});
typeMetric.AddMetricResult(new MetricResult()
{
Name = MetricNames.NumberOfMethods,
Value = lcomMetric.NumMethods
});
return(typeMetric);
}
private static async Task <Tuple <Compilation, SemanticModel, TypeDeclarationSyntaxInfo> > VerifyCompilation(Compilation compilation, TypeDeclarationSyntaxInfo typeNode)
{
var tree = typeNode.Syntax.SyntaxTree;
if (tree == null)
{
var cu = CSharpSyntaxTree.Create(
SyntaxFactory
.CompilationUnit()
.WithMembers(SyntaxFactory.List(new[] { (MemberDeclarationSyntax)typeNode.Syntax })));
var root = await cu.GetRootAsync().ConfigureAwait(false);
typeNode.Syntax = (TypeDeclarationSyntax)root.ChildNodes().First();
var newCompilation = compilation.AddSyntaxTrees(cu);
var semanticModel = newCompilation.GetSemanticModel(cu);
return(new Tuple <Compilation, SemanticModel, TypeDeclarationSyntaxInfo>(newCompilation, semanticModel, typeNode));
}
var result = AddToCompilation(compilation, tree);
var childNodes = result.Item2.GetRoot().DescendantNodesAndSelf();
typeNode.Syntax = childNodes.OfType <TypeDeclarationSyntax>().First();
return(new Tuple <Compilation, SemanticModel, TypeDeclarationSyntaxInfo>(
result.Item1,
result.Item1.GetSemanticModel(result.Item2),
typeNode));
}
public IEnumerable<SyntaxNode> GetMembers(TypeDeclarationSyntaxInfo type)
{
Visit(type.Syntax);
return _members.ToList();
}
public IEnumerable <SyntaxNode> GetMembers(TypeDeclarationSyntaxInfo type)
{
Visit(type.Syntax);
return(_members.ToList());
}
private static async Task<Tuple<Compilation, SemanticModel, TypeDeclarationSyntaxInfo>> VerifyCompilation(Compilation compilation, TypeDeclarationSyntaxInfo typeNode)
{
var tree = typeNode.Syntax.SyntaxTree;
if (tree == null)
{
var cu = CSharpSyntaxTree.Create(
SyntaxFactory
.CompilationUnit()
.WithMembers(SyntaxFactory.List(new[] { (MemberDeclarationSyntax)typeNode.Syntax })));
var root = await cu.GetRootAsync().ConfigureAwait(false);
typeNode.Syntax = (TypeDeclarationSyntax)root.ChildNodes().First();
var newCompilation = compilation.AddSyntaxTrees(cu);
var semanticModel = newCompilation.GetSemanticModel(cu);
return new Tuple<Compilation, SemanticModel, TypeDeclarationSyntaxInfo>(newCompilation, semanticModel, typeNode);
}
var result = AddToCompilation(compilation, tree);
var childNodes = result.Item2.GetRoot().DescendantNodesAndSelf();
typeNode.Syntax = childNodes.OfType<TypeDeclarationSyntax>().First();
return new Tuple<Compilation, SemanticModel, TypeDeclarationSyntaxInfo>(
result.Item1,
result.Item1.GetSemanticModel(result.Item2),
typeNode);
}
