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)); }