public string Generate(ClassDeclarationSyntax classToOverride)
{
var topOfTheTree = (CompilationUnitSyntax)classToOverride.Ancestors().Last();
var nsName = classToOverride.Ancestors().OfType <NamespaceDeclarationSyntax>().First().Name;
var cu = SyntaxFactory.CompilationUnit()
.AddUsings(topOfTheTree.Usings.ToArray());
var ns = SyntaxFactory.NamespaceDeclaration(nsName);
var props = GetProperties(classToOverride);
var newClass = SyntaxFactory.ClassDeclaration("Testing123") //CalculateCorrectName
.AddBaseListTypes(SyntaxFactory.SimpleBaseType(SyntaxFactory.ParseTypeName(classToOverride.Identifier.Text)))
.AddModifiers(classToOverride.Modifiers.ToArray())
.AddMembers(
props.Select(p =>
{
var newModifierList = new SyntaxTokenList(p.Modifiers.Where(m => m.Kind() != SyntaxKind.VirtualKeyword)
.Concat(new[] { SyntaxFactory.Token(SyntaxKind.OverrideKeyword) }));
return(SyntaxFactory.PropertyDeclaration(p.Type, p.Identifier)
.WithModifiers(newModifierList)
.AddAttributeLists(JsonLibraryAttribute(GetJproperty(p)))
.AddAccessorListAccessors(p.AccessorList.Accessors.ToArray()));
})
.Cast <MemberDeclarationSyntax>().ToArray());
return(cu.AddMembers(ns.AddMembers(newClass)).NormalizeWhitespace().ToFullString());
}
/// <summary>
/// Get the namespace of the class.
/// </summary>
void FillNamespace()
{
Namespace = classDeclarationSyntax.Ancestors()
.OfType <NamespaceDeclarationSyntax>()
.Select(n => n.Name.GetText().ToString().Trim())
.FirstOrDefault() ?? "";
}
private void DeclareClass(ClassDeclarationSyntax node)
{
var owners = ImmutableArray <string> .Empty;
foreach (var ancestor in node.Ancestors())
{
switch (ancestor)
{
case NamespaceDeclarationSyntax ns:
owners = owners.Insert(0, "namespace " + ns.Name.WithoutTrivia());
break;
case ClassDeclarationSyntax c:
owners = owners.Insert(0, "partial class " + c.Identifier.WithoutTrivia());
break;
}
}
owners = owners.Add("partial class " + node.Identifier.WithoutTrivia());
for (var i = 0; i < owners.Length; i++)
{
Output
.AppendLine(owners[i])
.AppendLine("{");
_indentation.Add(Output.Indent());
}
}
public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node)
{
NamespaceDeclarationSyntax namespaceDeclaration = node.Ancestors().OfType <NamespaceDeclarationSyntax>().FirstOrDefault();
node = (ClassDeclarationSyntax)base.VisitClassDeclaration(node);
var classTemplates = new List <AopTemplate>();
var globalTemplates = _templateService.GetGlobalTemplates(_filePath, namespaceDeclaration?.Name?.ToString(), node.Identifier.ToString());
classTemplates.AddRange(globalTemplates.Where(w => w.Action == Action));
classTemplates.ForEach(s => s.AppliedTo = AopTemplateApplied.Class);
string className = node.Identifier.ToString();
Console.Out.WriteLine("Class: " + className);
if (BuilderSettings.Verbosity > 2)
{
Console.Out.WriteLine("Old code:");
Console.Out.WriteLine(node.ToFullString());
}
AopRewriter.AddTemplatesFromAttributes(classTemplates, Action, node.AttributeLists, AopTemplateAction.Methods);
ClassDeclarationSyntax result = AopRewriter.ProcessTemplates <ClassDeclarationSyntax>(_templateService, classTemplates, node, node);
return(result);
}
public static IEnumerable <(SyntaxKind Kind, string Name)> AncestorMembers(this ClassDeclarationSyntax node)
{
foreach (var ancestor in node.Ancestors().OfType <MemberDeclarationSyntax>())
{
string?name = null;
var kind = default(SyntaxKind);
if (ancestor is NamespaceDeclarationSyntax ns)
{
kind = SyntaxKind.NamespaceDeclaration;
name = ns.Name.WithoutTrivia().ToString();
}
else if (ancestor is ClassDeclarationSyntax c)
{
kind = SyntaxKind.ClassDeclaration;
name = c.Identifier.WithoutTrivia().ToString();
}
else
{
TryGetAncestorMember(ancestor, ref kind, ref name);
}
if (name != null)
{
yield return(kind, name);
}
}
}
public static string GetFullName(this ClassDeclarationSyntax node)
{
var result = new StringBuilder(node.Identifier.WithoutTrivia().ToString());
foreach (var ancestor in node.Ancestors())
{
string?name = null;
switch (ancestor)
{
case NamespaceDeclarationSyntax ns:
name = ns.Name.WithoutTrivia().ToString();
break;
case ClassDeclarationSyntax c:
name = c.Identifier.WithoutTrivia().ToString();
break;
}
if (!string.IsNullOrEmpty(name))
{
result.Insert(0, ".");
result.Insert(0, name);
}
}
return(result.ToString());
}
public OptionsDecryptorGenerator(OptionClass optionClass)
{
this.optionClass = optionClass;
classDeclaration = optionClass.ClassDeclaration;
optionClassName = classDeclaration.Identifier.ValueText;
namespaceName = classDeclaration.Ancestors().OfType <NamespaceDeclarationSyntax>().ElementAt(0);
fullName = namespaceName.Name + "." + optionClassName;
}
public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node)
{
var updated = !node.Ancestors().OfType <TypeDeclarationSyntax>().Any()
? node.AddAttributeLists(GetTypeDeclarationAttributes())
.WithModifiers(this.GetTypeDeclarationModifiers(node.Modifiers))
: node;
return(base.VisitClassDeclaration(updated));
}
public static bool ExcludeFromExternalCoverage(this ClassDeclarationSyntax claz)
{
if (claz == null)
{
return(true);
}
var namespaceNode = claz.Ancestors <NamespaceDeclarationSyntax>().LastOrDefault <SyntaxNode>();
if (namespaceNode != null &&
namespaceNode.GetLeadingTrivia().ToString().Contains("<auto-generated>"))
{
return(true);
}
var baseListSyntax = claz.BaseList;
if (baseListSyntax != null &&
baseListSyntax.Types.Any())
{
foreach (var type in baseListSyntax.Types)
{
var typeSyntax = type.Type;
var baseClass = typeSyntax.ToString();
if (typeSyntax is GenericNameSyntax syntax)
{
baseClass = syntax.Identifier.ValueText;
}
if (baseClass.Equals("DbContext", StringComparison.InvariantCultureIgnoreCase) ||
baseClass.EndsWith("Exception", StringComparison.InvariantCultureIgnoreCase))
{
return(true);
}
}
}
var className = claz.ClassName();
if (claz.NameSpace().StartsWith("System.Linq", StringComparison.InvariantCultureIgnoreCase) ||
className != null &&
(className.EndsWith("Collections", StringComparison.InvariantCultureIgnoreCase) ||
className.EndsWith("Collection", StringComparison.InvariantCultureIgnoreCase)))
{
return(true);
}
return(claz.DescendantNodes <MethodDeclarationSyntax>().All(x =>
{
var valueText = x.Identifier.ValueText;
return MethodsToExcludeFromExternalCoverage.Contains(valueText) ||
x.ReturnType.ToString() == className;
}));
}
public IEnumerable <AopTemplate> GetPropertyTemplates(PropertyDeclarationSyntax node)
{
ClassDeclarationSyntax classDeclaration = node.Ancestors().OfType <ClassDeclarationSyntax>().FirstOrDefault();
NamespaceDeclarationSyntax namespaceDeclaration = classDeclaration.Ancestors().OfType <NamespaceDeclarationSyntax>().FirstOrDefault();
var propertyTemplates = new List <AopTemplate>();
var globalTemplate = _templateService.GetGlobalTemplates(_filePath, namespaceDeclaration?.Name?.ToString(), classDeclaration?.Identifier.ToString(), propertyName: node.Identifier.ToString());
propertyTemplates.AddRange(globalTemplate.Where(w => w.Action == AopTemplateAction.All || w.Action == AopTemplateAction.Properties));
AddTemplatesFromClass(propertyTemplates, AopTemplateAction.Properties, classDeclaration, node.Identifier.ToString(), node.Modifiers);
AddTemplatesFromAttributes(propertyTemplates, AopTemplateAction.Properties, node.AttributeLists, AopTemplateAction.Properties);
if (!String.IsNullOrEmpty(BuilderSettings.OnlyTemplate))
{
return(propertyTemplates.Where(w => w.TemplateName == BuilderSettings.OnlyTemplate));
}
return(propertyTemplates.OrderBy(o => o.AdvicePriority));
}
private static StringBuilder ProcessTraitInternal(GeneratorExecutionContext context, ClassDeclarationSyntax traitClass, Dictionary <string, ClassDeclarationSyntax> availableTraits)
{
// make sure it is abstract and partial class
SyntaxTokenList modifiers = traitClass.Modifiers;
if (!modifiers.Any(w => w.Kind() == SyntaxKind.PartialKeyword) || !modifiers.Any(w => w.Kind() == SyntaxKind.AbstractKeyword))
{
return(Utils.ReturnError($"in {traitClass.Identifier.ToString()}: Trait must be defined as an abstract and partial class"));
}
var sb = new StringBuilder();
var namespaceNode = traitClass.Ancestors().OfType <NamespaceDeclarationSyntax>().FirstOrDefault();
string fullTraitClassName = (namespaceNode != null ? (namespaceNode.Name + ".") : "") + traitClass.Identifier;
availableTraits[fullTraitClassName] = traitClass;
if (traitClass.BaseList == null)
{
return(sb);
}
var semanticModel = context.Compilation.GetSemanticModel(traitClass.SyntaxTree);
if (Utils.IsStrictMode(traitClass))
{
// for strict method we need to skip for errors, because they are already added to the source
// and also skip for method with the same name, but different signature
if (!CheckStrictMode(traitClass, semanticModel, sb))
{
return(sb);
}
}
AddProxy(traitClass, sb, semanticModel, namespaceNode);
return(sb);
}
public override void VisitClassDeclaration(ClassDeclarationSyntax node)
{
int startLine = node.GetLocation().GetLineSpan().StartLinePosition.Line + 1;
int endLine = node.GetLocation().GetLineSpan().EndLinePosition.Line + 1;
string name = node.Identifier.ToString();
NamespaceDeclarationSyntax namespaceNode = node.Ancestors().OfType <NamespaceDeclarationSyntax>().FirstOrDefault();
string @namespace = namespaceNode != null?namespaceNode.Name.ToString() : "";
Func <Smell, bool> predicate = s => s.ClassName == name && s.ClassNamespace == @namespace;
var visitedClass = new Class
{
FileName = _fileName,
Namespace = @namespace,
Name = name,
SmellsCount = SmellsStore.Smells.Count(predicate),
AbstractionSmellsCount = SmellsStore.Smells.Where(s => s.Type == SmellType.Abstraction).Count(predicate),
EncapsulationSmellsCount = SmellsStore.Smells.Where(s => s.Type == SmellType.Encapsulation).Count(predicate),
ModularizationSmellsCount = SmellsStore.Smells.Where(s => s.Type == SmellType.Modularization).Count(predicate),
HierarchySmellsCount = SmellsStore.Smells.Where(s => s.Type == SmellType.Hierarchy).Count(predicate),
};
_locationStore.AddLocationRelativeToClass(startLine - 1, LocationRelativeToClass.ClassDescription, visitedClass);
_locationStore.AddLocationRelativeToClass(startLine, LocationRelativeToClass.ClassStart, visitedClass);
_locationStore.AddLocationRelativeToClass(startLine + 1, endLine - 1, LocationRelativeToClass.ClassInner, visitedClass);
_locationStore.AddLocationRelativeToClass(endLine, LocationRelativeToClass.ClassEnd, visitedClass);
// Handle partial classes
if (!_classStore.Classes.Exists(c => c.Name == name && c.Namespace == @namespace))
{
_classStore.Classes.Add(visitedClass);
}
base.VisitClassDeclaration(node);
}
private NamespaceDeclarationSyntax GetNamespace(ClassDeclarationSyntax node) => node.Ancestors().OfType <NamespaceDeclarationSyntax>().Single();
