private static void EditInterfaceBaseInterfaces(
InterfaceWithCodeAnalysis @interface,
string oldInterfaceName,
List <ITypeReferenceWithCodeAnalysis> genericParameters)
{
foreach (InterfaceReferenceWithCodeAnalysis reference in @interface.Interfaces.ToArray())
{
string referenceName = reference.Name;
if (referenceName == "IVisitable")
{
UnspecifiedTypeReferenceWithCodeAnalysis genericParameterType =
reference.GenericParameters[0] as UnspecifiedTypeReferenceWithCodeAnalysis;
genericParameterType.Name = genericParameterType.Name.Replace("Generic", "Editable");
}
else
{
reference.Name = GetNewName(referenceName);
}
}
InterfaceReferenceWithCodeAnalysis interfaceReference = new InterfaceReferenceWithCodeAnalysis(
oldInterfaceName,
genericParameters.ToArray());
@interface.Interfaces.Add(interfaceReference);
}
private static List <ITypeReferenceWithCodeAnalysis> EditInterfaceGenericParameters(
InterfaceWithCodeAnalysis @interface)
{
List <ITypeReferenceWithCodeAnalysis> genericParameters = new List <ITypeReferenceWithCodeAnalysis>();
foreach (GenericParameterDeclarationWithCodeAnalysis parameter in @interface.GenericParameters)
{
genericParameters.Add(new GenericParameterReferenceWithCodeAnalysis(parameter.Name));
if (parameter.InterfaceConstraints.Count == 0)
{
continue;
}
InterfaceReferenceWithCodeAnalysis constraint = parameter.InterfaceConstraints.First();
constraint.Name = GetNewName(constraint.Name);
}
return(genericParameters);
}
private static async Task GenerateEditableWrappers()
{
string baseDirectory = Path.GetFullPath(
Path.Combine(Path.GetDirectoryName(typeof(Program).Assembly.Location), @"..\..\..\.."));
ProjectWithCodeAnalysis project = await ProjectWithCodeAnalysis.OpenAsync(
Path.Combine(baseDirectory, @"CSharpDom\CSharpDom.csproj"));
project.Lock();
foreach (DocumentWithCodeAnalysis document in project.Documents.OrderBy(document => document.FullFilePath))
{
document.IsLocked = true;
string filePath = document.FullFilePath;
if (!filePath.Contains(@"CSharpDom\BaseClasses\Wrappers"))
{
continue;
}
string newDirectory = Path.GetDirectoryName(filePath)
.Replace(@"CSharpDom\BaseClasses\Wrappers", @"CSharpDom\BaseClasses\Editable\Wrappers");
string destinationPath = Path.Combine(newDirectory, GetNewName(Path.GetFileName(filePath)));
if (File.Exists(destinationPath))
{
continue;
}
LoadedDocumentWithCodeAnalysis loadedDocument = await document.LoadAsync();
NamespaceWithCodeAnalysis @namespace = loadedDocument.Namespaces.First();
Console.WriteLine($"Writing: {Path.GetFileName(destinationPath)}");
string namespaceName = @namespace.Name;
using (CodeAnalysisSettings.AllowEdits(loadedDocument))
{
foreach (UsingDirectiveWithCodeAnalysis directive in loadedDocument.UsingDirectives)
{
directive.Name = directive.Name.Replace("CSharpDom.Common", "CSharpDom.Common.Editable");
}
loadedDocument.UsingDirectives.Add(new UsingDirectiveWithCodeAnalysis("CSharpDom.Common"));
loadedDocument.UsingDirectives = loadedDocument.UsingDirectives
.OrderBy(directive => directive.Name)
.ToArray();
@namespace.Name = "CSharpDom.BaseClasses.Editable.Wrappers";
SealedClassWithCodeAnalysis @class = @namespace.Classes.SealedClasses.First();
@class.Name = "Editable" + @class.Name;
@class.BaseClass.Name = Regex.Replace(@class.BaseClass.Name, "^Abstract", "Editable");
ITypeReferenceWithCodeAnalysis interfaceReference =
@class.ImplementedInterfaces.First().GenericParameters[0];
interfaceReference.Name = Regex.Replace(interfaceReference.Name, "^I", "IEditable");
foreach (GenericParameterDeclarationWithCodeAnalysis genericParameter in @class.GenericParameters)
{
InterfaceReferenceWithCodeAnalysis constraint = genericParameter.InterfaceConstraints.First();
constraint.Name = Regex.Replace(constraint.Name, "^I", "IEditable");
}
ITypeReferenceWithCodeAnalysis constructorParameterType =
@class.Constructors.First().Parameters[0].ParameterType;
constructorParameterType.Name = Regex.Replace(constructorParameterType.Name, "^I", "IEditable");
foreach (SealedClassAutoPropertyWithCodeAnalysis property in @class.Properties.AutoProperties)
{
if (property.Name == "WrappedObject")
{
//CodeAnalysisLogger.StartLoggingDebugMessages();
property.PropertyType.Name = Regex.Replace(property.PropertyType.Name, "^I", "IEditable");
//string[] logMessages = CodeAnalysisLogger.GetDebugLogMessages();
//CodeAnalysisLogger.StopLoggingDebugMessages();
break;
}
}
foreach (SealedClassPropertyWithCodeAnalysis property in @class.Properties)
{
string propertyName = property.Name;
if (propertyName == "WrappedObject")
{
continue;
}
string propertyTypeName = property.PropertyType.Name;
if (propertyTypeName.Contains("ReadOnly"))
{
property.PropertyType.Name = propertyTypeName.Replace("ReadOnly", string.Empty);
}
IExpressionWithCodeAnalysis expression = ExpressionFactory.Binary(
ExpressionFactory.Member(ExpressionFactory.Identifier("WrappedObject"), propertyName),
BinaryOperatorExpressionType.Assign,
ExpressionFactory.Identifier("value"));
property.SetAccessor = new ClassAccessorWithCodeAnalysis(
AccessorType.Set,
new MethodBodyWithCodeAnalysis(StatementFactory.Expression(expression)));
}
Directory.CreateDirectory(Path.GetDirectoryName(destinationPath));
const int maximumLineLength = 120;
string sourceCode = loadedDocument.ToSourceCode(
new IndentBaseTypeListIfTooLongRule(maximumLineLength),
new IndentGenericParamterDefinitionsIfTooLongRule(maximumLineLength),
new IndentMethodParametersIfTooLongRule(maximumLineLength));
File.WriteAllText(destinationPath, sourceCode);
}
}
}
private static async Task GenerateForwardingVisitor()
{
string visitorFileName = Path.Combine(
Path.GetDirectoryName(typeof(Program).Assembly.Location),
@"..\..\..\..\CSharpDom\Common\Statements\GenericStatementChildVisitor.cs");
visitorFileName = Path.GetFullPath(visitorFileName);
LoadedDocumentWithCodeAnalysis loadedDocument =
await LoadedDocumentWithCodeAnalysis.LoadFromFileAsync(visitorFileName);
StaticClassWithCodeAnalysis visitorClass = loadedDocument.Namespaces.First().Classes.StaticClasses.First();
using (CodeAnalysisSettings.AllowEdits(visitorClass))
{
foreach (StaticClassMethodWithCodeAnalysis method in
visitorClass.Methods.Where(method => method.GenericParameters.LastOrDefault()?.Name != "TVisitor"))
{
Console.WriteLine($"Editing: {method.Name}");
UnspecifiedTypeReferenceWithCodeAnalysis visitableType =
(UnspecifiedTypeReferenceWithCodeAnalysis)method.Parameters[0].ParameterType;
InterfaceReferenceWithCodeAnalysis visitorType = new InterfaceReferenceWithCodeAnalysis(
"IVisitable",
TypeReferenceFactory.GenericParameter("TVisitor"));
foreach (GenericParameterDeclarationWithCodeAnalysis genericParameter in
method.GenericParameters)
{
string genericParameterName = genericParameter.Name;
if (genericParameterName != "TDocument" &&
genericParameterName != "TProject" &&
genericParameterName != "TSolution")
{
genericParameter.InterfaceConstraints.Add(visitorType);
}
}
string newName = Regex.Replace(visitableType.Name, "^I", "T");
method.Parameters[0].ParameterType = TypeReferenceFactory.GenericParameter(newName);
method.Parameters[1].ParameterType = TypeReferenceFactory.GenericParameter("TVisitor");
GenericParameterDeclarationWithCodeAnalysis newGenericParameter =
new GenericParameterDeclarationWithCodeAnalysis(newName)
{
InterfaceConstraints =
{
new InterfaceReferenceWithCodeAnalysis(visitableType)
}
};
method.GenericParameters.Insert(0, newGenericParameter);
method.GenericParameters.Add(new GenericParameterDeclarationWithCodeAnalysis("TVisitor"));
int statementIndex = -1;
int parameterIndex = 1;
foreach (IStatementWithCodeAnalysis statement in method.Body.Statements)
{
statementIndex++;
if (!(statement is ExpressionStatementWithCodeAnalysis expression) ||
!(expression.Expression is MethodCallExpressionWithCodeAnalysis methodCall) ||
!(methodCall.Expression is MemberExpressionWithCodeAnalysis memberCall) ||
!(memberCall.ObjectExpression is NewExpressionWithCodeAnalysis newObjectCall))
{
continue;
}
UnspecifiedTypeReferenceWithCodeAnalysis type =
newObjectCall.Type as UnspecifiedTypeReferenceWithCodeAnalysis;
string typeName = type.Name.Replace("Wrapper", string.Empty);
string genericTypeName = $"T{typeName}";
string parameterName = $"{typeName.Substring(0, 1).ToLower()}{typeName.Substring(1)}Factory";
newGenericParameter = new GenericParameterDeclarationWithCodeAnalysis(genericTypeName)
{
InterfaceConstraints =
{
new InterfaceReferenceWithCodeAnalysis(
$"I{typeName}",
type.GenericParameters.ToArray()),
visitorType
}
};
method.GenericParameters.Insert(parameterIndex, newGenericParameter);
ITypeReferenceWithCodeAnalysis parameterType = TypeReferenceFactory.Delegate(
"Func",
TypeReferenceFactory.GenericParameter(newName),
TypeReferenceFactory.GenericParameter(genericTypeName));
MethodParameterWithCodeAnalysis parameter = new MethodParameterWithCodeAnalysis(
parameterType,
parameterName);
method.Parameters.Insert(parameterIndex, parameter);
parameterIndex++;
memberCall.ObjectExpression = ExpressionFactory.MethodCall(
ExpressionFactory.Identifier(parameterName),
ExpressionFactory.Identifier(method.Parameters[0].Name));
}
}
}
const int maximumLineLength = 120;
string sourceCode = loadedDocument.ToSourceCode(
new IndentMethodParametersIfTooLongRule(maximumLineLength));
File.WriteAllText(visitorFileName, sourceCode);
}