public void GenerateHandler()
{
_namespace = _namespace.AddMembers(_class);
_syntaxFactory = _syntaxFactory.AddMembers(_namespace);
var data = _syntaxFactory
.NormalizeWhitespace()
.ToFullString();
var patternAbsolutePath = _settings.GroupingStrategy switch
{
GroupByType.Concern => FileSystemUtility.CreateDirectory(new[] { _settings.DomainAbsolutePath, _settings.Concern, _settings.PatternType.ToString() }),
GroupByType.Operation => FileSystemUtility.CreateDirectory(new[] { _settings.DomainAbsolutePath, _settings.PatternType.ToString() })
};
//LogUtility.Info($"patternAbsolutePath: ${patternAbsolutePath}");
var concernAbsolutePath = _settings.GroupingStrategy switch
{
GroupByType.Concern => FileSystemUtility.CreateDirectory(new[] { _settings.DomainAbsolutePath, _settings.Concern, _settings.PatternType.ToString() }),
GroupByType.Operation => FileSystemUtility.CreateDirectory(new[] { patternAbsolutePath, _settings.Concern })
};
//LogUtility.Info($"concernAbsolutePath: ${concernAbsolutePath}");
var absoluteFilePath = FileSystemUtility.CreateFile(new[] { concernAbsolutePath, _settings.ClassName }, data);
//LogUtility.Info($"absoluteFilePath: ${absoluteFilePath}");
CleanUp();
}
public NamespaceDeclarationSyntax CreateTonModelClass(TypeElement typeElement)
{
NamespaceDeclarationSyntax ns = NamespaceDeclaration(IdentifierName(ClientGenerator.NamespaceModels));
return(typeElement.Type switch
{
TypeType.EnumOfConsts => ns.AddMembers(GenerateEnumOfConsts(typeElement)),
TypeType.EnumOfTypes => ns.AddMembers(GenerateEnumOfTypes(typeElement)),
TypeType.Struct => ns.AddMembers(GenerateStruct(typeElement)),
_ => throw new ArgumentOutOfRangeException(nameof(typeElement.Type), typeElement.Type, "Not supported type")
});
public override NamespaceDeclarationSyntax Handle(ASTNode definition, NamespaceDeclarationSyntax @namespace, IEnumerable <ASTNode> allDefinitions)
{
var objectTypeDefinition = definition as GraphQLObjectTypeDefinition;
var classDeclaration = SyntaxFactory.ClassDeclaration(objectTypeDefinition.Name.Value)
.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword))
.AddAttributeLists(GetTypeAttributes(objectTypeDefinition.Name.Value));
if (objectTypeDefinition.Interfaces != null && objectTypeDefinition.Interfaces.Any())
{
var baseList = SyntaxFactory.BaseList();
foreach (var interfaceImplementation in objectTypeDefinition.Interfaces)
{
baseList = baseList.AddTypes(SyntaxFactory.SimpleBaseType(
SyntaxFactory.ParseTypeName(interfaceImplementation.Name.Value)));
}
classDeclaration = classDeclaration.WithBaseList(baseList);
}
classDeclaration = this.CreateProperties(
objectTypeDefinition,
classDeclaration,
objectTypeDefinition.Fields,
allDefinitions);
return(@namespace.AddMembers(classDeclaration));
}
/// <summary>
/// Start code generation
/// </summary>
public void GenerateIntermediateCode()
{
if (Module == null)
{
throw new DataException("Please set Module before calling GenerateIntermediateCode()");
}
StandardFunctionRepository.Initialize(Module);
_compiledCode = SyntaxFactory.CompilationUnit();
MainClassNamespace = "Oberon0." + Module.Name;
MainClassName = Module.Name + "__Impl";
// Create a namespace: (namespace CodeGenerationSample)
_namespace = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName(MainClassNamespace))
.NormalizeWhitespace();
// Add System using statement: (using System)
_namespace = _namespace.AddUsings(SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("System")),
SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("AnyClone")));
GenerateClass();
_namespace = _namespace.AddMembers(_classDeclaration);
_compiledCode = _compiledCode.AddMembers(_namespace).NormalizeWhitespace();
}
public TestInfo[] Generate(string SourceCode)
{
SyntaxNode TreeRoot = CSharpSyntaxTree.ParseText(SourceCode).GetRoot();
List <TestInfo> result = new List <TestInfo>();
foreach (var SourceClass in TreeRoot.DescendantNodes().OfType <ClassDeclarationSyntax>())
{
string ClassName = SourceClass.Identifier.ValueText;
var methods = SourceClass.DescendantNodes().OfType <MethodDeclarationSyntax>().Where(method => method.Modifiers.Any(SyntaxKind.PublicKeyword));
NamespaceDeclarationSyntax NamespaceItem = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName("UnitTests"));
ClassDeclarationSyntax ClassItem = SyntaxFactory.ClassDeclaration($"{ClassName}Test").
AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword)).
AddAttributeLists(SyntaxFactory.AttributeList(SyntaxFactory.AttributeList().Attributes.Add(TestClassAttribute)));
var unit = SyntaxFactory.CompilationUnit().
AddUsings(FormUsings(TreeRoot)).
AddMembers(NamespaceItem.
AddMembers(ClassItem.
AddMembers(FormMethods(methods)
)));
result.Add(new TestInfo()
{
FileName = $"{ClassName}Test.cs", TestCode = unit.NormalizeWhitespace().ToFullString()
});
}
return(result.ToArray());
}
/// <summary>
/// Generate a constant string to update static code data.
/// </summary>
/// <param name="ianaOrgTlds"></param>
/// <returns></returns>
public static (string, string) GenCodes(IanaOrgTlds ianaOrgTlds)
{
StringBuilder tldConsts = new StringBuilder();
tldConsts.Append(GetAssetSymbolsHeader());
StringBuilder tldDict = new StringBuilder();
tldDict.Append(GetDictHeader());
foreach (string tld in ianaOrgTlds.List)
{
tldConsts.Append(GetConstant(tld.ToConstantCase()));
tldDict.Append(GetDict(tld));
}
tldConsts.Append(GetConstFooter());
tldDict.Append(GetDictFooter());
ClassDeclarationSyntax newClassNode = SyntaxFactory.ParseSyntaxTree(tldConsts.ToString()).GetRoot()
.DescendantNodes()
.OfType <ClassDeclarationSyntax>()
.FirstOrDefault();
NamespaceDeclarationSyntax parentNamespace = (NamespaceDeclarationSyntax)newClassNode?.Parent;
parentNamespace?.AddMembers(newClassNode).NormalizeWhitespace();
return(tldConsts.ToString(), tldDict.ToString());
}
private string GenerateRepositoryBaseClass()
{
string className = String.Join("", configuration.OperationClassPrefixName, configuration.OperationClassBaseName, CSharpLanguageSettings.BaseKeyWord);
string fileName = $"{className}.cs";
string fileLocation = Path.Combine(configuration.OperationsBaseFolderLocation, fileName);
if (!File.Exists(fileLocation))
{
CompilationUnitSyntax compilationUnit = SyntaxFactory.CompilationUnit();
NamespaceDeclarationSyntax @namespace = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName(
String.Join(".", configuration.ProjectName, configuration.OperationsFolderName, configuration.OperationsGeneratedFolderName)).NormalizeWhitespace());
ClassDeclarationSyntax classDeclaration = SyntaxFactory.ClassDeclaration(className)
.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword))
.AddModifiers(SyntaxFactory.Token(SyntaxKind.AbstractKeyword));
@namespace = @namespace.AddMembers(classDeclaration);
compilationUnit = compilationUnit.AddMembers(@namespace);
string fileContent = compilationUnit.NormalizeWhitespace().ToFullString();
File.WriteAllText(fileLocation, fileContent);
}
return(className);
}
public CompilationUnitSyntax StubInterface(CompilationUnitSyntax cu, InterfaceDeclarationSyntax interfaceDclr,
SemanticModel semanticModel)
{
INamedTypeSymbol interfaceType = semanticModel.GetDeclaredSymbol(interfaceDclr);
NamespaceDeclarationSyntax namespaceNode = GetNamespaceNode(interfaceDclr);
string interfaceName = interfaceType.GetGenericName();
string stubName = NamingUtils.GetStubName(interfaceName);
ClassDeclarationSyntax classDclr = SF.ClassDeclaration(SF.Identifier(stubName))
.AddModifiers(SF.Token(RoslynUtils.GetVisibilityKeyword(interfaceType)))
.WithBaseList(RoslynUtils.BaseList(interfaceName))
.AddAttributeLists(AttributeListList(Attribute("CompilerGenerated")).ToArray());
classDclr = RoslynUtils.CopyGenericConstraints(interfaceType, classDclr);
classDclr = AddStubContainerField(classDclr, stubName);
classDclr = StubProperties(interfaceType, classDclr);
classDclr = StubMethods(interfaceType, classDclr);
string fullNameSpace = semanticModel.GetDeclaredSymbol(namespaceNode).ToString();
NamespaceDeclarationSyntax namespaceDclr = SF.NamespaceDeclaration(SF.IdentifierName(fullNameSpace))
.WithUsings(namespaceNode.Usings);
namespaceDclr = namespaceDclr.AddMembers(classDclr);
cu = cu.AddMembers(namespaceDclr);
return(cu);
}
public override SyntaxNode VisitNamespaceDeclaration(NamespaceDeclarationSyntax node)
{
SyntaxTree tree = CSharpSyntaxTree.ParseText(ClassContent);
var root = (CompilationUnitSyntax)tree.GetRoot();
return(node.AddMembers(root.Members[0]));
}
private void GenerateOperationClass(OperationGroupContext operationGroupContext, string generatedClassName)
{
try
{
string className = String.Join("", configuration.OperationClassPrefixName, operationGroupContext.Name, configuration.OperationClassBaseName);
string fileName = $"{className}.cs";
string fileLocation = Path.Combine(configuration.OperationsFolderLocation, fileName);
if (!File.Exists(fileLocation))
{
CompilationUnitSyntax compilationUnit = SyntaxFactory.CompilationUnit();
NamespaceDeclarationSyntax @namespace = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName(
String.Join(".", configuration.ProjectName, configuration.OperationsFolderName)).NormalizeWhitespace());
ClassDeclarationSyntax classDeclaration = SyntaxFactory.ClassDeclaration(className)
.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword))
.AddBaseListTypes(SyntaxFactory.SimpleBaseType(SyntaxFactory.ParseTypeName(generatedClassName)));
@namespace = @namespace.AddMembers(classDeclaration);
compilationUnit = compilationUnit.AddMembers(@namespace);
string fileContent = compilationUnit.NormalizeWhitespace().ToFullString();
File.WriteAllText(fileLocation, fileContent);
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
public List <OutputFileInfo> GenerateTestClasses(string text)
{
List <OutputFileInfo> outputs = new List <OutputFileInfo>();
SyntaxNode root = CSharpSyntaxTree.ParseText(text).GetRoot();
IEnumerable <ClassDeclarationSyntax> classes = root.DescendantNodes().OfType <ClassDeclarationSyntax>();
foreach (ClassDeclarationSyntax cl in classes)
{
ClassDeclarationSyntax testClass = CreateTestClass(cl.Identifier.Text);
IEnumerable <SyntaxNode> methods = cl.DescendantNodes()
.OfType <MethodDeclarationSyntax>()
.Where(method => method.Modifiers.Any(SyntaxKind.PublicKeyword));
foreach (SyntaxNode method in methods)
{
testClass = testClass.AddMembers(CreateTestMethod((method as MethodDeclarationSyntax).Identifier.ValueText));
}
CompilationUnitSyntax syntaxFactory = SyntaxFactory.CompilationUnit();
NamespaceDeclarationSyntax @namespace = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName("CodeGenerationSample")).NormalizeWhitespace();
@namespace = @namespace.AddMembers(testClass);
syntaxFactory = syntaxFactory.AddUsings(usingDirectives()).AddMembers(@namespace);
string code = syntaxFactory.NormalizeWhitespace().ToFullString();
OutputFileInfo info = new OutputFileInfo(testClass.Identifier.ValueText + ".cs", code);
outputs.Add(info);
}
return(outputs);
}
public static CompilationUnitSyntax GenerateGlobalPropertiesProviderCompilationUnit(Workspace workspace, string targetNamespace, string className)
{
CompilationUnitSyntax unit = SyntaxFactory.CompilationUnit();
SyntaxList <UsingDirectiveSyntax> usings = SyntaxFactory.List(
new[]
{
Using("System.Collections.Immutable"),
Using("System.ComponentModel.Composition"),
Using("System.Threading"),
Using("System.Threading.Tasks"),
Using("Microsoft.VisualStudio.ProjectSystem"),
Using("Microsoft.VisualStudio.ProjectSystem.Build")
}
);
unit = unit.WithUsings(usings);
unit = unit.WithLeadingTrivia(GenerateLicenseHeader($"{className}.cs"));
NamespaceDeclarationSyntax ns = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.IdentifierName(targetNamespace));
ClassDeclarationSyntax cd = GenerateGlobalPropertiesProviderClass(className);
cd = cd.WithAttributeLists(GenerateExportBuildGlobalPropertiesProviderAttribute());
ns = ns.AddMembers(cd);
unit = unit.AddMembers(ns);
unit = (CompilationUnitSyntax)Formatter.Format(unit, workspace);
return(unit);
}
public CompileContext(Type baseType, Type modelType, string templateNamespace = null, string templateName = null, string templatePath = null, LogHandler logHandler = null)
{
_templateBaseType = baseType;
_location = new TemplateLocation(templatePath);
_macroManager = new MacroManager(baseType);
_modelTypeName = ClassContext.GetTypeName(modelType);
_stateTypeName = $"TxMark.Template.IState<{_modelTypeName}>";
_nameTagManager = new NameTagManager();
_bagsByReference = new Bag <object>();
_variableTypeByName = new Dictionary <string, VariableTypes>();
if (templateNamespace == null)
{
templateNamespace = DEFAULT_NAMESPACE;
}
if (templateName == null)
{
templateName = "Template_" + Guid.NewGuid().ToString().Replace('-', '_');
}
_logHandler = logHandler ?? DefaultLogHandler;
_codeContextStack = new Stack <ICodeContext>();
_metadataReferenceManager = new MetadataReferenceManager();
AddNamespaceFor(typeof(Microsoft.CSharp.RuntimeBinder.RuntimeBinderException));
AddNamespaceFor(typeof(DynamicObject));
AddNamespaceFor(typeof(string));
AddNamespaceFor(baseType);
AddNamespaceFor(modelType);
AddNamespaceFor(typeof(TemplateState <object>));
AddNamespaceFor(typeof(Dictionary <string, object>));
_namespace = SF.NamespaceDeclaration(SF.IdentifierName(templateNamespace));
_codeContext = new ClassContext(templateName, baseType, modelType, (classDeclaration) =>
{
_namespace = _namespace.AddMembers(classDeclaration);
List <UsingDirectiveSyntax> usingDirectives = new List <UsingDirectiveSyntax>();
foreach (var namespaceName in _usingNamespaces)
{
//usingDirectives.Add(SF.UsingDirective(SF.IdentifierName(namespaceName)));
}
_compilationUnit = SF.CompilationUnit();
//.AddUsings(usingDirectives.ToArray());
_compilationUnit = _compilationUnit.AddMembers(_namespace);
});
}
public override SyntaxNode VisitNamespaceDeclaration(NamespaceDeclarationSyntax node)
{
if (node.Name.ToString() == "NetcoreDbgTest.Script")
{
return(node.AddMembers(ScriptDeclarations.ToArray()));
}
return(node);
}
private SyntaxNode GenerateCompileUnit(I model, T @interface, NamespaceDeclarationSyntax @namespace)
{
@namespace = @namespace.AddMembers(@interface);
var declarations = model.Usings.Where(n => n != model.Namespace && !model.Namespace.HasParent(n)).OrderBy(u => u.FullName).Select(u => _syntaxGenerator.NamespaceImportDeclaration(u.FullName)).ToList();
declarations.Add(@namespace);
return(_syntaxGenerator.CompilationUnit(declarations));
}
public static NamespaceDeclarationSyntax WithDummyClass(this NamespaceDeclarationSyntax node)
{
var dummyClass = SyntaxFactory.ClassDeclaration(Constants.DummyClass)
.WithModifiers(SyntaxKind.PublicKeyword)
.WithGeneratedNonUserCodeAttributes()
.WithDefaultConstructor(false, SyntaxKind.PrivateKeyword)
.WithField(Constants.DummyClassInstance, Constants.DummyClass, SyntaxKind.PublicKeyword, SyntaxKind.StaticKeyword);
return(node.AddMembers(dummyClass));
}
NamespaceDeclarationSyntax GenerateStructs(NamespaceDeclarationSyntax ns)
{
return(ns.AddMembers(_idl.Structs.Select(e =>
StructDeclaration(e.Name)
.WithModifiers(TokenList(Token(_visibility)))
.AddAttribute("System.Runtime.InteropServices.StructLayout", "System.Runtime.InteropServices.LayoutKind.Sequential")
.AddModifiers(Token(SyntaxKind.UnsafeKeyword))
.WithMembers(new SyntaxList <MemberDeclarationSyntax>(SeparatedList(e.Select(m =>
DeclareField(m.Type.ToString(), m.Name, SyntaxKind.PublicKeyword)))))
).ToArray()));
}
public static NamespaceDeclarationSyntax WithDummyClass(this NamespaceDeclarationSyntax node)
{
const string dummyClassName = "Dummy";
var dummyClass =
CreateClass(dummyClassName)
.WithModifiers(SyntaxKind.PublicKeyword)
.WithAttributes(CreateGeneratedCodeAttribute(), CreateDebugNonUserCodeAttribute())
.WithDefaultConstructor(false, SyntaxKind.PrivateKeyword)
.WithField("Instance", dummyClassName, SyntaxKind.PublicKeyword, SyntaxKind.StaticKeyword);
return(node.AddMembers(dummyClass));
}
public async Task <string> Generate(string code)
{
var generator = new CommandBuilerGenerator();
var models = await GetModels(code);
var syntaxTree = models.syntaxTree;
var semanticModel = models.semanticModel;
var classToDecorate = models.syntaxTree.DescendantNodes().OfType <ClassDeclarationSyntax>().ToList();
if (classToDecorate.Count == 0)
{
return("No class found to decorate");
}
NamespaceDeclarationSyntax oldNamespace = classToDecorate[0].Parent as NamespaceDeclarationSyntax;
NamespaceDeclarationSyntax newNamespace = oldNamespace;
var classList = new List <MemberDeclarationSyntax>();
foreach (var classModel in classToDecorate)
{
var classSemantic = semanticModel.GetDeclaredSymbol(classModel);
if (HasBaseType(classSemantic, "DeviceActor"))
{
// ExternAliasDirectiveSyntax - Represents an ExternAlias directive syntax, e.g. "extern alias MyAlias;" with specifying "/r:MyAlias=SomeAssembly.dll " on the compiler command line.
var proxy = new TransformationContext(classModel, semanticModel, models.compilation, "", null, null);
var result = generator.Generate(proxy);
foreach (var res in result.Members)
{
ConsoleEx.WriteOKLine($"{classSemantic.Name}:");
ConsoleEx.Write($"{res.NormalizeWhitespace().ToFullString()}");
classList.Add(res);
}
}
}
foreach (var proxyClass in classList)
{
newNamespace = newNamespace.AddMembers(proxyClass);
}
syntaxTree = syntaxTree.ReplaceNode(oldNamespace, newNamespace);
Veryfy(syntaxTree);
return(syntaxTree.NormalizeWhitespace().ToFullString());
}
public override NamespaceDeclarationSyntax Handle(ASTNode definition, NamespaceDeclarationSyntax @namespace, IEnumerable <ASTNode> allDefinitions)
{
var objectTypeDefinition = definition as GraphQLInputObjectTypeDefinition;
var classDeclaration = SyntaxFactory.ClassDeclaration(objectTypeDefinition.Name.Value)
.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword))
.AddAttributeLists(GetTypeAttributes(objectTypeDefinition.Name.Value));
classDeclaration = this.CreateProperties(
objectTypeDefinition.Name.Value, classDeclaration, objectTypeDefinition.Fields, allDefinitions);
return(@namespace.AddMembers(classDeclaration));
}
public override NamespaceDeclarationSyntax Handle(ASTNode definition, NamespaceDeclarationSyntax @namespace, IEnumerable <ASTNode> allDefinitions)
{
var enumTypeDefinition = definition as GraphQLEnumTypeDefinition;
var enumDeclaration = SyntaxFactory.EnumDeclaration(enumTypeDefinition.Name.Value)
.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword))
.AddAttributeLists(GetTypeAttributes(enumTypeDefinition.Name.Value));
foreach (var value in enumTypeDefinition.Values)
{
enumDeclaration = enumDeclaration.AddMembers(SyntaxFactory.EnumMemberDeclaration(value.Name.Value));
}
return(@namespace.AddMembers(enumDeclaration));
}
NamespaceDeclarationSyntax GenerateEnums(NamespaceDeclarationSyntax ns)
{
return(ns.AddMembers(_idl.Enums.Select(e =>
EnumDeclaration(e.Name)
.WithModifiers(TokenList(Token(_visibility)))
.WithMembers(SeparatedList(e.Select(m =>
{
var member = EnumMemberDeclaration(m.Name);
if (m.Value != null)
{
return member.WithEqualsValue(EqualsValueClause(ParseExpression(m.Value)));
}
return member;
})))
).ToArray()));
}
private static string GenerateTest(IEnumerable <UsingDirectiveSyntax> usings, NamespaceDeclarationSyntax ns, ClassDeclarationSyntax @class)
{
usings = usings.Append(CreateUsingDirective("NUnit.Framework"));
usings = usings.Append(CreateUsingDirective("Moq"));
usings = usings.Append(CreateUsingDirective(FindFullNamespace(@class)));
CompilationUnitSyntax cu = SyntaxFactory.CompilationUnit().AddUsings(usings.ToArray());
NamespaceDeclarationSyntax testNamespace = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName($"{usings.Last().Name}.Tests"));
ClassDeclarationSyntax testClass = SyntaxFactory.ClassDeclaration(@class.Identifier.Text + "Tests").AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword));
testClass = testClass.AddMembers(GenerateSetUp(@class));
testClass = testClass.AddMembers(GenerateMethods(@class));
cu = cu.AddMembers(testNamespace.AddMembers(testClass));
return(cu.NormalizeWhitespace().ToFullString());
}
private static void GenerateSingleCSharpDocument(
IEnumerable <GeneratorResult> results,
SourceDocumentKind kind,
string fileName,
ICollection <SourceDocument> documents)
{
var code = new StringBuilder();
// marker for style cop to ignore this code
code.AppendLine("// <auto-generated/>");
// enable nullability settings
code.AppendLine("#nullable enable");
CompilationUnitSyntax compilationUnit = CompilationUnit();
foreach (var group in results.GroupBy(t => t.Result.Namespace).OrderBy(t => t.Key))
{
NamespaceDeclarationSyntax namespaceDeclaration =
NamespaceDeclaration(IdentifierName(group.Key));
foreach (var item in group)
{
BaseTypeDeclarationSyntax typeDeclaration = item.Result.TypeDeclaration;
#if DEBUG
SyntaxTriviaList trivia = typeDeclaration
.GetLeadingTrivia()
.Insert(0, Comment("// " + item.Generator.FullName));
typeDeclaration = typeDeclaration.WithLeadingTrivia(trivia);
#endif
namespaceDeclaration = namespaceDeclaration.AddMembers(typeDeclaration);
}
compilationUnit = compilationUnit.AddMembers(namespaceDeclaration);
}
compilationUnit = compilationUnit.NormalizeWhitespace(elasticTrivia: true);
code.AppendLine();
code.AppendLine(compilationUnit.ToFullString());
documents.Add(new(
fileName,
code.ToString(),
kind));
}
public async Task <CodeGenResult> CodeGen(Workspace workspace, Project project)
{
var usings = new HashSet <string>();
usings.UnionWith(GetCommonUsings());
CompilationUnitSyntax cu = SF.CompilationUnit();
foreach (Document document in project.Documents)
{
SyntaxTree syntaxTree = await document.GetSyntaxTreeAsync();
SemanticModel semanticModel = await document.GetSemanticModelAsync();
IEnumerable <InterfaceDeclarationSyntax> interfaces = syntaxTree.GetRoot().DescendantNodes().OfType <InterfaceDeclarationSyntax>();
bool copyDocumentUsings = false;
foreach (var interfaceNode in interfaces)
{
ClassDeclarationSyntax classDclr = GenerateApiControllerForInterface(interfaceNode, semanticModel);
if (classDclr == null)
{
continue;
}
// only copy the usings in the document if at least one ApiController is generated
copyDocumentUsings = true;
var namespaceNode = interfaceNode.Parent as NamespaceDeclarationSyntax;
// ReSharper disable once PossibleNullReferenceException
usings.UnionWith(namespaceNode.Usings.Select(@using => @using.Name.ToString()));
// use the same namespace in the generated class
string fullNameSpace = semanticModel.GetDeclaredSymbol(namespaceNode).ToString();
NamespaceDeclarationSyntax namespaceDclr = SF.NamespaceDeclaration(SF.IdentifierName(fullNameSpace)).WithUsings(namespaceNode.Usings);
namespaceDclr = namespaceDclr.AddMembers(classDclr);
cu = cu.AddMembers(namespaceDclr);
}
if (copyDocumentUsings)
{
usings.UnionWith(syntaxTree.GetRoot().DescendantNodes().OfType <UsingDirectiveSyntax>().Select(@using => @using.Name.ToString()));
}
}
return(new CodeGenResult(Formatter.Format(cu, workspace).ToString(), usings));
}
private static NamespaceDeclarationSyntax AddTypeToTargetNamespace(TypeDeclarationSyntax originalTargetType, NamespaceDeclarationSyntax targetNamespace, TypeDeclarationSyntax targetType)
{
if (originalTargetType != null)
{
targetNamespace = targetNamespace.RemoveNode(originalTargetType, SyntaxRemoveOptions.KeepNoTrivia);
}
else
{
var type = targetNamespace.DescendantNodes().OfType <TypeDeclarationSyntax>().FirstOrDefault(x => x.Identifier.ValueText == targetType.Identifier.ValueText);
if (type != null)
{
targetNamespace = targetNamespace.RemoveNode(type, SyntaxRemoveOptions.KeepNoTrivia);
}
}
targetNamespace = targetNamespace.AddMembers(targetType);
return(targetNamespace);
}
private void ParseOperationBinding(OperationBinding operationBinding, [CallerLineNumber] int callerLine = -1)
{
currentClass = ClassDeclaration(operationBinding.Name).WithModifiers(TokenList(new[] { Token(SyntaxKind.PublicKeyword), Token(SyntaxKind.PartialKeyword) }))
.WithLeadingTrivia(TriviaList(Comment(string.Format("//{0}:ParseOperationBinding:Sender", callerLine))))
.WithBaseList(BaseList(new SeparatedSyntaxList <BaseTypeSyntax>().Add(SimpleBaseType(ParseTypeName("SimpleSoapClient.Models.SimpleSoapClientBase")))));
ParseOperationBindingExtensions(operationBinding.Extensions);
ns = ns.AddMembers(currentClass);
currentClass = ClassDeclaration(operationBinding.Input.Name).WithModifiers(TokenList(new[] { Token(SyntaxKind.PublicKeyword), Token(SyntaxKind.PartialKeyword) }))
.WithLeadingTrivia(TriviaList(Comment(string.Format("//{0}:ParseOperationBinding:Input", callerLine))));
ParseOperationBindingExtensions(operationBinding.Input.Extensions);
ns = ns.AddMembers(currentClass);
currentClass = ClassDeclaration(operationBinding.Output.Name).WithModifiers(TokenList(new[] { Token(SyntaxKind.PublicKeyword), Token(SyntaxKind.PartialKeyword) }))
.WithLeadingTrivia(TriviaList(Comment(string.Format("//{0}:ParseOperationBinding:Output", callerLine))));
ParseOperationBindingExtensions(operationBinding.Output.Extensions);
ns = ns.AddMembers(currentClass);
}
private static void VisitClassDeclaration(ClassDeclarationSyntax node)
{
var parent = (CompilationUnitSyntax)node.Parent;
NamespaceDeclarationSyntax namespaceDeclaration = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.IdentifierName(" cls" + Guid.NewGuid().ToString("N")));
var newCompilationUnit = SyntaxFactory.CompilationUnit()
.AddMembers
(
namespaceDeclaration
.AddMembers
(
parent.Members.ToArray()
)
);
CSharpSyntaxTree.Create(newCompilationUnit);
}
public static string CreateTest(IEnumerable <UsingDirectiveSyntax> usings, ClassDeclarationSyntax @class)
{
var syntaxFactory = SyntaxFactory.CompilationUnit();
usings = usings.Append(CreateUsing("NUnit.Framework"));
usings = usings.Append(CreateUsing(GetClassFullName(@class)));
syntaxFactory = syntaxFactory.AddUsings(usings.ToArray());
NamespaceDeclarationSyntax testNamespace = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName(usings.Last().Name + ".Tests"));
ClassDeclarationSyntax testClass = SyntaxFactory.ClassDeclaration(@class.Identifier.Text + "Test").AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword));
testClass = testClass.AddMembers(CreateMethods(@class))
.AddAttributeLists(SyntaxFactory.AttributeList().AddAttributes(SyntaxFactory.Attribute(SyntaxFactory.IdentifierName("TestFixture"))));
testNamespace = testNamespace.AddMembers(testClass);
syntaxFactory = syntaxFactory.AddMembers(testNamespace);
return(syntaxFactory.NormalizeWhitespace().ToFullString());
}
private static NamespaceDeclarationSyntax Go(NamespaceDeclarationSyntax ns, Configuration config, Specification spec)
{
var className = ClassNameNormaliser(spec.Info.Title);
var constructorCode = $@"if (!string.IsNullOrWhiteSpace(url)){{ this.url = url;}} else {{ this.url = ""{spec.Schemes[0]}://{spec.Host}""; }}";
if (config.IncludeHTTPClientForCSharp)
{
constructorCode += Environment.NewLine + " if (httpClient == null){ this.httpClient = new SwaggerHTTPClient();} else { this.httpClient = httpClient; }";
}
var baseClass = SyntaxFactory.ClassDeclaration(className)
.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword))
.AddMembers(Field("url", "string").AddModifiers(SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword)),
Field("httpClient", "ISwaggerHTTPClient").AddModifiers(SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword)),
Constructor(className, constructorCode, new SimplifiedParameter("url", "string", "null", true), new SimplifiedParameter("httpClient", "ISwaggerHTTPClient", config.IncludeHTTPClientForCSharp ? "null" : null, true)))
.WithCloseBraceToken(SyntaxFactory.Token(SyntaxKind.CloseBraceToken));
if (spec.Definations != null)
{
foreach (var defination in spec.Definations)
{
baseClass = AddDefination(baseClass, defination, config);
}
}
foreach (var path in spec.Paths)
{
baseClass = AddOperation(baseClass, OperationConfig.FromValues(HTTPAction.Delete, path.Delete, path.Path), config);
baseClass = AddOperation(baseClass, OperationConfig.FromValues(HTTPAction.Get, path.Get, path.Path), config);
baseClass = AddOperation(baseClass, OperationConfig.FromValues(HTTPAction.Post, path.Post, path.Path), config);
baseClass = AddOperation(baseClass, OperationConfig.FromValues(HTTPAction.Put, path.Put, path.Path), config);
baseClass = AddOperation(baseClass, OperationConfig.FromValues(HTTPAction.Head, path.Head, path.Path), config);
baseClass = AddOperation(baseClass, OperationConfig.FromValues(HTTPAction.Options, path.Options, path.Path), config);
baseClass = AddOperation(baseClass, OperationConfig.FromValues(HTTPAction.Patch, path.Patch, path.Path), config);
}
if (config.IncludeHTTPClientForCSharp)
{
baseClass = baseClass.WithTrailingTrivia(SyntaxFactory.Comment(httpCode));
}
return(ns.AddMembers(baseClass));
}
