/// <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 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();
ccu.AddNamespace(setDoc.GeneratedClassNamespace).Types.Add(CreateClass(setDoc));
context.WriteCodeDomToFile(item, context.GetOutputFileName(item, ".Designer"), ccu);
}
public static void Main(string[] args)
{
string directory = "../../../ICSharpCode.NRefactory.VB/Ast/";
string visitorsDir = "../../../ICSharpCode.NRefactory.VB/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.VB.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", NormalizeNewLines(writer));
}
ccu = new CodeCompileUnit();
cns = ccu.AddNamespace("ICSharpCode.NRefactory.VB");
cns.AddImport("System");
cns.AddImport("ICSharpCode.NRefactory.VB.Ast");
cns.Types.Add(CreateAstVisitorInterface(nodeTypes));
using (StringWriter writer = new StringWriter()) {
new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
File.WriteAllText(visitorsDir + "../IAstVisitor.cs", NormalizeNewLines(writer));
}
ccu = new CodeCompileUnit();
cns = ccu.AddNamespace("ICSharpCode.NRefactory.VB.Visitors");
cns.AddImport("System");
cns.AddImport("System.Collections.Generic");
cns.AddImport("System.Diagnostics");
cns.AddImport("ICSharpCode.NRefactory.VB.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", NormalizeNewLines(writer));
}
ccu = new CodeCompileUnit();
cns = ccu.AddNamespace("ICSharpCode.NRefactory.VB.Visitors");
cns.AddImport("System");
cns.AddImport("System.Collections.Generic");
cns.AddImport("System.Diagnostics");
cns.AddImport("ICSharpCode.NRefactory.VB.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", NormalizeNewLines(writer));
}
ccu = new CodeCompileUnit();
cns = ccu.AddNamespace("ICSharpCode.NRefactory.VB.Visitors");
cns.AddImport("System");
cns.AddImport("ICSharpCode.NRefactory.VB.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",
NormalizeNewLines(writer).Replace("public override object", "public sealed override object"));
}
//NotImplementedAstVisitor
ccu = new CodeCompileUnit();
cns = ccu.AddNamespace("ICSharpCode.NRefactory.VB.Visitors");
cns.AddImport("System");
cns.AddImport("ICSharpCode.NRefactory.VB.Ast");
cns.Types.Add(CreateNotImplementedAstVisitorClass(nodeTypes));
using (StringWriter writer = new StringWriter()) {
new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
File.WriteAllText(visitorsDir + "NotImplementedAstVisitor.cs", NormalizeNewLines(writer));
}
Debug.WriteLine("DOM Generator done!");
Debug.WriteLine("start keyword list generation...");
KeywordGenerator.Generate();
Debug.WriteLine("keyword list generation 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);
#if !WIN8
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);
#else
var task = this.DataServiceBuilder.GenerateClientLayerCodeAsync(
new GenerateClientLayerCodeRequest(
serviceRoot.OriginalString,
this.DesignVersion,
this.ClientVersion,
language.FileExtension));
task.Wait();
var result = task.Result;
string clientCode = result.GenerateClientLayerCodeResult;
string errorMessage = result.errorLog;
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();
#endif
}
/// <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;
}
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!");
}
