public static BinaryOperatorExpressionWithCodeAnalysis Binary( IExpressionWithCodeAnalysis left, BinaryOperatorExpressionType @operator, IExpressionWithCodeAnalysis right) { return(new BinaryOperatorExpressionWithCodeAnalysis(left, @operator, right)); }
private static async Task EditGenericVisitor() { string baseDirectory = Path.GetFullPath( Path.Combine(Path.GetDirectoryName(typeof(Program).Assembly.Location), @"..\..\..\..")); LoadedDocumentWithCodeAnalysis document = await LoadedDocumentWithCodeAnalysis.LoadFromFileAsync( Path.Combine(baseDirectory, @"CSharpDom\Common\Expressions\GenericExpressionVisitor.cs")); foreach (StaticClassMethodWithCodeAnalysis method in document.Namespaces.First().Classes.StaticClasses.First().Methods) { IList <IStatementWithCodeAnalysis> statements = method.Body.Statements; if (statements.Count == 1 && statements[0] is ExpressionStatementWithCodeAnalysis expressionStatement && expressionStatement.Expression is MethodCallExpressionWithCodeAnalysis methodCall && methodCall.Expression is MemberExpressionWithCodeAnalysis member && member.ObjectExpression is IdentifierExpressionWithCodeAnalysis identifier && identifier.Name == "GenericExpressionChildVisitor") { continue; } //statements.Clear(); IExpressionWithCodeAnalysis expression = ExpressionFactory.MethodCall( ExpressionFactory.Member(ExpressionFactory.Identifier("GenericChildVisitor"), method.Name)); statements.Add(StatementFactory.Expression(expression)); } }
public static IfStatementWithCodeAnalysis If( IExpressionWithCodeAnalysis condition, IStatementWithCodeAnalysis thenStatement, IStatementWithCodeAnalysis elseStatement) { return(new IfStatementWithCodeAnalysis(condition, thenStatement, elseStatement)); }
public MethodCallExpressionWithCodeAnalysis( IExpressionWithCodeAnalysis expression, string methodName, params IExpressionWithCodeAnalysis[] parameters) : this(new MemberExpressionWithCodeAnalysis(expression, methodName), parameters) { }
public static MethodCallExpressionWithCodeAnalysis MethodCall( IExpressionWithCodeAnalysis objectExpression, string methodName, IEnumerable <ITypeReferenceWithCodeAnalysis> genericParameters, params IExpressionWithCodeAnalysis[] parameters) { return(new MethodCallExpressionWithCodeAnalysis(objectExpression, methodName, genericParameters, parameters)); }
public AbstractClassConstantWithCodeAnalysis( ClassMemberVisibilityModifier visibility, ITypeReferenceWithCodeAnalysis type, string name, IExpressionWithCodeAnalysis value) : this(new ClassConstantWithCodeAnalysis(visibility, type, name, value)) { }
public StaticPartialClassConstantWithCodeAnalysis( StaticClassMemberVisibilityModifier visibility, ITypeReferenceWithCodeAnalysis type, string name, IExpressionWithCodeAnalysis value) : this(new StaticClassConstantWithCodeAnalysis(visibility, type, name, value)) { }
public MethodCallExpressionWithCodeAnalysis( IExpressionWithCodeAnalysis expression, string methodName, IEnumerable <ITypeReferenceWithCodeAnalysis> genericParameters, params IExpressionWithCodeAnalysis[] parameters) : this(new GenericMemberExpressionWithCodeAnalysis(expression, methodName, genericParameters), parameters) { }
public static ForeachStatementWithCodeAnalysis ForEach( ITypeReferenceWithCodeAnalysis type, string variableName, IExpressionWithCodeAnalysis iterator, IStatementWithCodeAnalysis statement) { return(new ForeachStatementWithCodeAnalysis(type, variableName, iterator, statement)); }
public StructConstantWithCodeAnalysis( StructMemberVisibilityModifier visibility, ITypeReferenceWithCodeAnalysis type, string name, IExpressionWithCodeAnalysis value) : this(visibility, type, new ConstantWithCodeAnalysis(name, value)) { }
public static MemberExpressionWithCodeAnalysis Member( IExpressionWithCodeAnalysis objectExpression, string memberName) { return(new MemberExpressionWithCodeAnalysis(objectExpression, memberName)); }
public static CastExpressionWithCodeAnalysis Cast( ITypeReferenceWithCodeAnalysis type, IExpressionWithCodeAnalysis expression) { return(new CastExpressionWithCodeAnalysis(type, expression)); }
public static UsingStatementWithCodeAnalysis Using( IExpressionWithCodeAnalysis expression, IStatementWithCodeAnalysis statement) { return(new UsingStatementWithCodeAnalysis(expression, statement)); }
public static ThrowStatementWithCodeAnalysis Throw(IExpressionWithCodeAnalysis expression) { return(new ThrowStatementWithCodeAnalysis(expression)); }
public static ReturnStatementWithCodeAnalysis Return(IExpressionWithCodeAnalysis expression) { return(new ReturnStatementWithCodeAnalysis(expression)); }
public static LockStatementWithCodeAnalysis Lock( IExpressionWithCodeAnalysis expression, IStatementWithCodeAnalysis statement) { return(new LockStatementWithCodeAnalysis(expression, statement)); }
public static MethodCallExpressionWithCodeAnalysis MethodCall( IExpressionWithCodeAnalysis expression, params IExpressionWithCodeAnalysis[] parameters) { return(new MethodCallExpressionWithCodeAnalysis(expression, parameters)); }
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); } } }
public static DoStatementWithCodeAnalysis Do( IExpressionWithCodeAnalysis condition, IStatementWithCodeAnalysis statement) { return(new DoStatementWithCodeAnalysis(condition, statement)); }