/// <summary>
/// Builds a <see cref="CodeCompileUnit"/> containing all the compiled variations
/// </summary>
/// <returns>Code unit containing a single class (Tests.TestClass) with a method for each variation</returns>
private CodeCompileUnit BuildCompiledCodeUnit()
{
var ccu = new CodeCompileUnit();
var ns = ccu.AddNamespace("Tests");
foreach (var import in this.namespaceImports)
{
ns.ImportNamespace(import);
}
var codeClass = ns.DeclareType("TestClass").InheritsFrom(Code.TypeRef <GeneratedCode>());
foreach (var externalProperty in this.externalProperties.Values)
{
codeClass.AddAutoImplementedProperty(externalProperty.PropertyType, externalProperty.PropertyName);
}
// Add variations to class
foreach (var v in this.variations)
{
CodeMemberMethod codeVariation = codeClass.AddMethod(v.BlockName);
if (v.IsAsynchronous)
{
codeVariation = codeVariation.WithArgument(Code.TypeRef <IAsyncContinuation>(), "continuation");
}
codeVariation.Statements.AddRange(v.Statements);
}
codeClass.Members.AddRange(this.customMembers.ToArray());
return(ccu);
}
/// <summary>
/// Generates POCO entities based on the supplied model
/// </summary>
/// <param name="model">Model to generate classes from</param>
/// <returns>Generated code files</returns>
public IEnumerable <FileContents <string> > GenerateEntityClasses(EntityModelSchema model)
{
ExceptionUtilities.CheckArgumentNotNull(model, "model");
PocoAnnotator.Annotate(model, this.PocoOption);
List <FileContents <string> > results = new List <FileContents <string> >();
foreach (var ns in model.EntityTypes.Select(e => e.NamespaceName).Concat(model.EnumTypes.Select(e => e.NamespaceName)).Concat(model.ComplexTypes.Select(e => e.NamespaceName)).Distinct())
{
var codeUnit = new CodeCompileUnit();
CodeNamespace codeNamespace = codeUnit.AddNamespace(ns);
codeNamespace.ImportNamespace("System.Collections.Generic");
foreach (var type in model.ComplexTypes.Where(e => e.NamespaceName == ns))
{
codeNamespace.Types.Add(this.BuildType(type));
}
foreach (var type in model.EntityTypes.Where(e => e.NamespaceName == ns))
{
codeNamespace.Types.Add(this.BuildType(type));
}
foreach (var type in model.EnumTypes.Where(e => e.NamespaceName == ns))
{
codeNamespace.Types.Add(this.BuildType(type));
}
string code = this.GenerateCodeFromCompileUnit(codeUnit);
results.Add(new FileContents <string>(ns + this.language.FileExtension, code));
}
return(results);
}
public static CodeCompileUnit GenerateCompileUnit(ITextTemplatingEngineHost host, string content, ParsedTemplate pt, TemplateSettings settings)
{
ProcessDirectives(content, settings, pt.Errors);
//prep the compile unit
var ccu = new CodeCompileUnit();
var namespac = ccu.AddNamespace(settings.Namespace.NullIfEmpty());
foreach (string ns in settings.Imports.Union(host.StandardImports))
{
namespac.AddImport(new CodeNamespaceImport(ns));
}
var baseInfo = TemplateBaseTypeInfo.FromSettings(settings);
var type = namespac.AddClass(settings.Name)
.AsPartial()
.Inherits(baseInfo.Reference)
.WithVisibility(settings.InternalVisibility? TypeAttributes.NotPublic : TypeAttributes.Public);
if (baseInfo.Declaration is not null)
{
namespac.AddType(baseInfo.Declaration);
}
GenerateTransformMethod(type, settings, pt, host.TemplateFile, baseInfo.HasVirtualTransformMethod);
//class code and attributes from processors
foreach (var processor in settings.DirectiveProcessors.Values)
{
if (processor.GetClassCodeForProcessingRun().NullIfEmpty() is string classCode)
{
type.AddSnippetMember(classCode);
}
processor.GetTemplateClassCustomAttributes()?.AddTo(type);
}
//generate the Host property if needed
if (settings.HostSpecific && !settings.HostPropertyOnBase)
{
GenerateHostProperty(type, settings.HostType);
}
GenerateInitializationMethod(type, settings, baseInfo.HasVirtualInitializeMethod);
return(ccu);
}
public void GenerateCode(FileProjectItem item, CustomToolContext context)
{
XmlDocument doc = new XmlDocument();
doc.Load(item.FileName);
SettingsDocument setDoc = new SettingsDocument(doc.DocumentElement, DummySettingsEntryHost.Instance);
string customToolNamespace = item.GetEvaluatedMetadata("CustomToolNamespace");
if (!string.IsNullOrEmpty(customToolNamespace))
{
setDoc.GeneratedClassNamespace = customToolNamespace;
}
CodeCompileUnit ccu = new CodeCompileUnit();
var ns = ccu.AddNamespace(setDoc.GeneratedClassNamespace);
ns.Types.Add(CreateClass(setDoc));
if (setDoc.UseMySettingsClassName)
{
ns.Types.Add(CreateMySettingsProperty(setDoc));
}
context.WriteCodeDomToFile(item, context.GetOutputFileName(item, ".Designer"), ccu);
}
private CodeCompileUnit Generate()
{
CodeCompileUnit unit = new CodeCompileUnit();
string ns_name = _args.NamespaceName;
if (string.IsNullOrWhiteSpace(ns_name))
{
ns_name = $"rpc_{_server.InterfaceId.ToString().Replace('-', '_')}_{_server.InterfaceVersion.Major}_{_server.InterfaceVersion.Minor}";
}
string name = _args.ClientName;
if (string.IsNullOrWhiteSpace(name))
{
name = "Client";
}
CodeNamespace ns = unit.AddNamespace(ns_name);
int complex_type_count = GenerateComplexTypes(ns);
GenerateClient(name, ns, complex_type_count);
return(unit);
}
public static void Main(string[] args)
{
string directory = "../../NRefactory/Project/Src/Ast/";
string visitorsDir = "../../NRefactory/Project/Src/Visitors/";
Console.WriteLine("AST Generator running...");
if (!File.Exists(directory + "INode.cs"))
{
Console.WriteLine("did not find output directory " + Path.GetFullPath(Path.GetDirectoryName(directory)));
return;
}
if (!File.Exists(visitorsDir + "AbstractAstTransformer.cs"))
{
Console.WriteLine("did not find visitor output directory");
return;
}
List <Type> nodeTypes = new List <Type>();
foreach (Type type in typeof(MainClass).Assembly.GetTypes())
{
if (type.IsClass && typeof(INode).IsAssignableFrom(type))
{
nodeTypes.Add(type);
}
}
nodeTypes.Sort(delegate(Type a, Type b) { return(a.Name.CompareTo(b.Name)); });
CodeCompileUnit ccu = new CodeCompileUnit();
CodeNamespace cns = ccu.AddNamespace("ICSharpCode.NRefactory.Ast");
cns.AddImport("System");
cns.AddImport("System.Collections.Generic");
cns.AddImport("AgentRalph.Visitors");
foreach (Type type in nodeTypes)
{
if (type.GetCustomAttributes(typeof(CustomImplementationAttribute), false).Length == 0)
{
CodeTypeDeclaration ctd = cns.AddType(type.Name);
if (type.IsAbstract)
{
ctd.TypeAttributes |= TypeAttributes.Abstract;
}
ctd.IsPartial = true;
ctd.BaseTypes.Add(new CodeTypeReference(type.BaseType.Name));
ProcessType(type, ctd);
foreach (object o in type.GetCustomAttributes(false))
{
if (o is TypeImplementationModifierAttribute)
{
(o as TypeImplementationModifierAttribute).ModifyImplementation(cns, ctd, type);
}
}
if (!type.IsAbstract)
{
AddAnAcceptVisitorMethod(type, ctd, "IAstVisitor", typeof(object));
// Create an overload
AddAnAcceptVisitorMethod(type, ctd, "AstComparisonVisitor", typeof(bool));
AddAChillunsGetter(type, ctd);
var method = new CodeMemberMethod();
method.Name = "ToString";
method.Attributes = MemberAttributes.Public | MemberAttributes.Override;
method.ReturnType = new CodeTypeReference(typeof(string));
method.Statements.Add(new CodeMethodReturnStatement(CreateToString(type)));
ctd.Members.Add(method);
}
}
}
System.CodeDom.Compiler.CodeGeneratorOptions settings = new System.CodeDom.Compiler.CodeGeneratorOptions();
settings.IndentString = "\t";
settings.VerbatimOrder = true;
using (StringWriter writer = new StringWriter()) {
new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
File.WriteAllText(directory + "Generated.cs", writer.ToString());
}
ccu = new CodeCompileUnit();
cns = ccu.AddNamespace("ICSharpCode.NRefactory");
cns.AddImport("System");
cns.AddImport("ICSharpCode.NRefactory.Ast");
cns.Types.Add(CreateAstVisitorInterface(nodeTypes));
using (StringWriter writer = new StringWriter()) {
new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
File.WriteAllText(visitorsDir + "../IAstVisitor.cs", writer.ToString());
}
// My modifications to the generation process are not preserving the creation of these particular files.
// So I just don't regenerate them for the time being.
// ccu = new CodeCompileUnit();
// cns = ccu.AddNamespace("ICSharpCode.NRefactory.Visitors");
// cns.AddImport("System");
// cns.AddImport("System.Collections.Generic");
// cns.AddImport("System.Diagnostics");
// cns.AddImport("ICSharpCode.NRefactory.Ast");
// cns.Types.Add(CreateAstVisitorClass(nodeTypes, false));
//
// using (StringWriter writer = new StringWriter()) {
// new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
// File.WriteAllText(visitorsDir + "AbstractAstVisitor.cs", writer.ToString());
// }
//
// ccu = new CodeCompileUnit();
// cns = ccu.AddNamespace("ICSharpCode.NRefactory.Visitors");
// cns.AddImport("System");
// cns.AddImport("System.Collections.Generic");
// cns.AddImport("System.Diagnostics");
// cns.AddImport("ICSharpCode.NRefactory.Ast");
// cns.Types.Add(CreateAstVisitorClass(nodeTypes, true));
//
// using (StringWriter writer = new StringWriter()) {
// new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
// File.WriteAllText(visitorsDir + "AbstractAstTransformer.cs", writer.ToString());
// }
ccu = new CodeCompileUnit();
cns = ccu.AddNamespace("ICSharpCode.NRefactory.Visitors");
cns.AddImport("System");
cns.AddImport("ICSharpCode.NRefactory.Ast");
cns.Types.Add(CreateNodeTrackingAstVisitorClass(nodeTypes));
using (StringWriter writer = new StringWriter()) {
new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
// CodeDom cannot output "sealed", so we need to use this hack:
File.WriteAllText(visitorsDir + "NodeTrackingAstVisitor.cs",
writer.ToString().Replace("public override object", "public sealed override object"));
}
//NotImplementedAstVisitor
ccu = new CodeCompileUnit();
cns = ccu.AddNamespace("ICSharpCode.NRefactory.Visitors");
cns.AddImport("System");
cns.AddImport("ICSharpCode.NRefactory.Ast");
cns.Types.Add(CreateNotImplementedAstVisitorClass(nodeTypes));
using (StringWriter writer = new StringWriter()) {
new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
File.WriteAllText(visitorsDir + "NotImplementedAstVisitor.cs", writer.ToString());
}
// TwoTreeAbstractAstVisitor
ccu = new CodeCompileUnit();
cns = ccu.AddNamespace("AgentRalph.Visitors");
cns.AddImport("System");
cns.AddImport("System.Collections.Generic");
cns.AddImport("System.Diagnostics");
cns.AddImport("ICSharpCode.NRefactory.Ast");
cns.AddImport("ICSharpCode.NRefactory");
cns.Types.Add(CreateAstComparisonVisitorClass(nodeTypes));
using (StringWriter writer = new StringWriter())
{
new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
// Put it in the NRefactor project
var path = visitorsDir + "AstComparisonVisitor.Generated.cs";
File.WriteAllText(path, writer.ToString());
Console.WriteLine("Created file " + path);
}
Console.WriteLine("AST Generator done!");
}
public static void Main(string[] args)
{
string directory = "../../../Project/Src/Ast/";
string visitorsDir = "../../../Project/Src/Visitors/";
Debug.WriteLine("AST Generator running...");
if (!File.Exists(directory + "INode.cs"))
{
Debug.WriteLine("did not find output directory");
return;
}
if (!File.Exists(visitorsDir + "AbstractAstTransformer.cs"))
{
Debug.WriteLine("did not find visitor output directory");
return;
}
List <Type> nodeTypes = new List <Type>();
foreach (Type type in typeof(MainClass).Assembly.GetTypes())
{
if (type.IsClass && typeof(INode).IsAssignableFrom(type))
{
nodeTypes.Add(type);
}
}
nodeTypes.Sort(delegate(Type a, Type b) { return(a.Name.CompareTo(b.Name)); });
CodeCompileUnit ccu = new CodeCompileUnit();
CodeNamespace cns = ccu.AddNamespace("ICSharpCode.NRefactory.Ast");
cns.AddImport("System");
cns.AddImport("System.Collections.Generic");
foreach (Type type in nodeTypes)
{
if (type.GetCustomAttributes(typeof(CustomImplementationAttribute), false).Length == 0)
{
CodeTypeDeclaration ctd = cns.AddType(type.Name);
if (type.IsAbstract)
{
ctd.TypeAttributes |= TypeAttributes.Abstract;
}
ctd.BaseTypes.Add(new CodeTypeReference(type.BaseType.Name));
ProcessType(type, ctd);
foreach (object o in type.GetCustomAttributes(false))
{
if (o is TypeImplementationModifierAttribute)
{
(o as TypeImplementationModifierAttribute).ModifyImplementation(cns, ctd, type);
}
}
if (!type.IsAbstract)
{
CodeMemberMethod method = new CodeMemberMethod();
method.Name = "AcceptVisitor";
method.Attributes = MemberAttributes.Public | MemberAttributes.Override;
method.Parameters.Add(new CodeParameterDeclarationExpression("IAstVisitor", "visitor"));
method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "data"));
method.ReturnType = new CodeTypeReference(typeof(object));
CodeExpression ex = new CodeVariableReferenceExpression("visitor");
ex = new CodeMethodInvokeExpression(ex, VisitPrefix + ctd.Name,
new CodeThisReferenceExpression(),
new CodeVariableReferenceExpression("data"));
method.Statements.Add(new CodeMethodReturnStatement(ex));
ctd.Members.Add(method);
method = new CodeMemberMethod();
method.Name = "ToString";
method.Attributes = MemberAttributes.Public | MemberAttributes.Override;
method.ReturnType = new CodeTypeReference(typeof(string));
method.Statements.Add(new CodeMethodReturnStatement(CreateToString(type)));
ctd.Members.Add(method);
}
}
}
System.CodeDom.Compiler.CodeGeneratorOptions settings = new System.CodeDom.Compiler.CodeGeneratorOptions();
settings.IndentString = "\t";
settings.VerbatimOrder = true;
using (StringWriter writer = new StringWriter()) {
new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
File.WriteAllText(directory + "Generated.cs", writer.ToString());
}
ccu = new CodeCompileUnit();
cns = ccu.AddNamespace("ICSharpCode.NRefactory");
cns.AddImport("System");
cns.AddImport("ICSharpCode.NRefactory.Ast");
cns.Types.Add(CreateAstVisitorInterface(nodeTypes));
using (StringWriter writer = new StringWriter()) {
new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
File.WriteAllText(visitorsDir + "../IAstVisitor.cs", writer.ToString());
}
ccu = new CodeCompileUnit();
cns = ccu.AddNamespace("ICSharpCode.NRefactory.Visitors");
cns.AddImport("System");
cns.AddImport("System.Collections.Generic");
cns.AddImport("System.Diagnostics");
cns.AddImport("ICSharpCode.NRefactory.Ast");
cns.Types.Add(CreateAstVisitorClass(nodeTypes, false));
using (StringWriter writer = new StringWriter()) {
new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
File.WriteAllText(visitorsDir + "AbstractAstVisitor.cs", writer.ToString());
}
ccu = new CodeCompileUnit();
cns = ccu.AddNamespace("ICSharpCode.NRefactory.Visitors");
cns.AddImport("System");
cns.AddImport("System.Collections.Generic");
cns.AddImport("System.Diagnostics");
cns.AddImport("ICSharpCode.NRefactory.Ast");
cns.Types.Add(CreateAstVisitorClass(nodeTypes, true));
using (StringWriter writer = new StringWriter()) {
new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
File.WriteAllText(visitorsDir + "AbstractAstTransformer.cs", writer.ToString());
}
ccu = new CodeCompileUnit();
cns = ccu.AddNamespace("ICSharpCode.NRefactory.Visitors");
cns.AddImport("System");
cns.AddImport("ICSharpCode.NRefactory.Ast");
cns.Types.Add(CreateNodeTrackingAstVisitorClass(nodeTypes));
using (StringWriter writer = new StringWriter()) {
new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
// CodeDom cannot output "sealed", so we need to use this hack:
File.WriteAllText(visitorsDir + "NodeTrackingAstVisitor.cs",
writer.ToString().Replace("public override object", "public sealed override object"));
}
//NotImplementedAstVisitor
ccu = new CodeCompileUnit();
cns = ccu.AddNamespace("ICSharpCode.NRefactory.Visitors");
cns.AddImport("System");
cns.AddImport("ICSharpCode.NRefactory.Ast");
cns.Types.Add(CreateNotImplementedAstVisitorClass(nodeTypes));
using (StringWriter writer = new StringWriter()) {
new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
File.WriteAllText(visitorsDir + "NotImplementedAstVisitor.cs", writer.ToString());
}
Debug.WriteLine("AST Generator done!");
}
/// <summary>
/// Generates the client-side proxy classes then calls the given callback
/// </summary>
/// <param name="continuation">The async continuation to report completion on</param>
/// <param name="serviceRoot">The root uri of the service</param>
/// <param name="model">The model for the service</param>
/// <param name="language">The language to generate code in</param>
/// <param name="onCompletion">The action to invoke with the generated code</param>
public void GenerateClientCode(IAsyncContinuation continuation, Uri serviceRoot, EntityModelSchema model, IProgrammingLanguageStrategy language, Action <string> onCompletion)
{
ExceptionUtilities.CheckArgumentNotNull(continuation, "continuation");
ExceptionUtilities.CheckArgumentNotNull(serviceRoot, "serviceRoot");
ExceptionUtilities.CheckArgumentNotNull(model, "model");
ExceptionUtilities.CheckArgumentNotNull(language, "language");
ExceptionUtilities.CheckArgumentNotNull(onCompletion, "onCompletion");
ExceptionUtilities.CheckAllRequiredDependencies(this);
// because the product code-gen does not produce this overload of the DataServiceContext constructor, we need to add it ourselves
// namespace <contextNamespace>
// {
// partial class <contextType>
// {
// public <contextType>(Uri serviceUri, DataServiceProtocolVersion maxProtocolVersion)
// : base(serviceUri, maxProtocolVersion)
// {
// }
// }
// }
var compileUnit = new CodeCompileUnit();
var contextNamespace = compileUnit.AddNamespace(model.EntityTypes.First().NamespaceName);
var contextType = contextNamespace.DeclareType(model.EntityContainers.Single().Name);
contextType.IsPartial = true;
contextType.AddConstructor()
.WithArgument(Code.TypeRef <Uri>(), "serviceUri")
.WithArgument(Code.TypeRef("Microsoft.OData.Client.ODataProtocolVersion"), "maxProtocolVersion")
.WithBaseConstructorArgument(Code.Variable("serviceUri"))
.WithBaseConstructorArgument(Code.Variable("maxProtocolVersion"));
string constructorOverload = language.CreateCodeGenerator().GenerateCodeFromNamespace(contextNamespace);
this.DataServiceBuilder.BeginGenerateClientLayerCode(
serviceRoot.OriginalString,
this.DesignVersion,
this.ClientVersion,
language.FileExtension,
result =>
{
AsyncHelpers.CatchErrors(
continuation,
() =>
{
string errorMessage;
string clientCode = this.DataServiceBuilder.EndGenerateClientLayerCode(out errorMessage, result);
if (errorMessage != null)
{
throw new TaupoInfrastructureException(errorMessage);
}
// add the extra constructor overload we generated above
clientCode = string.Concat(clientCode, Environment.NewLine, constructorOverload);
onCompletion(clientCode);
continuation.Continue();
});
},
null);
}
public static CodeNamespace AddNamespace(this CodeCompileUnit ccu, string namespaceName = null) => ccu.AddNamespace(namespaceName == null ? Declare.Namespace() : Declare.Namespace(namespaceName));
