void AddPluginObjsConstructor(RoslynCodeBuilder roslynCodeBuilder)
{
string paramsLine = GetWrappedObjConstructorParamStr();
if (paramsLine.IsNullOrEmpty())
{
return;
}
roslynCodeBuilder.PushRegion("Plugins Constructor");
roslynCodeBuilder.AddLine($"public {this.ClassName}({paramsLine})");
roslynCodeBuilder.Push();
foreach (PluginInfo pluginInfo in PluginInfos)
{
pluginInfo.AddPluginInitInConstructorCode(roslynCodeBuilder);
roslynCodeBuilder.AddLine();
}
roslynCodeBuilder.AddLine($"{INIT_METHOD_NAME}()", true);
roslynCodeBuilder.Pop(true);
roslynCodeBuilder.PopRegion();
}
void AddWrappedObjsConstructor(RoslynCodeBuilder roslynCodeBuilder)
{
string paramsLine = GetWrappedObjConstructorParamStr();
if (paramsLine.IsNullOrEmpty())
{
return;
}
roslynCodeBuilder.PushRegion("Wrappers Constructor");
roslynCodeBuilder.AddLine($"public {this.ClassName}({paramsLine})");
roslynCodeBuilder.Push();
foreach (WrappedObjInfo wrapObjInfo in _wrappedObjInfos)
{
string assignmentLine =
$"{wrapObjInfo.WrappedObjPropName} = {wrapObjInfo.WrappedObjClassName.FirstCharToLowerCase(true)}";
roslynCodeBuilder.AddLine(assignmentLine, true);
}
roslynCodeBuilder.Pop(true);
roslynCodeBuilder.PopRegion();
}
public void AddCallToPluginObjConstructor
(
RoslynCodeBuilder roslynCodeBuilder,
Dictionary <string, string> sharedPluginsNameMap
)
{
roslynCodeBuilder.AddText($" new {this.ClassName}(");
bool notFirst = false;
foreach (PluginInfo pluginInfo in PluginInfos)
{
if (notFirst)
{
roslynCodeBuilder.AddText(", ");
}
else
{
notFirst = true;
}
string pluginPropName = pluginInfo.PluginPropName;
if (!sharedPluginsNameMap.TryGetValue(pluginPropName, out string valToAdd))
{
valToAdd = "null";
}
roslynCodeBuilder.AddText(valToAdd);
}
roslynCodeBuilder.AddText(");");
roslynCodeBuilder.AddLine();
}
public void Build(IPropertySymbol symbol, RoslynCodeBuilder roslynCodeBuilder)
{
string firePropertyChangedStr =
$"this.OnPropertyChanged(nameof({symbol.Name}));";
roslynCodeBuilder.AddPropWithBackingStore(symbol, null, firePropertyChangedStr);
}
protected override void BuildImpl(IEventSymbol wrapperSymbol, RoslynCodeBuilder roslynCodeBuilder)
{
roslynCodeBuilder.AddEventDefinitionAndEventInvocationMethod
(
this.WrapperSymbol,
this.IndexInputParamToReplaceByThis
);
}
public void AddInit(RoslynCodeBuilder roslynCodeBuilder)
{
if (!HasInit)
{
return;
}
roslynCodeBuilder.AddAssignCoreObj(WrapperSymbolName, TheInitTypeSymbol);
}
void OpenClassDeclaration(RoslynCodeBuilder roslynCodeBuilder)
{
roslynCodeBuilder.AddClass
(
ClassName,
null,
SuperClassTypeSymbol,
AllImplementedInterfaces.ToArray()
);
}
public override void Build(IEventSymbol symbol, RoslynCodeBuilder roslynCodeBuilder)
{
base.Build(symbol, roslynCodeBuilder);
roslynCodeBuilder.AddEmptyLine();
roslynCodeBuilder.AddLine("protected void OnPropertyChanged(string propName)");
roslynCodeBuilder.Push();
roslynCodeBuilder.AddLine($"this.PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propName))", true);
roslynCodeBuilder.Pop();
}
internal void Build(RoslynCodeBuilder roslynCodeBuilder)
{
if (NoWrappers || this.WrappedMembers.IsNullOrEmpty())
{
BuildIfNoWrappers(roslynCodeBuilder);
return;
}
BuildImpl(this.WrapperSymbol, roslynCodeBuilder);
}
private void AddInit(RoslynCodeBuilder roslynCodeBuilder)
{
roslynCodeBuilder.PushRegion("Init Method");
roslynCodeBuilder.AddLine($"void {INIT_METHOD_NAME}()");
roslynCodeBuilder.Push();
this.PropBuilderInfos.DoForEach(propBuilderInfo => propBuilderInfo.AddInit(roslynCodeBuilder));
roslynCodeBuilder.Pop();
roslynCodeBuilder.PopRegion();
}
protected virtual void BuildIfNoWrappers(RoslynCodeBuilder roslynCodeBuilder)
{
if (TheCodeBuilder != null)
{
TheCodeBuilder.Build(this.WrapperSymbol, roslynCodeBuilder);
return;
}
if (DefaultCodeBuilder != null)
{
DefaultCodeBuilder.Build(this.WrapperSymbol, roslynCodeBuilder);
}
}
static void Main(string[] args)
{
MSBuildWorkspace workspace = MSBuildWorkspace.Create();
Project proj = workspace.OpenProjectAsync("../../../TestProj/TestProj.csproj").Result;
Compilation compilation = proj.GetCompilationAsync().Result;
INamedTypeSymbol myClass = compilation.GetTypeByMetadataName("TestProj.MyClass");
INamedTypeSymbol myInterface = compilation.GetTypeByMetadataName("TestProj.IMyInterface");
string fullNamespace = myClass.GetFullNamespace();
IEnumerable <ISymbol> allMembers = myClass.GetMembers();
IMethodSymbol myMethod = myClass.GetMemberByName <IMethodSymbol>(nameof(MyClass.MyMethod));
IPropertySymbol myProp = myClass.GetMemberByName <IPropertySymbol>(nameof(MyClass.MyInt));
string methodSignature = myMethod.GetMethodSignature();
IPropertySymbol intProp = myInterface.GetMemberByName <IPropertySymbol>(nameof(IMyInterface.TheInt));
IPropertySymbol strProp = myInterface.GetMemberByName <IPropertySymbol>(nameof(IMyInterface.TheStr));
RoslynCodeBuilder roslynCodeBuilder = new RoslynCodeBuilder();
RoslynAnalysisAndGenerationUtils.TheNamespaces = roslynCodeBuilder.AllNamespaces;
RoslynAnalysisAndGenerationUtils.TheAssemblies = roslynCodeBuilder.AllAssemblies;
roslynCodeBuilder.AddNamespace("NP.Generated");
roslynCodeBuilder.AddClass("MyClass1", null, null, myInterface);
roslynCodeBuilder.AddAutoProp(intProp.Name, intProp.Type as INamedTypeSymbol);
roslynCodeBuilder.AddAutoProp(strProp.Name, strProp.Type as INamedTypeSymbol);
//roslynCodeBuilder.AddField("_myField", myClass);
//roslynCodeBuilder.AddPropWithBackingStore("MyProp", myClass);
//roslynCodeBuilder.AddPropWrapper("_propField", myProp);
//roslynCodeBuilder.AddPropOpening("MyField", myClass);
//roslynCodeBuilder.Pop();
roslynCodeBuilder.AddMethodWrapper("_propField", myMethod);
roslynCodeBuilder.PopAll();
Console.WriteLine(roslynCodeBuilder.ToString());
}
protected override void BuildImpl(IMethodSymbol methodWrapperSymbol, RoslynCodeBuilder roslynCodeBuilder)
{
bool shouldOverride = (!ForceNoOverride) && methodWrapperSymbol.ShouldOverride();
roslynCodeBuilder.AddMethodOpeningFromSymbolOnly(methodWrapperSymbol, shouldOverride);
string returnVarName = "result";
string firstLineInsert = "";
if (!methodWrapperSymbol.ReturnsVoid)
{
string returnTypeStr = (methodWrapperSymbol.ReturnType as INamedTypeSymbol).GetFullTypeString();
roslynCodeBuilder.AddLine($"{returnTypeStr} {returnVarName} = default({returnTypeStr})", true);
firstLineInsert = $"{returnVarName} = ";
}
if (this.IncludeBaseVirtualInOverride)
{
roslynCodeBuilder.AddEmptyLine();
roslynCodeBuilder.AddMethodCall(WrapperSymbol, $"base.{WrapperSymbolName}");
}
bool isFirst = true;
foreach (MemberMapInfo memberMap in this.WrappedMembers)
{
memberMap.AddCheckForSharedLine(roslynCodeBuilder);
roslynCodeBuilder.Push();
roslynCodeBuilder.AddLine();
if (isFirst)
{
roslynCodeBuilder.AddText(firstLineInsert);
isFirst = false;
}
memberMap.AddPluginMethodLine(this.WrapperSymbol, roslynCodeBuilder);
roslynCodeBuilder.Pop();
}
if (!methodWrapperSymbol.ReturnsVoid)
{
roslynCodeBuilder.AddReturnVar(returnVarName);
}
roslynCodeBuilder.Pop(true);
}
private void AddDefaultConstructor(RoslynCodeBuilder roslynCodeBuilder)
{
roslynCodeBuilder.PushRegion("Default Constructor");
roslynCodeBuilder.AddDefaultConstructorOpening(this.ClassName);
foreach (WrappedObjInfo wrappedObj in _wrappedObjInfos)
{
wrappedObj.AddDefaultConstructor(roslynCodeBuilder);
}
roslynCodeBuilder.Pop();
roslynCodeBuilder.PopRegion();
}
private void AddMethodWraps(RoslynCodeBuilder roslynCodeBuilder)
{
if (MethodBuilderInfos.IsNullOrEmpty())
{
return;
}
roslynCodeBuilder.PushRegion("Wrapped Methods");
foreach (WrapperMemberBuilderInfo <IMethodSymbol> methodBuilderInfo in this.MethodBuilderInfos)
{
methodBuilderInfo.Build(roslynCodeBuilder);
}
roslynCodeBuilder.PopRegion();
}
private void AddWrappedClasses(RoslynCodeBuilder roslynCodeBuilder)
{
if (this._wrappedObjInfos.IsNullOrEmpty())
{
return;
}
roslynCodeBuilder.PushRegion("Wrapped Classes");
foreach (WrappedObjInfo wrappedClassInfo in this._wrappedObjInfos)
{
wrappedClassInfo.AddWrappedClass(roslynCodeBuilder);
}
roslynCodeBuilder.PopRegion();
}
private void AddPlugins(RoslynCodeBuilder roslynCodeBuilder)
{
if (this.PluginInfos.IsNullOrEmpty())
{
return;
}
roslynCodeBuilder.PushRegion("Plugins");
foreach (PluginInfo wrappedClassInfo in this.PluginInfos)
{
wrappedClassInfo.AddPluginClass(roslynCodeBuilder);
}
roslynCodeBuilder.PopRegion();
}
private void ImplementEvents(RoslynCodeBuilder roslynCodeBuilder)
{
if (this.EventBuilderInfos.IsNullOrEmpty())
{
return;
}
roslynCodeBuilder.PushRegion("The Wrapped Events Definitions");
foreach (var eventBuilder in this.EventBuilderInfos)
{
eventBuilder.Build(roslynCodeBuilder);
}
roslynCodeBuilder.PopRegion();
}
private void AddPropWraps(RoslynCodeBuilder roslynCodeBuilder)
{
if (PropBuilderInfos.IsNullOrEmpty())
{
return;
}
roslynCodeBuilder.PushRegion("Generated Properties");
foreach (PropertyWrapperMemberBuilderInfo propBuilderInfo in this.PropBuilderInfos)
{
propBuilderInfo.Build(roslynCodeBuilder);
}
roslynCodeBuilder.PopRegion();
}
protected virtual string GenerateCode()
{
Compilation compilation = this.TheCompilation;
SetMissingMaps();
SetWrappedMembers();
RoslynCodeBuilder roslynCodeBuilder = new RoslynCodeBuilder();
RoslynAnalysisAndGenerationUtils.TheNamespaces =
roslynCodeBuilder.AllNamespaces;
RoslynAnalysisAndGenerationUtils.TheNamespaces.Add("NP.Utilities");
RoslynAnalysisAndGenerationUtils.TheNamespaces.Add("NP.Roxy");
RoslynAnalysisAndGenerationUtils.TheNamespaces.Add("NP.Roxy.Attributes");
RoslynAnalysisAndGenerationUtils.InitTypeNamespace <Action <int> >();
roslynCodeBuilder.AddNamespace(AssemblerNames.GENERATED_NAMESPACE_NAME);
OpenClassDeclaration(roslynCodeBuilder);
AddStaticCoreReference(roslynCodeBuilder);
ImplementEvents(roslynCodeBuilder);
AddPlugins(roslynCodeBuilder);
//AddSharedProps(roslynCodeBuilder);
AddInit(roslynCodeBuilder);
AddDefaultConstructor(roslynCodeBuilder);
AddPluginObjsConstructor(roslynCodeBuilder);
AddPropWraps(roslynCodeBuilder);
AddMethodWraps(roslynCodeBuilder);
roslynCodeBuilder.PopAll();
TheGeneratedCode = roslynCodeBuilder.ToStr();
return(TheGeneratedCode);
}
void OpenClassDeclaration(RoslynCodeBuilder roslynCodeBuilder)
{
INamedTypeSymbol[] allSymbols = { ImplementorTypeSymbol, TypeToImplementSymbol };
INamedTypeSymbol firstSymbol = allSymbols.FirstOrDefault(symb => symb.IsClass()) ?? ImplementorTypeSymbol;
INamedTypeSymbol[] otherSymbols = allSymbols.Except(firstSymbol.ToCollection()).ToArray();
roslynCodeBuilder.AddClass
(
ClassName,
null,
firstSymbol.GetNullForNoType(TheCompilation),
true,
otherSymbols
);
}
internal void Build(RoslynCodeBuilder roslynCodeBuilder)
{
if (this.WrappedMembers.IsNullOrEmpty())
{
if (TheCodeBuilder != null)
{
TheCodeBuilder.Build(this.WrapperSymbol, roslynCodeBuilder);
return;
}
if (DefaultCodeBuilder != null)
{
DefaultCodeBuilder.Build(this.WrapperSymbol, roslynCodeBuilder);
}
return;
}
BuildImpl(this.WrapperSymbol, roslynCodeBuilder);
}
private void AddDefaultConstructor(RoslynCodeBuilder roslynCodeBuilder)
{
roslynCodeBuilder.PushRegion("Constructor");
roslynCodeBuilder
.AddConstructorOpening
(
this.ClassName,
Accessibility.Public
);
foreach (PluginInfo wrappedObj in PluginInfos)
{
wrappedObj.AddPluginDefaultConstructorInitialization(roslynCodeBuilder);
}
roslynCodeBuilder.AddLine($"{INIT_METHOD_NAME}()", true);
roslynCodeBuilder.Pop();
roslynCodeBuilder.PopRegion();
}
public void Build(IPropertySymbol symbol, RoslynCodeBuilder roslynCodeBuilder)
{
roslynCodeBuilder.AddDelegatesCallingProp(symbol);
}
public void Build(IMethodSymbol symbol, RoslynCodeBuilder roslynCodeBuilder)
{
roslynCodeBuilder.AddDelegateCallingMethod(symbol);
}
protected abstract void BuildImpl
(
TSymbol wrapperSymbol,
RoslynCodeBuilder roslynCodeBuilder
);
protected override void BuildImpl(IMethodSymbol methodWrapperSymbol, RoslynCodeBuilder roslynCodeBuilder)
{
roslynCodeBuilder.AddMethodOpeningFromSymbolOnly(methodWrapperSymbol);
string returnVarName = "result";
string firstLineInsert = "";
if (!methodWrapperSymbol.ReturnsVoid)
{
firstLineInsert =
(methodWrapperSymbol.ReturnType as INamedTypeSymbol).GetFullTypeString() + $" {returnVarName} = ";
}
if (this.IncludeBaseVirtualInOverride)
{
roslynCodeBuilder.AddEmptyLine();
roslynCodeBuilder.AddMethodCall(WrapperSymbol, $"base.{WrapperSymbolName}");
}
bool isFirst = true;
foreach (MemberMapInfo memberMap in this.WrappedMembers)
{
roslynCodeBuilder.AddEmptyLine();
if (isFirst)
{
roslynCodeBuilder.AddText(firstLineInsert);
isFirst = false;
}
IMethodSymbol wrappedMethodSymbol = memberMap.TheWrappedSymbol as IMethodSymbol;
if (memberMap.IsNonPublic)
{
if (memberMap.AllowNonPublic)
{
roslynCodeBuilder
.AddNonPublicMethodCall
(
WrapperSymbol,
memberMap.WrappedObjPropName,
memberMap.WrappedMemberName,
wrappedMethodSymbol
);
}
}
else
{
if (memberMap.TheWrappedSymbol.IsStatic)
{
roslynCodeBuilder.AddStaticMethodCall
(
WrapperSymbol,
memberMap.WrappedObjPropName,
memberMap.WrappedClassMemberFullName);
}
else
{
roslynCodeBuilder.AddMethodCall
(
WrapperSymbol,
memberMap.WrappedClassMemberFullName);
}
}
}
if (!methodWrapperSymbol.ReturnsVoid)
{
roslynCodeBuilder.AddReturnVar(returnVarName);
}
roslynCodeBuilder.Pop(true);
}
protected override void BuildImpl(IPropertySymbol propertyWrapperSymbol, RoslynCodeBuilder roslynCodeBuilder)
{
Accessibility propAccessibility = propertyWrapperSymbol.DeclaredAccessibility;
roslynCodeBuilder.AddPropOpening
(
propertyWrapperSymbol.Name,
propertyWrapperSymbol.Type as INamedTypeSymbol,
propertyWrapperSymbol.DeclaredAccessibility,
propertyWrapperSymbol.ShouldOverride()
);
if (propertyWrapperSymbol.GetMethod != null)
{
Accessibility getterAccessibility = propertyWrapperSymbol.GetMethod.DeclaredAccessibility;
if (getterAccessibility == propAccessibility)
{
getterAccessibility = Accessibility.NotApplicable;
}
roslynCodeBuilder.OpenPropGetter(getterAccessibility);
MemberMapInfo firstMemberMap =
this.WrappedMembers
.FirstOrDefault(member => (!member.IsNonPublic));
if (firstMemberMap == null)
{
firstMemberMap = this.WrappedMembers.First();
}
if (firstMemberMap.IsNonPublic)
{
if (firstMemberMap.AllowNonPublic)
{
string returnType = (propertyWrapperSymbol.Type as INamedTypeSymbol).GetFullTypeString();
roslynCodeBuilder.AddLine($"return ({returnType}) {firstMemberMap.WrappedObjPropName}.GetPropValue(\"{firstMemberMap.WrappedMemberName}\", true)", true);
}
}
else
{
string wrappedMemberStr = firstMemberMap.WrappedClassMemberFullName;
roslynCodeBuilder.AddReturnVar(wrappedMemberStr);
}
roslynCodeBuilder.Pop();
}
if (propertyWrapperSymbol.SetMethod != null)
{
Accessibility setterAccessibility = propertyWrapperSymbol.SetMethod.DeclaredAccessibility;
if (setterAccessibility == propAccessibility)
{
setterAccessibility = Accessibility.NotApplicable;
}
roslynCodeBuilder.OpenPropSetter(setterAccessibility);
if (this.IncludeBaseVirtualInOverride)
{
roslynCodeBuilder.AddSettingValue($"base.{WrapperSymbolName}");
}
foreach (MemberMapInfo memberMap in this.WrappedMembers)
{
if (memberMap.IsNonPublic)
{
if (memberMap.AllowNonPublic)
{
roslynCodeBuilder.AddLine($"{memberMap.WrappedObjPropName}.SetPropValue(\"{memberMap.WrappedMemberName}\", value, true)", true);
}
}
else
{
string wrappedMemberStr = memberMap.WrappedClassMemberFullName;
roslynCodeBuilder.AddSettingValue(wrappedMemberStr);
}
}
roslynCodeBuilder.Pop();
}
roslynCodeBuilder.Pop();
}
static void Main(string[] args)
{
MSBuildWorkspace workspace = MSBuildWorkspace.Create();
Project proj = workspace.OpenProjectAsync("../../InterfaceImplTest.csproj").Result;
//Project proj = workspace.OpenProjectAsync("../../../TestProj/TestProj.csproj").Result;
//Assembly testProjAssembly = Assembly.ReflectionOnlyLoadFrom("TestProj.dll");
//AssemblyMetadata assemblyMetadata =
// Microsoft.CodeAnalysis.AssemblyMetadata.CreateFromFile("TestProj.dll");
//AssemblyIdentity assemblyIdentity = AssemblyIdentity.FromAssemblyDefinition(testProjAssembly);
Compilation compilation = proj.GetCompilationAsync().Result;
INamedTypeSymbol myInterface =
compilation.GetTypeByMetadataName($"InterfaceImplTest.{nameof(MyInterfaceToTestCircularReference)}");
//INamedTypeSymbol myInterface =
// compilation.GetTypeByMetadataName($"TestProj.{nameof(IMyInterface)}");
IAssemblySymbol assembly = myInterface.ContainingAssembly;
ISourceAssemblySymbol sourceAssemblySymbol = assembly as ISourceAssemblySymbol;
IAssemblySymbol assemblySymbol = assembly as IAssemblySymbol;
IEnumerable <MetadataReference> references =
sourceAssemblySymbol
.Compilation
.References
.Concat
(
new[]
{
sourceAssemblySymbol
.Compilation
.ToMetadataReference()
}).ToArray();
IPropertySymbol intProp =
myInterface
.GetMemberByName <IPropertySymbol>(nameof(IMyInterface.TheInt));
IPropertySymbol strProp =
myInterface
.GetMemberByName <IPropertySymbol>(nameof(IMyInterface.TheStr));
RoslynCodeBuilder roslynCodeBuilder = new RoslynCodeBuilder();
RoslynAnalysisAndGenerationUtils.TheNamespaces = roslynCodeBuilder.AllNamespaces;
RoslynAnalysisAndGenerationUtils.TheAssemblies = roslynCodeBuilder.AllAssemblies;
roslynCodeBuilder.AddNamespace("NP.Generated");
roslynCodeBuilder.AddClass("MyClass1", null, null, myInterface);
roslynCodeBuilder.AddAutoProp(intProp.Name, intProp.Type as INamedTypeSymbol);
roslynCodeBuilder.AddAutoProp(strProp.Name, strProp.Type as INamedTypeSymbol);
roslynCodeBuilder.PopAll();
string classStr = roslynCodeBuilder.ToString();
}
protected void AddStaticCoreReference(RoslynCodeBuilder roslynCodeBuilder)
{
roslynCodeBuilder.AddLine($"public static Core {STATIC_CORE_MEMBER_NAME} {{ get; set; }}");
}
